Java 解析Json字符串

Java中有很多方式可以解析Json字符串:

• FastJson库
  阿里巴巴开源
  擅长解析建议JSON字符串数据，而且是数据字段为固定的
• Gson 库
• org.json库解析
  使用起来，比较简单

Json格式

• {} 使用JSONObject 对象根据属性名称获取Value值
• [] 使用JSONArray 对象根据下标获取value

JSON格式数据，2中类型（格式）：
    1) key/value 集合
        key 数据类型：String字符串，value 数据类型：字符串（可以嵌套json字符串），整形，浮点型
        案例：
            {"id": 1001, "name": "Jack", "age": 35, "money": 99999.99 }
        格式化：
            {
                "id": 1001,
                "name": "Jack",
                "age": 35,
                "money": 99999.99
            }
        【将其解析以后，转换为map集合】

    2) 值列表
        数据类型：字符安(可以嵌套json字符串), 整形，浮点型
        案例： 
            [1, 2, 3, 4, 5, 6, 7]
        格式化：
            [
                1,
                2,
                3,
                4,
                5,
                6,
                7
            ]
        【将其解析存储为List列表中或数组中】

org.json库解析 一 简单Json

• 创建一个json字符串解析完成后的 存储类
• 创建 JSONObject 对象
• 调用get对象数据类型 ,获取数据
• 封装对象

package cn.itcast.vehicle.JsonTest;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import netscape.javascript.JSObject;
import org.json.JSONObject;

/**
 * @description: 使用 org.json 实现简单Json字符转换
 *
 * @author:
 */
public class JsonText {
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    private static class VehicleJson {
        private Integer batteryAlarm;
        private Integer carMode;
        private Double minVoltageBattery;
        private Integer chargeStatus;
        private String vin;
    }

    public static void main(String[] args) {

        String context = "{\n" +
                "    \"batteryAlarm\": 0,\n" +
                "    \"carMode\": 1,\n" +
                "    \"minVoltageBattery\": 3.89,\n" +
                "    \"chargeStatus\": 1,\n" +
                "    \"vin\": \"LS5A3CJC0JF890971\"\n" +
                "}" +
                "";
        JSONObject jsonObject =new JSONObject(context);

        int batteryAlarm = jsonObject.getInt("batteryAlarm");
        int carMode = jsonObject.getInt("carMode");
        double minVoltageBattery = jsonObject.getDouble("minVoltageBattery");
        int chargeStatus = jsonObject.getInt("chargeStatus");
        String vin = jsonObject.getString("vin");


        VehicleJson vehicleJson =new VehicleJson(batteryAlarm,carMode,minVoltageBattery,chargeStatus,vin);
        System.out.println(vehicleJson);
    }
}

org.json库解析 二 复杂Json

复杂Json 就是 Json 嵌套Json
一层一层解析就可以了
注意 使用get(属性名)toString 获取嵌套Json 数据 转成String 然后解析
[] JSONArray 数组
{}JSONObject json字符串

org.json库解析 三 缺省Json

解析JSON字符串时，思路：

• 1. 先将JSON字符串解析后，各个属性名称和值，存储到Map集合中
     json-str -> Map<String, Object>
• 2. 依据属性名称到map集合获取值，如果没有值给予默认值即可
     map.getOrDefault(n1, -999999)
     map.getOrDefault(n2, -999999D)
     map.getOrDefault(n3, "")

思路:将JSON字符串转成Map集合,通过map集合 对应key值获取value,如果没有值,就使用默认值

Map<String, Object> resultMap = jsonStrToMap(content) ;

• step1 将json解析成map,
  将json中的所有key 放入hashmap的key中
• step2 通过key值获取map中的value值,没有就使用默认值

   /**
     * 解析json字符串： [{}, {}, {}] - 列表list，其中列表中每个值属于嵌套字符串，需要内部再次解析{} -> map集合
     */
    private static List<Map<String, Object>> jsonStrToList(String content){
        // 定义列表List，存储解析的数据
        List<Map<String, Object>> list = new ArrayList<>() ;

        // a. 构建JSONArray对象
        JSONArray jsonArray = new JSONArray(content);
        // b. 循环遍历，获取数组中每个值，再次解析
        for(int index = 0 ; index < jsonArray.length(); index ++){
            // b-1. 依据下标获取列表中的每个值
            String jsonStr = jsonArray.get(index).toString();
            // b-2. 解析json字符串 {} -> map集合
            Map<String, Object> map = jsonStrToMap(jsonStr);
            // b-3. 添加到列表中
            list.add(map) ;
        }

        // 返回列表
        return list ;
    }

    /**
     * 解析json字符串，格式为： {} ,将key/value存储到map集合中
     */
    private static Map<String, Object> jsonStrToMap(String content) {
        // 定义Map集合，存储解析json字符串中各个字段的值
        Map<String, Object> map = new HashMap<>() ;

        // a. 构建JSONObject对象
        JSONObject jsonObject = new JSONObject(content);
        // b. 获取所有key名称
        Set<String> keySet = jsonObject.keySet();
        // c. 遍历Set集合，依据key获取value值
        for (String key : keySet) {
            Object value = jsonObject.get(key);
            map.put(key, value) ;
        }

        // 返回map集合
        return map ;
    }

二代码

package cn.itcast.vehicle.JsonTest;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.json.JSONArray;
import org.json.JSONObject;

import java.util.ArrayList;
import java.util.List;

/**
 * @description: 解析嵌套Json
 * @author:
 */
public class JsonText2 {


    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    private static class VehiclePlusJson {
        private int batteryAlarm;
        private int carMode;
        private double minVoltageBattery;
        private int chargeStatus;
        private String vin;
        private List<Integer> probeTemperatures;
        private int chargeTemperatureProbeNum;
        private int childSystemNum;
    }

    public static void main(String[] args) {

        String context = "{\n" +
                "    \"batteryAlarm\": 0,\n" +
                "    \"carMode\": 1,\n" +
                "    \"minVoltageBattery\": 3.89,\n" +
                "    \"chargeStatus\": 1,\n" +
                "    \"vin\": \"LS5A3CJC0JF890971\",\n" +
                "    \"nevChargeSystemTemperatureDtoList\": [{\n" +
                "        \"probeTemperatures\": [25, 23, 24, 21, 24, 21, 23, 21, 23, 21, 24, 21, 24, 21, 25, 21],\n" +
                "        \"chargeTemperatureProbeNum\": 16,\n" +
                "        \"childSystemNum\": 1\n" +
                "    }]\n" +
                "}";
        JSONObject jsonObject = new JSONObject(context);


        int batteryAlarm = jsonObject.getInt("batteryAlarm");
        int carMode = jsonObject.getInt("carMode");
        double minVoltageBattery = jsonObject.getDouble("minVoltageBattery");
        int chargeStatus = jsonObject.getInt("chargeStatus");
        String vin = jsonObject.getString("vin");
        // 以下是一个嵌套Json,获取嵌套Json
        // todo 获取嵌套JSON 使用 get().toString
        String nevList = jsonObject.get("nevChargeSystemTemperatureDtoList").toString();
        //且里面是用[]包含的 是一个数组

        //todo 使用JSONAarry 解析
        JSONArray jsonArray =new JSONArray(nevList);

        String nevChargeSystemTemperatureDtoListStr = jsonArray.get(0).toString();
        // 创建JSONObject 解析嵌套的
        JSONObject jsonObject1 = new JSONObject(nevChargeSystemTemperatureDtoListStr);
        //todo 获取嵌套JSON
        String probeTemperatures = jsonObject1.get("probeTemperatures").toString();

        JSONArray jsonArray1 = new JSONArray(probeTemperatures);

        ArrayList<Integer> arrayList =new ArrayList<>();

        //定义 list集合存储 jsonarry内的内容

        for (int i = 0; i < jsonArray1.length() ; i++) {

            arrayList.add(jsonArray1.getInt(i));

        }

        //
        int chargeTemperatureProbeNum = jsonObject1.getInt("chargeTemperatureProbeNum");
        int childSystemNum = jsonObject1.getInt("childSystemNum");

        VehiclePlusJson vehiclePlusJson = new VehiclePlusJson(
                batteryAlarm, carMode, minVoltageBattery, chargeStatus, vin, arrayList,     chargeTemperatureProbeNum, childSystemNum
        );

        System.out.println(vehiclePlusJson);
    }



}

三代码

package cn.itcast.vehicle.JsonTest;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.json.JSONArray;
import org.json.JSONObject;

import java.util.*;

/**
 * 解析复杂JSON字符串，使用org.json库解析，原则：一层一层解析，由外向内
 *  1. {}  -> 构建JSONObject对象
 *      依据属性名称获取值
 *  2. []  ->  构建JSONArray对象
 *      依据下标索引获取值，从0开始
 *  todo: 考虑JSON字符串数据中各个属性是否一致，如果数据中属性不固定的话，需要灵活解析
 *      1. 将json字符串中key/value值解析封装到map集合
 *          Map<String, Object>
 *      2. 依据属性key名称到map集合中获取值，如果没有的话，给予默认值
 *          map.getOrDefault(name, default-value)
 * @author xuanyu
 */
public class JsonParsePlusOptimizedDemo {

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    private static class VehicleJsonObject {
        private int batteryAlarm;
        private int carMode;
        private double minVoltageBattery;
        private int chargeStatus;
        private String vin;
        private String probeTemperatures;
        private int chargeTemperatureProbeNum;
        private int childSystemNum;
    }

    public static void main(String[] args) {
        // 字符串json，嵌套格式
        String content = "{\n" +
            "    \"batteryAlarm\": 0,\n" +
            "    \"carMode\": 1,\n" +
            "    \"minVoltageBattery\": 3.89,\n" +
            "    \"chargeStatus\": 1,\n" +
            "    \"vin\": \"LS5A3CJC0JF890971\"\n" +
            "}" ;

        // 第1层： 解析json字符串->{} - Map集合，使用JSONObject
        Map<String, Object> objectMap = jsonStrToMap(content);
        // System.out.println(objectMap);
        // todo： 依据属性key到Map集合中获取value值，如果没有值，给予默认值（字符串："", int: -999999, double: -999999D)
        int batteryAlarm = Integer.parseInt(
            objectMap.getOrDefault("batteryAlarm", -999999).toString()
        );
        int carMode = Integer.parseInt(
            objectMap.getOrDefault("carMode", -999999).toString()
        );
        double minVoltageBattery = Double.parseDouble(
            objectMap.getOrDefault("minVoltageBattery", -999999D).toString()
        );
        int chargeStatus = Integer.parseInt(
            objectMap.getOrDefault("chargeStatus", -999999).toString()
        );
        String vin = objectMap.getOrDefault("vin", "").toString();
        // System.out.println(batteryAlarm + ", " + carMode + ", " + minVoltageBattery + ", " + chargeStatus + ", " + vin);

        // 获取嵌套属性key对应值
        String nevChargeSystemTemperatureDtoListStr = objectMap
            .getOrDefault("nevChargeSystemTemperatureDtoList", "[]").toString();

        // 第2层、再次解析JSON字符串： [{}]  -> 解析封装到Map集合
        List<Map<String, Object>> mapList = jsonStrToList(nevChargeSystemTemperatureDtoListStr);

        String probeTemperatures = "";
        Integer chargeTemperatureProbeNum = -999999 ;
        Integer childSystemNum = -999999 ;
        // 判断列表中是否有数据，如果有的话，获取第一条数据
        if(mapList.size() > 0) {
            Map<String, Object> map = mapList.get(0);
            probeTemperatures = map.getOrDefault("probeTemperatures", "").toString();
            chargeTemperatureProbeNum = Integer.parseInt(
                map.getOrDefault("chargeTemperatureProbeNum", -999999).toString()
            );
            childSystemNum = Integer.parseInt(
                map.getOrDefault("childSystemNum", -999999).toString()
            );
        }

        // 封装实体类对象
        VehicleJsonObject vehicleJsonObject = new VehicleJsonObject(
            batteryAlarm, carMode, minVoltageBattery, chargeStatus, vin,
            probeTemperatures, chargeTemperatureProbeNum, childSystemNum
        );
        System.out.println(vehicleJsonObject);

    }

    /**
     * 解析json字符串： [{}, {}, {}] - 列表list，其中列表中每个值属于嵌套字符串，需要内部再次解析{} -> map集合
     */
    private static List<Map<String, Object>> jsonStrToList(String content){
        // 定义列表List，存储解析的数据
        List<Map<String, Object>> list = new ArrayList<>() ;

        // a. 构建JSONArray对象
        JSONArray jsonArray = new JSONArray(content);
        // b. 循环遍历，获取数组中每个值，再次解析
        for(int index = 0 ; index < jsonArray.length(); index ++){
            // b-1. 依据下标获取列表中的每个值
            String jsonStr = jsonArray.get(index).toString();
            // b-2. 解析json字符串 {} -> map集合
            Map<String, Object> map = jsonStrToMap(jsonStr);
            // b-3. 添加到列表中
            list.add(map) ;
        }

        // 返回列表
        return list ;
    }

    /**
     * 解析json字符串，格式为： {} ,将key/value存储到map集合中
     */
    private static Map<String, Object> jsonStrToMap(String content) {
        // 定义Map集合，存储解析json字符串中各个字段的值
        Map<String, Object> map = new HashMap<>() ;

        // a. 构建JSONObject对象
        JSONObject jsonObject = new JSONObject(content);
        // b. 获取所有key名称
        Set<String> keySet = jsonObject.keySet();
        // c. 遍历Set集合，依据key获取value值
        for (String key : keySet) {
            Object value = jsonObject.get(key);
            map.put(key, value) ;
        }

        // 返回map集合
        return map ;
    }

}