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字符串时，思路：
- 先将JSON字符串解析后，各个属性名称和值，存储到Map集合中
json-str -> Map<String, Object>
- 先将JSON字符串解析后，各个属性名称和值，存储到Map集合中
- 依据属性名称到map集合获取值，如果没有值给予默认值即可
map.getOrDefault(n1, -999999)
map.getOrDefault(n2, -999999D)
map.getOrDefault(n3, "")
- 依据属性名称到map集合获取值，如果没有值给予默认值即可
思路:将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 ;
}
}
