自己动手实现JSON解析_自建json视频解析接口

不积跬步，无以至千里；不积小流，无以成江海。要沉下心来，诗和远方的路费真的很贵！

参考博客：小胡老师的博客

JSON数据结构

概念

JSON数据结构是一种与开发语言无关、轻量级的数据存储格式，全称JavaScript Object Notation。是一种数据格式的标准规范。

优点：易于人的阅读和编写，易于程序解析与生产，它相比xml格式的数据结构，占用的数据空间更小。

JSON解析

JSON对象解析

JSON对象结构格式：外面是一个大括号，表示JSON数据结构，里面是Key-Value的存储形式，它们之间用,隔开。

{
  "id": 1,
  "name": "KG",
  "age": 20,
  "isMan": true
}
1
2
3
4
5
6

key一般是字符串，value可以是int、string、boolean、NULL等类型。

以前安卓需要导入json库，现在可以直接用，都已经内置于Android的系统库。

 //构造接口返回的数据
        String s = "{\"id\": 1,\"name\": \"KG\",\"age\": 20,\"isMan\": true}";
        try {
            //json解析
            JSONObject jsonObject = new JSONObject(s);
            //get方法根据key得到value
            int age = jsonObject.getInt("age");
            String name = jsonObject.getString("name");
            boolean isMan = jsonObject.getBoolean("isMan");
            System.out.println("name:" + name + "," + "age:" + age + ",isMan:" + isMan);
        } catch (JSONException e) {
            e.printStackTrace();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13

JSON数组解析

JSON数组结构格式：采用[]表示数组，里面全部都是value，中间用,隔开。

["KG", "JK", "KH", "KZ"]
1

value可以是int、string、boolean、NULL等类型。

//构造接口返回的数据
        String res = "[ \"KG\", \"JK\", \"KH\",\"KZ\" ]";
        try {
            //json解析
            JSONArray jsonArray = new JSONArray(res);
            //遍历数组
            for(int i=0;i<jsonArray.length();i++){
                //得到每一个对象
                String s = (String) jsonArray.get(i);
                System.out.println("第"+ i +"个对象:" + s + ",");
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

JSON对象嵌套解析

value是一个JSON对象，即为JSON对象嵌套。

{
  "id": 1,
  "name": "KG",
  "isMan": true,
  "class": {
    "grade": "18级",
    "classname": "信息管理与信息系统"
  }
}
1
2
3
4
5
6
7
8
9

//构造接口返回的数据
        String res = "{\"id\":1,\"name\":\"KG\",\"isMan\":true," +
                "\"class\":{\"grade\":\"18级\",\"classname\":\"信息管理与信息系统\"}}";
        try {
            //json解析
            //最外面是一个对象
            JSONObject jsonObject = new JSONObject(res);
            //get方法得到值
            int id = jsonObject.getInt("id");
            String name = jsonObject.getString("name");
            boolean isMan = jsonObject.getBoolean("isMan");
            //得到嵌套的json对象
            JSONObject jsonObject1 = jsonObject.getJSONObject("class");
            String grade = jsonObject1.getString("grade");
            String classname = jsonObject1.getString("classname");
            System.out.println("id:" + id + ",name:" + name + ",isMan:" + isMan
                    + ",年级:" + grade + ",班级:" + classname);
        } catch (JSONException e) {
            e.printStackTrace();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

JSON对象嵌套数组解析

首先外面是一个整的JSON对象，里面存在数组。

{
  "grade": "18级",
  "classname": "信息管理与信息系统",
  "students": ["WSW", "HFC", "HRK", "LJK"]
}
1
2
3
4
5

//构造接口返回的数据
        String res = "{\"grade\":\"18级\",\"classname\":\"信息管理与信息系统\"," +
                "\"students\":[\"WSW\",\"HFC\",\"HRK\",\"LJK\"]}";
        try {
            //json解析
            //最外面是一个对象
            JSONObject jsonObject = new JSONObject(res);
            //get方法得到值
            String grade = jsonObject.getString("grade");
            String classname = jsonObject.getString("classname");
            System.out.println("grade:" + grade + ",classname:" + classname);
            //得到嵌套的json数组
            JSONArray jsonArray = jsonObject.getJSONArray("students");
            //遍历数组
            for(int i=0;i<jsonArray.length();i++){
                //得到第i个对象
                String s = (String) jsonArray.get(i);
                System.out.println("第" + (i+1) + "个学生:" + s + ",");
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

JSON对象嵌套数组再嵌套对象解析

首先外面是一个对象，里面有一个数组，数组中的value又是对象。

{
  "id": 1,
  "name": "KG",
  "isMan": true,
  "course": [{
    "cid": "10001",
    "cname": "高等数学",
    "teacher": "JM"
  }, {
    "cid": "10002",
    "cname": "线性代数",
    "teacher": "FG"
  }, {
    "cid": "10003",
    "cname": "离散数学",
    "teacher": "WCF"
  }]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//构造接口返回的数据
        String res = "{\n" +
                "  \"id\": 1,\n" +
                "  \"name\": \"KG\",\n" +
                "  \"isMan\": true,\n" +
                "  \"course\": [{\n" +
                "    \"cid\": \"10001\",\n" +
                "    \"cname\": \"高等数学\",\n" +
                "    \"teacher\": \"JM\"\n" +
                "  }, {\n" +
                "    \"cid\": \"10002\",\n" +
                "    \"cname\": \"线性代数\",\n" +
                "    \"teacher\": \"FG\"\n" +
                "  }, {\n" +
                "    \"cid\": \"10003\",\n" +
                "    \"cname\": \"离散数学\",\n" +
                "    \"teacher\": \"WCF\"\n" +
                "  }]\n" +
                "}";
        try {
            //json解析
            //最外面是一个对象
            JSONObject jsonObject = new JSONObject(res);
            //get方法得到值
            int id = jsonObject.getInt("id");
            String name = jsonObject.getString("name");
            boolean isMan = jsonObject.getBoolean("isMan");
            System.out.println("id:" + id + ",name:" + name + ",isMan:" + isMan);
            //得到嵌套的json数组
            JSONArray jsonArray = jsonObject.getJSONArray("course");
            //遍历数组
            for(int i=0;i<jsonArray.length();i++){
                //得到第i个对象
                JSONObject jsonObject1 = (JSONObject) jsonArray.get(i);
                String cid = jsonObject1.getString("cid");
                String cname = jsonObject1.getString("cname");
                String teacher = jsonObject1.getString("teacher");
                System.out.println("第" + cid + "门课程:" + cname + ",老师：" + teacher + ",");
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

总结

快忘记了，总体复习一遍。以上就是大部分经常可以看见的JSON格式，基本可以涵盖所有了。