JSON_

一、什么是JSON?

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。JSON采用完全独立于语言的文本格式，而且很多语言都提供了对 json 的支持（包括 C, C++, C#, Java, JavaScript, Perl, Python等）。 这样就使得 JSON 成为理想的数据交换格式。

json 是一种轻量级的数据交换格式（相比较于xml）

数据交换指的是客户端和服务器之间业务数据的传递格式。

二、JSON在JavaScript中的使用

1、json的定义

json 是由键值对组成，并且由花括号包围。每个键由引号引起来，键和值之间使用冒号进行分隔，多组键值对之间进行逗号进行分隔

// json的定义                               
var jsonObj={                            
	"key1":20,                           
	"key2":"cxc",                        
	"key3":true,                         
	"key4":[1,"cc",false],//值可以是数组       
	"key5":{			  //json对象类型     
		"key5_1":551,                    
		"key5_2":"key5_2value"           
	},                                   
	"key6":[{			 //json数组        
		"key6_1_1":6611,                 
		"key6_1_2":"key6_1_2value"       
	},{                                  
		"key6_2_1":6621,                 
		"key6_2_2":"key6_2_2value"       
	}]                                   
}                                        

2、json的访问

• json本身是一个对象

alert(typeof (jsonObj));//object json就是一个对象  

• json 中的 key 我们可以理解为是对象中的一个属性。
• json 中的 key 访问就跟访问对象的属性一样： json 对象.key

alert(typeof (jsonObj));//object json就是一个对象                             
//json的访问                                                               
alert(jsonObj.key1);  //20                                              
alert(jsonObj.key2);  //cxc                                             
alert(jsonObj.key3);  //true                                            
alert(jsonObj.key4);  //数组 [1,"cc",false]                               
//json中数组遍历                                                             
for (var i=0;i<jsonObj.key4.length;i++){                                
	alert(jsonObj.key4[i]);                                             
}                                                                       
                                                                        
alert(jsonObj.key5);		//[object Object]                           
alert(jsonObj.key5.key5_1);  //551                                      
alert(jsonObj.key5.key5_2)   //key5_2value                              
                                                                        
alert(jsonObj.key6);   	//得到json数组，[object Object],[object Object]      
                                                                        
var jsonItem =jsonObj.key6[0];                                          
alert(jsonItem.key6_1_1);       //6611                                  
alert(jsonItem.key6_1_2);       //key6_1_2value                         

3、json的两个常用方法

• JSON.stringify() ------ 把 json 对象转换成为 json 字符串
• JSON.parse() --------- 把json 字符串转换成为 json 对象

• json 的存在有两种形式。
  1、对象的形式存在，我们叫它 json 对象。
  2、字符串的形式存在，我们叫它 json 字符
• 一般我们要操作 json 中的数据的时候，需要 json 对象的格式
• 一般我们要在客户端和服务器之间进行数据交换的时候，使用 json字符串

//把json对象转换成json字符串                                                           
var jsonObjString =JSON.stringify(jsonObj); //像java中对象的toString               
alert(jsonObjString);                                                         
                                                                              
//把json字符串，转换成json对象                                                          
var jsonObj2=JSON.parse(jsonObjString);                                       
alert(jsonObj2);   	//[object Object]                                         
alert(jsonObj2.key1);    //20                                                 
alert(jsonObj2.key2);    //cxc                                                

三、JSON在Java中的使用

首先导入jar包

创建一个Person类

1、javaBean 和 json 的互转

@Test                                                                 
public void test1(){                                                  
    Person person=new Person(1,"cxc");                                
                                                                      
    //创建Gson对象实例                                                      
    Gson gson=new Gson();                                             
    //toJson方法可以把Java对象转换成为json字符串                                    
    String psersonJsonString = gson.toJson(person);                   
    System.out.println(psersonJsonString);                            
                                                                      
    //fromJson把json字符串转换成为java对象                                      
    //第一个参数：json字符串                                                   
    //第二个参数：转换回去的Java对象类型                                             
    Person person1 = gson.fromJson(psersonJsonString, Person.class);  
    System.out.println(person1);                                      
}                                                                     

2、List 和 json 的互转

@Test                                                                                               
public void test2(){                                                                                
    List<Person> personList=new ArrayList<>();                                                      
                                                                                                    
    personList.add(new Person(1,"cxc"));                                                            
    personList.add(new Person(2,"fjm"));                                                            
                                                                                                    
    Gson gson=new Gson();                                                                           
                                                                                                    
    //把List转换成为json字符串                                                                              
    String personListJsonString = gson.toJson(personList);                                          
    System.out.println(personListJsonString);                                                       
                                                                                                    
    ArrayList<Person> list = gson.fromJson(personListJsonString, new PersonListType().getType());   
    System.out.println(list);                                                                       
    Person person = list.get(0);                                                                    
    System.out.println(person);                                                                     
}                                                                                                   

将json字符串转换成ArrayList需要创建一个类继承TypeToken

3、map 和 json 的互转

@Test                                                                                                                        
public void test3(){                                                                                                         
    Map<Integer,Person> personMap=new HashMap<>();                                                                           
    personMap.put(1,new Person(1,"cxc"));                                                                                    
    personMap.put(2,new Person(2,"fjm"));                                                                                    
                                                                                                                             
    Gson gson=new Gson();                                                                                                    
    //把map集合转换成为json字符串                                                                                                      
    String personMapJsonString = gson.toJson(personMap);                                                                     
    System.out.println(personMapJsonString);                                                                                 
                                                                                                                             
    //使用匿名内部类（省去了额外创建一个类）                                                                                                    
    Map<Integer,Person> personMap2=gson.fromJson(personMapJsonString, new TypeToken<HashMap<Integer,Person>>(){}.getType()); 
    System.out.println(personMap2);                                                                                          
    Person p= personMap2.get(1);                                                                                             
    System.out.println(p);                                                                                                   
}                                                                                                                            

以上使用匿名内部类创建TypeToken对象，省去了额外创建一个类去继承TypeToken