Json

Posted 2021-01-07 breeze

　　Json  全称javascript Object Notation，是一种轻量级的数据交换格式。 本质就是具有特定格式的字符串，完全独立于编程语言，其传输有效性比XML 数据传输的有效性高，并且流量消耗更低，被大量使用，但是其语义性相对XML 较差，不如XML直观， 但是差别不大。

• 具有良好的可读和便于快速编写的特性。
• 业内主流技术为其提供了完整的解决方案（有点类似于正则表达式 ，获得了当今大部分语言的支持）
• JSON采用兼容性很高的文本格式，同时也具备类似于C语言体系的行为。 – Json.org
• JSON作为数据是目前网络中主流的数据传输格式之一，应用十分广泛。

    Json 支持哪些数据类型：

　　　　 我们要使用Json 解析，就必须对其规则原理有所了解，然后才能实现功能。 

       Json中的数据是一种类似于Map的键值对的存在其（”key”:”value”）中值的类型可以是下面数据类型中的任意一种： 

1. 数字（整数或浮点数） 
2. 逻辑值（true 或 false） 
3. 字符串（在双引号中） 
4. 数组（在方括号中） 
5. 函数 
6. 对象（在大括号中） 
7. null

  　　语法规则：

大括号’{ }’，  对象型
中括号’[ ]’，  数组型
逗号’，’， 
冒号’：’， 
双引号’“”’。

  数据类型： 嵌套对象，数组，字符串，数字，布尔值，或空值。

  Json 解析中 ，有三种情况。 

1.｛｝ 解析’大括号’类型 
2. [ ] 解析是’中括号’类型 
3. 1与2的组合方法  像”｛’name’:’张三’ ，’like’:[‘编程’,’游戏’,’睡觉’]｝”

那我们来 具体看看 栗子， 怎么解析这三种情况 ： 

• Objec 对象型：

　　用{ }包含一系列无序的key–Value键值对表示，其中Key和Value之间用冒号分割，每个key-value之间用逗号分割。

 1 //大括号Object类型数据：
 2  
 3 String Obj =“{
 4 
 5      ‘name‘ : ‘张三‘,
 6       ‘ age ‘ ： ‘ 20 ‘ ,
 7      ‘name‘ :‘ 李四‘
 8      ‘age ‘ ： ‘ 24‘,          //键值对之间用冒号隔开，每一对用逗号隔开。
 9 
10 
11 }”; 

• Array  数组类型

　　　　使用[ ]包含所有元素，每个元素用逗号分隔，元素可以是任意的值

1 // 中括号保存数组
2   String     jsonarray = "["周一","周二","周三"，123，adcd，null]"；
3  
4    访问元素采用数组的访问， 使用下标索引， 从0 开始

• 组合类型

 

// 组合嵌套 1 
 String jsonObj = "{ 
          ‘name‘:‘张三‘，
          ‘age‘ ：‘ 24‘,
          ‘like‘ : ‘{‘tpye‘ : ‘篮球‘，‘other ‘：‘足球‘}‘
}" ；

 // 组合嵌套2
  String JsonObj2 = "{

          ‘name‘:‘张三‘，
          ‘age‘ ：‘ 24‘,
          ‘like‘ : [{‘tpye‘ : ‘篮球‘，‘other ‘：‘足球‘}
                    {‘type‘:‘唱歌‘，‘other‘：‘跳舞‘ }]                              

}"；               

 

 Json数据的解析：

两条规则： 

• 1.如果看到是{ }–>使用JSONObject
• 2.如果看到的[ ]–>使用JSONArray

  一  ：  纯对象(Object)的解析{ }:　

import org.json.JSONException;
import org.json.JSONObject;
 // JSON-->纯对象(Object)的解析，我们在eclipse里面操作JSON解析的时候需要第三方jar包的支持
public class Json1{
    public static void main(String[] args) {
//      编辑一个我们要解析的数据对象
//     根据JSON的官方定义，键，加"",值，如果是字符串，就加""，其他不加。
        String json="{‘name‘:‘张三‘,‘age‘:24}"; 
        try {
//          创建JSON解析对象(两条规则的体现:大括号用JSONObject,注意传入数据对象)
            JSONObject obj = new JSONObject(json);
//          obj.后面有各种数据类型,根据对象来选择使用的数据类型
            String name = obj.getString("name");
//          同上，这里的age为Int类型，我们就用对应的类型进行解析
            int age = obj.getInt("age");
//          最后输出到控制台
            System.out.println(name+" ： "+age); 
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }
}

 

   　　二 ： 纯数组(Array)的解析[ ]： 

 1 import org.json.JSONArray;
 2 import org.json.JSONException;
 3  
 4 public class Json2{
 5     public static void main(String[] args) {
 6 //      编辑一个我们要解析的数据对象
 7         String json="[‘周一‘,‘周二‘,‘周三‘,‘周四‘，‘周五‘]";
 8         try {
 9 //          创建JSON解析对象(两条规则的体现:中括号用JSONArray,注意传入数据对象)
10             JSONArray jArray = new JSONArray(json);
11 //          取得数组长度
12             int length = jArray.length();
13 //          数组的取值的方式 --->for循环遍历数组--->得到值
14             for (int i = 0; i < length; i++) {
15 //              根据解析的数据类型使用该类型的get方法得到该值，打印输出
16                 String string = jArray.getString(i);
17                 System.out.print(string+",");
18             }
19  
20         } catch (JSONException e) {
21             // TODO: handle exception
22         }
23     }
24 }

 

  　　三 ： 组合类型的解析：

   举个栗子  ： 

　　String json=”{‘name’:’张三’,’boy’:{‘name’:’李四’,’age’:18}}”;

分析: 我们首先是解析外面的大括号的对象，然后，通过boy，获取到对应的被包含的里面大括号对象。所以这里我们需要建立一个类,封装对应的数据字段，根据setName ,setAge的方式在去得到对应的值

 　　先创建一个POJO

 1 //创建一个Person用于接收解析数据，封装对应字段
 2  
 3 public class Person {
 4 //    分析我们要解析的对象，根据解析对象的属性值去创建对应的属性值
 5 //    根据分析我们所要解析的对象，两条属性 1.name(String类型) 2.是boy(类类型,意味着还需要在类中去嵌套一个类(创建类部类也可))
 6 //  　　相当于是我们进行两次对象解析，对象中又分别进行数组解析
 7 //   封装字段
 8     private String name;
 9     private Boy boy;  //类类型
10 //   setter getter方法
11     public String getName() {
12         return name;
13     }
14     public void setName(String name) {
15         this.name = name;
16     }
17     public Boy getBoy() {
18         return girlFriend;
19     }
20     public void setBoy(Boy boy) {
21         this.boy= boy;
22     }
23  
24 //   toString方法用于控制台输出
25     @Override
26     public String toString() {
27         return "Person [name=" + name + ", boy=" + boy+ "]";
28     }
29  
30 }
31  
32 // 为了方便看，这里创建了一个Boy这个类,也是POJO
33 class Boy{
34 //   根据对象属性值，创建对应的值
35     private String name;
36     private int age;
37 //   setter getter方法
38     public String getName() {
39         return name;
40     }
41     public void setName(String name) {
42         this.name = name;
43     }
44     public int getAge() {
45         return age;
46     }
47     public void setAge(int age) {
48         this.age = age;
49     }
50 //   toString方法用于控制台输出
51     @Override
52     public String toString() {
53         return "Boy[name=" + name + ", age=" + age + "]";
54     }

 

然后 开始解析过程

import org.json.JSONException;
import org.json.JSONObject;
 
//组合数据类型的解析--->对象嵌套对象类型
public class Json3{
    public static void main(String[] args) {
//      编辑一个我们要解析的数据对象
//      分析: 应该先解析外面的大的对象，然后，通过Boy，获取到对应的被包含的对象。
//      所以这里我们需要建立一个类,封装对应的数据字段，根据setName ,setAge的方式在去得到对应的值
 
    String json=”{‘name‘:’张三’,’boy’:{‘name‘:’李四’,’age’:18}}”;
        try {
//          1.创建JSON解析对象(两条规则的提现:大括号用JSONObject,注意传入数据对象)
            JSONObject jObj = new JSONObject(json);
//          2.实例化Person对象获取对应的值--->这里是获得外面大括号{}的name值 里面{}如何获得?
            Person per=new Person();
            String name = jObj.getString("name");
            per.setName(name);
//          3.分析:里面{}是嵌套在外面大括号类的所以我们解析的对象是通过外面大括号去取得里面大括号值，注意看
            //取得对应里面大括号的boy,取得name值，赋值给boy对象
            Boy boy=new Boy();
            JSONObject jObj1 = jObj.getJSONObject("boy");
            String boyName = jObj1.getString("name");
            girlFriend.setName(gfName);
//          获得age值并赋值
            int gfAge = jObj1.getInt("age");
            girlFriend.setAge(gfAge);
//          通过set把Boy的值赋Person 用于toString的输出，不然为空
            per.setBoy(boy);
//          输出
            System.out.println(per);
    }catch (JSONException e) {
        e.printStackTrace();
    }
    }
}

 

  总结下 如何对于 ｛[ { },{ } ]｝ 类型进行解析：

　　第一步看到大括号：JSONObject去解,创建好对应里面的属性的值；第二步看到中括号：JSONArray去解析 对应创建好对应里面的属性值；第三步中括号里面的{ }，又是一个JSONObject。大致如此，强调注意的是，设置的属性值setXxx getXxx必须要和去获得值名称一致，不然会出现错误。

    大致的解析就如此了。