java 取JSONObject里数组 java获取json中的数组

1.Javascript中的数组
  数组的创建
  数组下标操作
  数组的方法
 
  concat join slice 不修改原数组
 
  push pop unshift shift reverse sort splice 修改原数组

2.Javascript中简单对象的创建与属性操作
  简单对象的创建
  简单对象属性的添加
  简单对象属性的访问
通过对象直接量的方式定义包含属性的对象

3.JSON数据格式
  JSON(Javascript Object Notation)是一种轻量级的数据交换格式。
  纯文本，Javascript原生支持
  与XML相比：
     优势实在Javascript当中解析快，操作方便，不需要使用DOM。
     缺点是在服务器端，生成正确的JSON格式数据与生成XML格式数据相比，服务器端语言的辅助包成熟度较低。
 
 
4.面向对象的Javascript
类的定义
公用属性和方法的定义
原型对象


===================================================

1.Javascript中的数组

数组的创建

1. <script type="text/javascript">  
2.   
3.         function arrayTest(){  
4. //使用new Array()
5. new
6. //使用[]操作符
7.             var array2 = [];  
8.               
9. //创建的同时定义数组中的元素
10. //使用new Array()方式
11. new Array(1,2,3);  
12. //使用[]操作符
13. 1,2,3];  
14.             
15. //创建多维数组
16. //使用new Array()方式
17. new Array(1,new Array(2,3),4);  
18.               
19. //使用[]操作符
20. 1,[2,3],4];  
21.             
22. //数组的下标操作
23. //获取数组中的某元素的值
24. 1]);  
25. //设置数组中某个下标对应的元素值
26. 2] = 111;  
27. //访问对维数组中的元素
28. 1][0]);  
29. //javascript中的数组时可以动态改变大小的，因此可以直接给一个不存在的下标设置元素值
30. 99] = 100;  
31.             
32. //数组中的方法
33. //concat,这个方法可以用来做数组的连接或者说合并,原数组内容不会变更,将返回一个新的数组
34. 101,102,103);  
35. 104,105]);  
36.           var array43 = array.concat(array4);  
37.             
38. //join,这个方法可以将数组当中的元素，按照指定的分隔符连接成字符串输出，原数组的内容不会变
39. "");//1211112111
40. "+");//1+2+111+1+2+111
41.             
42.             
43. //slice,这个放好可以返回当前数组的子数组，原始数组的内容不会改变
44. 0,3);//从0下标开始,到3下标之前的元素返回新的数组[1,2,111]
45. 4);//从4下标开始,到数组尾部的所有元素都返回成新的数组[2,111]
46. //从当前数组的倒数第二个元素开始,当前数组倒数第一个元素之前的所有内容返回一个新的数组[2]
47. 2,-1);  
48.             
49.             
50. //push,pop,在数组尾端追加(push)或弹出(pop)元素,将会修改原数组的内容
51. 200);  
52. 201,202);  
53. 201,202]);  
54.           array43.push(array41);  
55.           var arraypop = array43.pop();  
56.           var arraypop = array43.pop();  
57.             
58.             
59. //unshift,shift,在数组的开头进行追加(unshift)和弹出(shift)的操作,将会修改原数组的内容
60. 300);  
61. 301,302);  
62. 303,304]);  
63.           var arrayshift = array43.shift();  
64.           var arrayshift2 = array43.shift();  
65.             
66. //reverse,这个方法可以翻转数组中的元素，修改原数组的内容
67.           array43.reverse();  
68.             
69. //sort,这个方法可以对数组中的元素进行排序，修改原数组的内容
70. //无参,是按照字母顺序对数组中的元素进行了升序的排列
71.           array43.sort(function(a,b){  
72. return
73. //就是按照数值大小，进行一个升序的排列。如果返回的是负值，则a会出现在b的前面
74.             
75.           array43.sort(function(a,b){  
76. return
77. //就是按照数值大小，进行一个降序的排列。
78.             
79. //splice,可以删除数值中的一部分元素，并且把删除的内容进行返回，原数组的内容会发生变更，还可以在制定位置添加元素
80. //第一个参数,删除元素开始的下标位置
81. //删除元素的个数
82.           array43.splice(index,howMany,element1,elementN);  
83. //用局部变量来接收删除的返回值，会把删除部分的内容进行返回
84. 4,2);//从下标为4的元素开始,删除两个元素
85. 4); //从下标为4的元素开始,直到数组末尾的所有元素都被删除
86.             
87. 1,0,400,401);//从下标为1的元素之前,0表示不删除，插入400,401
88. 1,0,[500,501]);//从下标为1的元素之前插入500,501
89.             
90.           
91.         }  
92.   
93. </script>

===================================================================

2.Javascript中简单对象的创建与属性操作

1. <script type="text/javascript">  
2.    
3.         function objectTest(){  
4. //方式1,通过new Object()
5. new
6. //方式1,通过{}操作符
7.             var obj2 = {};  
8.               
9. //增加属性，使用.操作符
10. //使用new Array()方式
11. 1;  
12. "String";  
13.           obj1.hell = function(){  
14. "hello!");  
15.           }  
16.           obj2.obj = obj1;  
17.             
18.             
19. //属性的访问，方法1，使用.操作符
20.           alert(obj2.obj.num);  
21.           alert(obj2.obj.str);  
22.           obj1.hello();  
23. //属性的访问，方法2，使用[]操作符
24. "obj"]["num"]);  
25. "obj"]["str"]);  
26. "hello"]();  
27.            
28. "");  
29.             
30. //对象直接量定义方法，利用{}
31.           var obj3 = {  
32. 1,  
33. "String",  
34.                                 hello；function(){  
35. "hello!");                                  
36.                                 }           
37.           };  
38.   
39.         }  
40.    
41.  </script>

======================================================================

3.JSON数据格式

1. <script type="text/javascript">  
2.    
3.         function jsonTest(){  
4. //JSON数据格式定义
5. "[1,2,{"
6. "a:123,b:'String',c:[100,101]'"
7. "}]";  
8.                            
9. //javascript的一个内置方法eval（),返回回json这段数据格式所对应的javascript的数组或者对象
10.             var jsonArray = eval（json1);  
11.               
12. "{"
13. "a:'hello', b:[1,2,3], c:function(){ alert(\"Hi!!!\") }"
14.                            
15. "}";  
16. //错误写法            
17. //var jsonObject = eval（json2);
18.               
19. //正确的写法
20. "(" + json2 + ")"
21.               
22.               
23.             如果从服务器端返回回来的json数据格式 他最终代表的是一个数组，可以直接用eval的方式对他进行执行，  
24.             返回javascript里面的一个数组。  
25.             如果从服务器端返回的json格式对应的是一个对象，我们必须要在他的外层加上括号(),  
26.             才会返回正确的对象，否则会报错。  
27.   
28.               
29.         }  
30.    
31.  </script>

======================================================================

4.面向对象的Javascript

1. <script type="text/javascript">  
2. //javascript中类的定义，需要靠function来模拟
3. /*
4.         function Teacher(){
5.         
6.         }*/
7.           
8. //建议采用下面的形式来定义一个js中的类，可以和普通的function进行区分
9. //建议类名首字母大写，以便更好的和普通的function进行区分
10.         var Teacher = function(){  
11.           
12.         }  
13.           
14. //定义一个Book的类,这个function还承担了模拟构造函数的工作
15. //在使用new操作符创建Book类的对象时，这个function中的代码会被执行
16. //这里面的this代表当前对象
17. /*
18.         var Book = function(name){
19.                     //定义共有的属性
20.                     this.name = name;
21.                     //定义共有的方法
22.                     this.getName = function(){
23.                         return this.name;
24.                     };
25.                     this.setName = function(name){
26.                         this.name = name;
27.                     }
28.         }*/
29.           
30.           
31. /*********************************************
32.         //一种更为合适的公有属性和方法定义
33.         var Book = function(name){
34.                 //Book.prototype.name=name;
35.                 //公有属性，在构造方法里面来定义，通过this关键字
36.                 this.name = name;
37.         }
38.         //Book.prototype.name="";//优先访问对象上的属性，即这里的this.name,没有才会访问(找)原型对象上的name;
39.         //公有的方法，在原型对象上定义
40.         Book.prototype.setName = function(name){
41.                 this.name = name;
42.         };
43.         
44.         Book.prototype.getName = function(){
45.                 return this.name;
46.         };**************************************/
47.           
48.           
49.           
50. //一种更为合适的公有属性和方法定义
51.         var Book = function(name){  
52. //Book.prototype.name=name;
53. //公有属性，在构造方法里面来定义，通过this关键字
54. this.name = name;  
55.       
56. if(typeof Book._init = "undefined"){  
57. //公有的方法，在原型对象上定义
58.                         Book.prototype.setName = function(name){  
59. this.name = name;  
60.                         };  
61.                   
62.                       Book.prototype.getName = function(){  
63. return this.name;  
64.                     };  
65.                 }  
66. true;  
67.           
68.         };  
69.           
70.           
71.           
72.           
73.         function ooTest(){  
74. new
75. instanceof
76. new Book("AJAX");//这个new操作相当于创建了一个简单对象，调用了类的构造方法
77. new Book("AJAX1");  
78.            alert(book1.getName());  
79.            alert(book2.getName());  
80.              
81. "JAVA");  
82.            alert(book1.getName());  
83.            alert(book2.getName());  
84.              
85. //function上面都有一个原型对象
86.            var proto = Book.prototype;  
87. "String";  
88.            proto.hello = function(){  
89. "Hello");  
90.            };  
91. //原型对象上定义了属性之后，拥有这个原型对象的function，
92. //它所模拟的类创建出的对象，就可以拥有原型对象上定义的属性
93.      
94.              
95.            alert();  
96.           
97.         }  
98.    
99.  </script>

-----------------------------------------------------------------

1. <script type="text/javascript">  
2. //展示原型对象上定义公有属性的另一个问题
3.         var Teacher = function(){     
4.         }  
5.         Teacher.prototype.student=[];  
6.       
7.         Teacher.prototype.addStudent = function(sname){  
8. this.student.push(sname);  
9.         };  
10.           
11.         Teacher.prototype.showStudent = function(){  
12. this.student);  
13.         };  
14.           
15.           
16.         function oo4Test(){  
17. new
18. new
19.      
20. "wang");  
21. "lee");  
22.            teacher1.showStudent();  
23.            teacher2.showStudent();  
24.            alert();  
25.           
26.         }  
27.    
28.  </script>