java详解 --- JOSN解析

JSON 语法

1.作用: JSON文本是类似于XML文本文件 用来 存储 和 传输 数据信息的媒介
注意:JSON同XML一样 不仅可以通过响应文件作为数据的载体 也可以通过满足语法的字符串作为对应数据的载体 称之为”json字符串”

2.JSON中数据存储采用 {} 与 [] 语法
{} –> java中的双列集合 (字典)
[] –> java中的单列集合 (数组)

3.JSON语法最顶层为 单一{} 或 单一[]

4.JSON语法中结构为 {} [] 相互嵌套({}可以嵌套{}[] / []也可以嵌套{} [])

5.JSON语法中以逗号(,)作为字段分割的标识
注意:最后一个字段不能添加逗号

6.字典中的语法为 {“key” : value} 格式
注意:key为字符串 value拥有类型
多条语句语法:
{
“key1” : value1,
“key2” : value2,
“key3” : value3,
“….” : ……,
“keyn” : valuen
}

7.数组中的缘语法为[value1 , value2 , … , value n] 格式
注意:value拥有类型

8.{} 和 [] 中的每一个value均可以为{} / [] 且多个value类型不一定相同

代码举例:
Person.json:

{
    "name" : "李阿姨",
    "gender" : "女",
    "age" : 30
}

Car.json:

[
    {
        "id" : "001",
        "brand" : "BMW",
        "color" : "银色",
        "size" : 5
    },

    {
        "id" : "002",
        "brand" : "T",
        "color" : "白色",
        "size" : 2
    },

    {
        "id" : "003",
        "brand" : "F1",
        "color" : "红色",
        "size" : 1
    }
]

School.json:

{
    "status" : 0,
    "msg" : "json剑桥学院",
    "data" :
    [
        {
            "tag" : "Teachers",
            "data" : 
            [
                {
                    "name" : "Teacher1",
                    "gender" : "男",
                    "subject" : "艺术",
                    "salary" : 800
                },
                {
                    "name" : "Teacher2",
                    "gender" : "女",
                    "subject" : "美术",
                    "salary" : 2000
                },
                {
                    "name" : "Teacher3",
                    "gender" : "未知",
                    "subject" : "生物",
                    "salary" : 2100
                }
            ]
        },
        {
            "tag" : "Students",
            "data" : 
            [
                {
                    "name" : "Student1",
                    "gender" : "男",
                    "age" : 18,
                    "class" : "三班"
                },
                {
                    "name" : "Student2",
                    "gender" : "男",
                    "age" : 8,
                    "class" : "六班"

                },
                {
                    "name" : "Student3",
                    "gender" : "女",
                    "age" : 16,
                    "class" : "八班"
                },
                {
                    "name" : "Student4",
                    "gender" : "女",
                    "age" : 10,
                    "class" : "七班"

                }
            ]
        }
    ]
}

所有方法都是采用封装的方式,请仔细查看:

public class practice {
    public static void main(String[] args) {
        // JSON解析
        //fun1("[1,2,3,4,5,false,\"true\"]");

        // JSON解析的两种情况
        //fun2("{\"color\" : \"红色\" , \"weight\" : 2.2}");

        // JSON解析两种情况混合
        //fun3("{\"data\" : [1,2,3,4,5] , \"姓名\" : \"张三\"}");

        // 将json转为对象
//      String jString = jsonString("Person.json的路径");
//      
//      Person p = JSON.parseObject(jString, Person.class);
//      System.out.println(p);

        // 获取车的数据
//      String jStr = jsonString("Car.json的路径");
//      
//      System.out.println(car1(jStr));
//      System.out.println(car2(jStr));
//      System.out.println(car3(jStr));

        Map school = Analy.jsonToMap();
        System.out.println("school:\n" + school);
    }

    // JSON解析 
    private static void fun1(String string) {
        Object object = JSON.parse(string);
        System.out.println(object);

        // 向下转型 将object向下转型为其他类型
        JSONArray jArray = (JSONArray)object;
        int num = jArray.getIntValue(0);
        boolean b = jArray.getBooleanValue(5);
        System.out.println(num);
        System.out.println(b);
    }

    // JSON解析的两种情况
    private static void fun2(String string) {
        Object object = JSON.parse(string);
        // JSON字符串以 {} 包裹 解析为JSONObject对象
        // JSON字符串以 [] 包裹 解析为JSONArray对象
        JSONObject jObject = (JSONObject)object;
        // JSONObject是以 key 索引数据
        // JSONArray是以 下标 索引数据
        String color = jObject.getString("color");
        System.out.println(color);
        double weight = jObject.getDoubleValue("weight");
        System.out.printf("%.1f", weight);
    }

    // JSON解析两种情况混合
    private static void fun3(String string) {
        Object object = JSON.parse(string);

        JSONObject jObject = (JSONObject) object;
        JSONArray array = jObject.getJSONArray("data");
        System.out.println(array);

        for (Object obj : array) {
            System.out.print(obj + " ");
        }
        System.out.println();

        for (int i = 0; i < array.size(); i++) {
            int num = array.getIntValue(i);
            System.out.print(num + " ");
        }
        System.out.println();

        // new Integer[]{} : Integet对象类型的数组 的 对象
        // toArray : 需要对象数组的对象 作为确定泛型的参数
        Integer[] integer = array.toArray(new Integer[]{}); 
        for (Integer i : integer) {
            System.out.print(i + " ");
        }
        System.out.println();

        String name = jObject.getString("姓名");
        System.out.println(name);
    }

    // 将JSON文本文件 转换为 JSON字符串
    /*
     * 分析:
     * BufferedReader一行行的读取文件
     * StringBuffer将读取的文件一次次的拼接
     * 将最终的字符串返回
     */
    public static String jsonString(String filePath) {
        // 创建StringBuffer
        StringBuffer sb = new StringBuffer();
        // 创建BufferedReader
        BufferedReader reader = null;
        try {
            File file = new File(filePath);

            reader = new BufferedReader(new FileReader(file));

            String In = "";
            while ((In = reader.readLine()) != null) {
                sb.append(In.trim());// 去空格
            }
        } catch (Exception e) {
            System.err.println("json文件解析失败" + e.getMessage());
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                }
            } catch (IOException e) {
                System.out.println("流关闭失败" + e.getMessage());
            }
        }
        return new String(sb);
    }

    // 获取车的数据
    // 1 getJSONObject / parseObject(toJSONString() , class) / 
    private static Car car1(String jsonString) {
        Object object = JSON.parse(jsonString);
        JSONArray jArray = (JSONArray)object;
        JSONObject jObject = jArray.getJSONObject(0);
        Car car = JSON.parseObject(jObject.toJSONString(), Car.class);
        return car;
    }

    // 2 getJSONObject() / toJavaObject()
    private static Car car2(String jsonString) {
        Object object = JSON.parse(jsonString);
        JSONArray jArray = (JSONArray)object;
        JSONObject jObject = jArray.getJSONObject(1);
        Car car = JSON.toJavaObject(jObject, Car.class);
        return car;
    }

    // 3 直接放进集合 然后获取元素
    private static Car car3(String jsonString) {
        // JSON / JSONArray / JSONObject 三者都可以使用
        List<Car>  cars = JSON.parseArray(jsonString, Car.class);
        Car car = cars.get(2);
        return car;
    }
}

/*
 * 功能 : 对外提供一个公用的JSON解析结果
 * 定义单例的原因 : 公用 - 封装 / 单一 - 单例
 */
class Analy{
    // 对外提供单一的对象
    public static Map school = null;

    // 对外提供的对象 和 自身对象没关系
    // 不对外提供构造器 且 自身构造器不做任何操作
    public Analy() {}

    // 单例对外提供的单例方法 - 做唯一对象赋值操作
    // 唯一对象school对应的Map 赋值操作为JSON书记的解析
    public static Map jsonToMap() {
        if (school == null) {
            school = analyse();
        }
        return school;
    }

    // 解析方法
    private static Map analyse() {
        Map map = new HashMap<>();
        String jStr = practice.jsonString("School.json的路径");
        // 第一层
        JSONObject jsonObject = JSON.parseObject(jStr);
        // 第二层
        JSONArray jsonArray = jsonObject.getJSONArray("data");
        // 第三层 Teachers / Students
        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject jObj = jsonArray.getJSONObject(i);
            // 第四层 Teacher数组 . Student数组
            JSONArray jArray = jObj.getJSONArray("data");
            String tag = jObj.getString("tag");
            // 第五层 整体解析为List<Teacher> / List<student>
            if (tag.equals("Teachers")) {
                List<Teacher> ts = JSON.parseArray(jArray.toJSONString(), Teacher.class);
                map.put(tag, ts);
            }
            if (tag.equals("Students")) {
                List<Student> ss = JSON.parseArray(jArray.toJSONString(), Student.class);
                map.put(tag, ss);
            }
        } 
        return map;
    }
}