1. JSONArray.fromObject静态方法
1.1. static JSONArray fromObject(Object object)静态方法, 把Java对象转换为JSONArray对象。json-lib底层, 会创建一个JsonConfig对象使用。
1.2. static JSONArray fromObject(Object object, JsonConfig jsonConfig)静态方法, 把Java对象转换为JSONArray对象。并指定一个JsonConfig。
1.3. 编写一个名叫JSONArrayStaticMethod的Java项目, 同时添加相关jar包。
1.4. 新建Sensor.java
package com.fj.ja;
import java.io.Serializable;
/**
* 传感器
*/
public class Sensor implements Serializable {
private static final long serialVersionUID = 1L;
private Boolean weightSensor; // 重力传感器
private Boolean fingerSensor; // 指纹传感器
private String otherSensor; // 其它传感器
public Sensor() {}
public Sensor(Boolean weightSensor, Boolean fingerSensor, String otherSensor) {
this.weightSensor = weightSensor;
this.fingerSensor = fingerSensor;
this.otherSensor = otherSensor;
}
public Boolean getWeightSensor() {
return weightSensor;
}
public void setWeightSensor(Boolean weightSensor) {
this.weightSensor = weightSensor;
}
public Boolean getFingerSensor() {
return fingerSensor;
}
public void setFingerSensor(Boolean fingerSensor) {
this.fingerSensor = fingerSensor;
}
public String getOtherSensor() {
return otherSensor;
}
public void setOtherSensor(String otherSensor) {
this.otherSensor = otherSensor;
}
@Override
public String toString() {
return "{weightSensor=" + weightSensor + ", fingerSensor=" + fingerSensor + ", otherSensor=" + otherSensor + "}";
}
}
1.5. 新建JSONArrayStaticFromObject.java
package com.fj.ja;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JsonConfig;
/**
* JSONArray
* 1. static JSONArray fromObject(Object object)静态方法, 把Java对象转换为JSONArray对象。json-lib底层, 会创建一个JsonConfig对象使用。
* 2. static JSONArray fromObject(Object object, JsonConfig jsonConfig)静态方法, 把Java对象转换为JSONArray对象。并指定一个JsonConfig。
*/
public class JSONArrayStaticFromObject {
public static void main(String[] args) {
// 数组
String[] mobileColor = {"亮黑色", "冰霜银", "零度白", "深海蓝", "晨曦金"};
// 集合
List<String> isp = new ArrayList<String>(); // ISP网络服务提供商
isp.add("移动");
isp.add("联通");
isp.add("电信");
// Map
Map<String, String> mainParam = new HashMap<String, String>();
mainParam.put("runtimeMemory", "8GB");
mainParam.put("mobileMemory", "128GB");
mainParam.put("CPUType", "HUAWEI Kirin 990 5G(麒麟990 5G)");
mainParam.put("CPUCount", "八核");
// Java Bean
Sensor sensor = new Sensor();
sensor.setWeightSensor(true);
sensor.setFingerSensor(true);
sensor.setOtherSensor("姿态感应器、色温传感器");
// Java Bean集合
List<Sensor> beanList = new ArrayList<Sensor>();
beanList.add(new Sensor(false, true, "姿态感应器、色温传感器"));
beanList.add(new Sensor(true, false, "姿态感应器、色温传感器"));
beanList.add(new Sensor(false, false, "姿态感应器、色温传感器"));
String jsonArrayStr = "[\"华为P40 Pro\",true,5988,2601010188703,6.58,[\"亮黑色\",\"冰霜银\",\"零度白\",\"深海蓝\",\"晨曦金\"],[\"移动\",\"联通\",\"电信\"],{\"mobileMemory\":\"128GB\",\"CPUCount\":\"八核\",\"CPUType\":\"HUAWEI Kirin 990 5G(麒麟990 5G)\",\"runtimeMemory\":\"8GB\"},{\"otherSensor\":\"姿态感应器、色温传感器\",\"weightSensor\":true,\"fingerSensor\":true},{\"5G\":\"移动5G(NR)/联通5G(NR)/电信5G(NR)\",\"4G\":\"移动/联通/电信4G主副卡 支持 TD-LTE/LTE FDD\",\"3G\":\"主卡: 联通3G(WCDMA)/电信3G(CDMA 2000); 副卡: 联通3G(WCDMA)\",\"2G\":\"主卡: 移动2G(GSM)/联通2G(GSM)/电信2G(CDMA 1X); 副卡: 移动2G(GSM)/联通2G(GSM)/电信2G(CDMA 1X)\"},[\"NFC\",\"WLAN\"]]";
System.out.println(JSONArray.fromObject(mobileColor)); // 把数组转换为JSONArray对象
System.out.println(JSONArray.fromObject(isp, new JsonConfig())); // 把集合转换为JSONArray对象
System.out.println(JSONArray.fromObject(mainParam)); // 把Map转换为JSONArray对象
System.out.println(JSONArray.fromObject(sensor)); // 把Java Bean转换为JSONArray对象
System.out.println(JSONArray.fromObject(beanList)); // 把Java Bean集合转换为JSONArray对象
System.out.println(JSONArray.fromObject(jsonArrayStr)); // 把JSON Array String对象转换为JSONArray对象
}
}
1.6. 运行JSONArrayStaticFromObject.java
2. JSONArray.toList静态方法
2.1. static List toList(JSONArray jsonArray, Object root, JsonConfig jsonConfig)静态方法, 从JSONArray创建一个集合。
2.2. 第二个参数传入对象, 如果jsonArray里有JSON对象数据的话, 根据对象的类创建新对象, 封装数据到新对象里。
2.3. 第三个参数传入一个JSONConfig对象, JSONConfig可以设置一个ClassMap, 倘若JSON对象里还有JSON对象, 可以根据ClassMap来进行键和值的类型匹配。
2.4. 新建JSONArrayStaticToList.java(toList静态方法, 第二个参数传入HashMap对象)
package com.fj.ja;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONNull;
import net.sf.json.JsonConfig;
/**
* JSONArray
* 1. JSONArray.toList(JSONArray jsonArray, Object root, JsonConfig jsonConfig)静态方法, 从JSONArray创建一个集合。
* 2. 第二个参数传入对象, 如果jsonArray里有JSON对象数据的话, 根据对象的类创建新对象, 封装数据到新对象里。
* 3. 第三个参数传入一个JSONConfig对象, JSONConfig可以设置一个ClassMap, 倘若JSON对象里还有JSON对象, 可以根据ClassMap来进行键和值的类型匹配。
*/
public class JSONArrayStaticToList {
public static void main(String[] args) {
// 数组
String[] mobileColor = {"亮黑色", "冰霜银", "零度白", "深海蓝", "晨曦金"};
// 集合
List<String> isp = new ArrayList<String>(); // ISP网络服务提供商
isp.add("移动");
isp.add("联通");
isp.add("电信");
// Java Bean
Sensor sensor = new Sensor();
sensor.setWeightSensor(true);
sensor.setFingerSensor(true);
sensor.setOtherSensor("姿态感应器、色温传感器");
// Map
Map<String, Object> mainParam = new HashMap<String, Object>();
mainParam.put("runtimeMemory", "8GB");
mainParam.put("mobileMemory", "128GB");
mainParam.put("CPUType", "HUAWEI Kirin 990 5G(麒麟990 5G)");
mainParam.put("CPUCount", "八核");
mainParam.put("sensor", sensor);
// Java Bean集合
List<Sensor> beanList = new ArrayList<Sensor>();
beanList.add(new Sensor(false, true, "姿态感应器、色温传感器"));
beanList.add(new Sensor(true, false, "姿态感应器、色温传感器"));
beanList.add(new Sensor(false, false, "姿态感应器、色温传感器"));
JSONArray jsonArray = new JSONArray();
jsonArray.element("HUAWEI P40 Pro");
jsonArray.element(true);
jsonArray.element(5988);
jsonArray.element(2601010188703L);
jsonArray.element(6.58D);
jsonArray.element(JSONNull.getInstance());
jsonArray.element(mobileColor);
jsonArray.element(isp);
jsonArray.element(mainParam);
jsonArray.element(sensor);
jsonArray.element(beanList);
JsonConfig jsonConfig = new JsonConfig();
Map<String, Class<?>> classMap = new HashMap<String, Class<?>>();
classMap.put("sensor", Sensor.class);
jsonConfig.setClassMap(classMap);
// 把jsonArray转换为集合, 第二个参数传入一个HashMap对象, 根据HashMap对象的类创建新的HashMap对象, 把jsonArray里的JSON对象数据, 封装到新的HashMap里。
// 传入一个HashMap对象是一个好主意, 因为它可以根据键和值很好的封装JSON对象。
List<?> list = JSONArray.toList(jsonArray, new HashMap<String, String>(), jsonConfig);
for (Object obj : list) {
System.out.println(obj);
}
}
}
2.5. 运行JSONArrayStaticToList.java
2.6. 新建JSONArrayStaticToListBean.java(toList静态方法, 第二个参数传入JavaBean对象)
package com.fj.ja;
import java.util.ArrayList;
import java.util.List;
import net.sf.json.JSONArray;
import net.sf.json.JsonConfig;
/**
* JSONArray
* 1. JSONArray.toList(JSONArray jsonArray, Object root, JsonConfig jsonConfig)静态方法, 从JSONArray创建一个集合。
* 2. 第二个参数传入对象, 如果jsonArray里有JSON对象数据的话, 根据对象的类创建新对象, 封装数据到新对象里。
* 3. 第三个参数传入一个JSONConfig对象, JSONConfig可以设置一个ClassMap, 倘若JSON对象里还有JSON对象, 可以根据ClassMap来进行键和值的类型匹配。
*/
public class JSONArrayStaticToListBean {
public static void main(String[] args) {
// Java Bean
Sensor sensor = new Sensor();
sensor.setWeightSensor(true);
sensor.setFingerSensor(true);
sensor.setOtherSensor("姿态感应器、色温传感器");
// Java Bean集合
List<Sensor> beanList = new ArrayList<Sensor>();
beanList.add(new Sensor(false, true, "姿态感应器、色温传感器"));
beanList.add(new Sensor(true, false, "姿态感应器、色温传感器"));
beanList.add(new Sensor(false, false, "姿态感应器、色温传感器"));
JSONArray jsonArray = new JSONArray();
jsonArray.element("HUAWEI P40 Pro");
jsonArray.element(true);
jsonArray.element(5988);
jsonArray.element(2601010188703L);
jsonArray.element(6.58D);
jsonArray.element(sensor);
jsonArray.element(beanList);
// 把jsonArray转换为集合, 第二个参数传入一个Sensor对象, 根据Sensor对象的类创建新的Sensor对象, 把jsonArray里的JSON对象数据, 封装到新的Sensor对象里。
List<?> list = JSONArray.toList(jsonArray, new Sensor(), new JsonConfig());
printList(list);
}
public static void printList(Object object) {
if(List.class.isAssignableFrom(object.getClass())) {
for (Object obj : (List<?>)object) {
printList(obj);
}
}
if(object instanceof Sensor) {
System.out.println((Sensor)object);
} else if(!List.class.isAssignableFrom(object.getClass())) {
System.out.println(object);
}
}
}
2.7. 运行JSONArrayStaticToListBean.java
3. toArray方法
3.1. Object[] toArray(), 把JSONArray转换为Object[]数组。调用的是Java底层的 java.util.List.toArray()方法。
3.2. 新建JSONArrayToArray.java
package com.fj.ja;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONNull;
/**
* JSONArray
* 1. Object[] toArray(), 把JSONArray转换为Object[]数组。调用的是Java底层的 java.util.List.toArray()方法。
*/
public class JSONArrayToArray {
public static void main(String[] args) {
// 数组
String[] mobileColor = {"亮黑色", "冰霜银", "零度白", "深海蓝", "晨曦金"};
// 集合
List<String> isp = new ArrayList<String>(); // ISP网络服务提供商
isp.add("移动");
isp.add("联通");
isp.add("电信");
// Map
Map<String, String> mainParam = new HashMap<String, String>();
mainParam.put("runtimeMemory", "8GB");
mainParam.put("mobileMemory", "128GB");
mainParam.put("CPUType", "HUAWEI Kirin 990 5G(麒麟990 5G)");
mainParam.put("CPUCount", "八核");
// Java Bean
Sensor sensor = new Sensor();
sensor.setWeightSensor(true);
sensor.setFingerSensor(true);
sensor.setOtherSensor("姿态感应器、色温传感器");
// Java Bean集合
List<Sensor> beanList = new ArrayList<Sensor>();
beanList.add(new Sensor(false, true, "姿态感应器、色温传感器"));
beanList.add(new Sensor(true, false, "姿态感应器、色温传感器"));
beanList.add(new Sensor(false, false, "姿态感应器、色温传感器"));
JSONArray jsonArray = new JSONArray();
jsonArray.element("HUAWEI P40 Pro"); // toArray后是String
jsonArray.element(true); // toArray后是boolean
jsonArray.element(5988); // toArray后是int
jsonArray.element(2601010188703L); // toArray后是long
jsonArray.element(6.58D); // toArray后是double
jsonArray.element(JSONNull.getInstance()); // toArray后是JSONNull对象
jsonArray.element(mobileColor); // toArray后是JSONArray对象
jsonArray.element(isp); // toArray后是JSONArray对象
jsonArray.element(mainParam); // toArray后是JSONObject对象
jsonArray.element(sensor); // toArray后是JSONObject对象
jsonArray.element(beanList); // toArray后是JSONArray对象, JSONArray里封装了JSONObject对象
Object[] objArr = jsonArray.toArray();
for (Object item : objArr) {
System.out.println(item);
}
}
}
3.3. 运行JSONArrayToArray.java
4. JSONArray.toArray静态方法
4.1. toArray(JSONArray jsonArray)静态方法
4.1.1. static Object toArray(JSONArray jsonArray)静态方法, 把JSONArray对象转换为Java对象(实际上是数组对象)。
4.1.2. Json-lib底层自己去解析JSONArray对象。Json-lib底层会创建一个Object数组, 并调用Java底层Array.set(Object array, int index, Object value)将指定数组对象中索引组件的值设置为指定的新值, 来封装JSONArray对象中的数据到Object数组。
4.1.3. 如果JSONArray对象是简单对象(没有再包含JSON对象和JSON数组数据), Json-lib底层会创建一个一维的Object[]数组, 并调用Java底层Array.set(Object array, int index, Object value)把这个一维的Object[]数组相应的坐标位置设置值。JSONArray.toArray(JSONArray jsonArray)这个静态方法恐怕最适合解析这种简单的JSONArray对象。
4.1.4. 如果JSONArray对象只包含JSON对象类型的数据, Json-lib底层会创建一个一维的Object[]数组, 在解析JSON对象类型的数据的时候调用Json-lib底层JSONObject对象的toBean(JSONObject jsonObject)方法, 把JSON对象类型的数据封装到一个动态JavaBean里面(DynaBean), 然后再调用Java底层Array.set(Object array, int index, Object value)把这个一维的Object[]数组相应的坐标位置设置值。
4.1.5. 如果JSONArray对象只包含JSON数组类型的数据, Json-lib底层会创建一个二维的Object[][]数组, 并调用Java底层Array.set(Object array, int index, Object value)把这个二维的Object[][]数组相应的坐标位置设置值。
4.1.6. 如果JSONArray对象同时包含基本元素和JSON对象数据, Json-lib底层会创建一个一维的Object[]数组, 并调用Java底层Array.set(Object array, int index, Object value)把这个一维的Object[]数组相应的坐标位置设置值。不会报错。
4.1.7. 如果JSONArray对象同时包含基本元素、JSON数组数据或者JSON对象、JSON数组数据或者基本元素、JSON对象和JSON数组数据, Json-lib底层会创建一个二维的Object[][]数组, 我们的基本数据和动态Bean并不是数组对象,调用Java底层Array.set(Object array, int index, Object value)给这个二维的Object[][]数组相应的坐标位置设置值的时候, 就会报类型不匹配的错误。比如把动态Bean放到这个二维数组下标为0的位置, Object[0]是一个一维的Object[]数组, 而我们动态Bean并不是数组, 所以会报类型不匹配的错误。
4.1.8. 新建JSONArrayStaticToArray.java
package com.fj.ja;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONNull;
import net.sf.json.JSONObject;
/**
* JSONArray
* 1. static Object toArray(JSONArray jsonArray)静态方法, 把JSONArray对象转换为Java对象(实际上是数组对象)。
* 2. Json-lib底层自己去解析JSONArray对象。Json-lib底层会创建一个Object数组, 并调用Java底层Array.set(Object array, int index, Object value)将指定数组对象
* 中索引组件的值设置为指定的新值, 来封装JSONArray对象中的数据到Object数组。
* 3. 如果JSONArray对象是简单对象(没有再包含JSON对象和JSON数组数据), Json-lib底层会创建一个一维的Object[]数组, 并调用Java底层Array.set(Object array, int index, Object value)
* 把这个一维的Object[]数组相应的坐标位置设置值。JSONArray.toArray(JSONArray jsonArray)这个静态方法恐怕最适合解析这种简单的JSONArray对象。
* 4. 如果JSONArray对象只包含JSON对象类型的数据, Json-lib底层会创建一个一维的Object[]数组, 在解析JSON对象类型的数据的时候调用Json-lib底层JSONObject对象的toBean(JSONObject jsonObject)
* 方法, 把JSON对象类型的数据封装到一个动态JavaBean里面(DynaBean), 然后再调用Java底层Array.set(Object array, int index, Object value)把这个一维的Object[]数组相应的坐标位置设置值。
* 5. 如果JSONArray对象只包含JSON数组类型的数据, Json-lib底层会创建一个二维的Object[][]数组, 并调用Java底层Array.set(Object array, int index, Object value)
* 把这个二维的Object[][]数组相应的坐标位置设置值。
* 6. 如果JSONArray对象同时包含基本元素和JSON对象数据, Json-lib底层会创建一个一维的Object[]数组, 并调用Java底层Array.set(Object array, int index, Object value)
* 把这个一维的Object[]数组相应的坐标位置设置值。不会报错。
* 7. 如果JSONArray对象同时包含基本元素、JSON数组数据或者JSON对象、JSON数组数据或者基本元素、JSON对象和JSON数组数据, Json-lib底层会创建一个二维的Object[][]数组, 我们的基本数据和动态Bean并不是数组对象,
* 调用Java底层Array.set(Object array, int index, Object value)给这个二维的Object[][]数组相应的坐标位置设置值的时候, 就会报类型不匹配的错误。比如把动态Bean放到这个二维数组下标为0的位置,
* Object[0]是一个一维的Object[]数组, 而我们动态Bean并不是数组, 所以会报类型不匹配的错误。
*/
public class JSONArrayStaticToArray {
public static void main(String[] args) {
// 数组
String[] mobileColor = {"亮黑色", "冰霜银", "零度白", "深海蓝", "晨曦金"};
// 集合
List<String> isp = new ArrayList<String>(); // ISP网络服务提供商
isp.add("移动");
isp.add("联通");
isp.add("电信");
// Map
Map<String, String> mainParam = new HashMap<String, String>();
mainParam.put("runtimeMemory", "8GB");
mainParam.put("mobileMemory", "128GB");
mainParam.put("CPUType", "HUAWEI Kirin 990 5G(麒麟990 5G)");
mainParam.put("CPUCount", "八核");
// Java Bean
Sensor sensor = new Sensor();
sensor.setWeightSensor(true);
sensor.setFingerSensor(true);
sensor.setOtherSensor("姿态感应器、色温传感器");
// Java Bean集合
List<Sensor> sensorList = new ArrayList<Sensor>();
sensorList.add(new Sensor(false, true, "姿态感应器、色温传感器"));
sensorList.add(new Sensor(true, false, "姿态感应器、色温传感器"));
sensorList.add(new Sensor(false, false, "姿态感应器、色温传感器"));
// JSONObject
JSONObject netJsonObject = new JSONObject()
.accumulate("5G", "移动5G(NR)/联通5G(NR)/电信5G(NR)")
.accumulate("4G", "移动/联通/电信4G主副卡 支持 TD-LTE/LTE FDD")
.accumulate("3G", "主卡: 联通3G(WCDMA)/电信3G(CDMA 2000); 副卡: 联通3G(WCDMA)")
.accumulate("2G", "主卡: 移动2G(GSM)/联通2G(GSM)/电信2G(CDMA 1X); 副卡: 移动2G(GSM)/联通2G(GSM)/电信2G(CDMA 1X)");
// JSONArray
JSONArray transferFunction = new JSONArray();
transferFunction.element("NFC").element("WLAN");
JSONArray jsonArray = new JSONArray();
// 这些方法一个一个的开启
baseElement(jsonArray);
// jsonObjectElement(jsonArray.element(mainParam).element(sensor).element(netJsonObject));
// jsonArrayElement(jsonArray.element(mobileColor).element(isp).element(sensorList).element(transferFunction));
// baseAndJsonObjectElement(jsonArray.element(true).element(mainParam));
// baseAndJsonArrayElement(jsonArray.element(true).element(mobileColor));
// jsonObjectAndJsonArrayElement(jsonArray.element(mainParam).element(isp));
// baseAndJsonObjectAndJsonArrayElement(jsonArray.element(5988).element(sensor).element(transferFunction));
}
/**
* 只包含基本元素
* @param jsonArray
*/
public static void baseElement(JSONArray jsonArray) {
jsonArray.element("HUAWEI P40 Pro");
jsonArray.element(true);
jsonArray.element(5988);
jsonArray.element(2601010188703L);
jsonArray.element(6.58D);
jsonArray.element(JSONNull.getInstance());
Object obj = JSONArray.toArray(jsonArray);
Object[] objArr = (Object[])obj;
for (Object object : objArr) {
System.out.println(object);
}
}
/**
* 只包含JSON对象类型
* @param jsonArray
*/
public static void jsonObjectElement(JSONArray jsonArray) {
Object obj = JSONArray.toArray(jsonArray);
Object[] objArr = (Object[])obj;
for (Object object : objArr) {
System.out.println(object);
}
}
/**
* 只包含JSON数组类型
* @param jsonArray
*/
public static void jsonArrayElement(JSONArray jsonArray) {
Object obj = JSONArray.toArray(jsonArray);
Object[][] obj2Arr = (Object[][])obj;
for (Object[] objArr : obj2Arr) {
for (Object object : objArr) {
System.out.println(object);
}
}
}
/**
* 基本类型和JSON对象类型。
* @param jsonArray
*/
public static void baseAndJsonObjectElement(JSONArray jsonArray) {
Object obj = JSONArray.toArray(jsonArray);
Object[] objArr = (Object[])obj;
for (Object object : objArr) {
System.out.println(object);
}
}
/**
* 基本类型和JSON数组类型, 报array element type mismatch错误。
* @param jsonArray
*/
public static void baseAndJsonArrayElement(JSONArray jsonArray) {
Object obj = JSONArray.toArray(jsonArray);
System.out.println(obj);
}
/**
* JSON对象类型和JSON数组类型, 报array element type mismatch错误。
* @param jsonArray
*/
public static void jsonObjectAndJsonArrayElement(JSONArray jsonArray) {
Object obj = JSONArray.toArray(jsonArray);
System.out.println(obj);
}
/**
* 基本类型、JSON对象类型和JSON数组类型, 报array element type mismatch错误。
* @param jsonArray
*/
public static void baseAndJsonObjectAndJsonArrayElement(JSONArray jsonArray) {
Object obj = JSONArray.toArray(jsonArray);
System.out.println(obj);
}
}
4.1.9. 运行JSONArrayStaticToArray.java
4.2. toArray(JSONArray jsonArray, JsonConfig jsonConfig)静态方法
4.2.1. static Object toArray(JSONArray jsonArray, JsonConfig jsonConfig)静态方法, 把JSONArray对象转换为Java对象(实际上是数组对象)。第二个参数可以传入一个JsonConfig对象, 我们可以给JsonConfig指定一个rootClass, 让JSONArray数据按照rootClass的类型来解析。
4.2.2. 新建JSONArrayStaticToArrayJsonConfig.java
package com.fj.ja;
import java.util.ArrayList;
import java.util.List;
import net.sf.json.JSONArray;
import net.sf.json.JsonConfig;
/**
* JSONArray
* 1. static Object toArray(JSONArray jsonArray, JsonConfig jsonConfig)静态方法, 把JSONArray对象转换为Java对象(实际上是数组对象)。
* 第二个参数可以传入一个JsonConfig对象, 我们可以给JsonConfig指定一个rootClass, 让JSONArray数据按照rootClass的类型来解析。
*/
public class JSONArrayStaticToArrayJsonConfig {
public static void main(String[] args) {
// 集合
List<String> isp = new ArrayList<String>(); // ISP网络服务提供商
isp.add("移动");
isp.add("联通");
isp.add("电信");
JSONArray jsonArray = new JSONArray();
jsonArray.addAll(isp);
// 创建一个jsonConfig对象, 并指定它的rootClass是String.class类对象。
JsonConfig jsonConfig = new JsonConfig();
jsonConfig.setRootClass(String.class);
Object obj = JSONArray.toArray(jsonArray, jsonConfig);
String[] strArr = (String[])obj;
for (String str : strArr) {
System.out.println(str);
}
}
}
4.2.3. 运行JSONArrayStaticToArrayJsonConfig.java
4.3. toArray(JSONArray jsonArray, Class objectClass)静态方法
4.3.1. static Object toArray(JSONArray jsonArray, Class objectClass)静态方法, 把JSONArray对象转换为Java对象(实际上是数组对象, 这个数组是指定类型)。第二个参数(objectClass)可以传入一个类对象, 会把它设置为JSONConfig的rootClass, 会根据这个类对象类型来创建Java对象数组, 然后把JSONArray对象中的元素封装到这个创建好的Java对象数组。
4.3.2. 新建JSONArrayStaticToArrayObjectClass.java
package com.fj.ja;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import net.sf.json.JSONArray;
import net.sf.json.JSONNull;
import net.sf.json.JSONObject;
/**
* JSONArray
* 1. static Object toArray(JSONArray jsonArray, Class objectClass)静态方法, 把JSONArray对象转换为Java对象(实际上是数组对象, 这个数组是指定类型)。
* 第二个参数(objectClass)可以传入一个类对象, 会把它设置为JSONConfig的rootClass, 会根据这个类对象类型来创建Java对象数组, 然后把JSONArray对象中的元素封装到这个创建好的Java对象数组。
*/
public class JSONArrayStaticToArrayObjectClass {
public static void main(String[] args) {
// 数组
String[] mobileColor = {"亮黑色", "冰霜银", "零度白", "深海蓝", "晨曦金"};
// 集合
List<String> isp = new ArrayList<String>(); // ISP网络服务提供商
isp.add("移动");
isp.add("联通");
isp.add("电信");
// Map
Map<String, String> mainParam = new HashMap<String, String>();
mainParam.put("runtimeMemory", "8GB");
mainParam.put("mobileMemory", "128GB");
mainParam.put("CPUType", "HUAWEI Kirin 990 5G(麒麟990 5G)");
mainParam.put("CPUCount", "八核");
// Java Bean
Sensor sensor = new Sensor();
sensor.setWeightSensor(true);
sensor.setFingerSensor(true);
sensor.setOtherSensor("姿态感应器、色温传感器");
// Java Bean集合
List<Sensor> sensorList = new ArrayList<Sensor>();
sensorList.add(new Sensor(false, true, "姿态感应器、色温传感器"));
sensorList.add(new Sensor(true, false, "姿态感应器、色温传感器"));
sensorList.add(new Sensor(false, false, "姿态感应器、色温传感器"));
// JSONObject
JSONObject netJsonObject = new JSONObject()
.accumulate("5G", "移动5G(NR)/联通5G(NR)/电信5G(NR)")
.accumulate("4G", "移动/联通/电信4G主副卡 支持 TD-LTE/LTE FDD")
.accumulate("3G", "主卡: 联通3G(WCDMA)/电信3G(CDMA 2000); 副卡: 联通3G(WCDMA)")
.accumulate("2G", "主卡: 移动2G(GSM)/联通2G(GSM)/电信2G(CDMA 1X); 副卡: 移动2G(GSM)/联通2G(GSM)/电信2G(CDMA 1X)");
// JSONArray
JSONArray transferFunction = new JSONArray();
transferFunction.element("NFC").element("WLAN");
JSONArray jsonArray = new JSONArray();
// 这些方法一个一个的开启
// singleBaseElement(jsonArray);
// baseElement(jsonArray);
// mapJsonObjectElement(jsonArray.element(mainParam));
// beanJsonObjectElement(jsonArray.element(sensor));
// jsonObjectJsonObjectElement(jsonArray.element(netJsonObject));
jsonObjectElement(jsonArray.element(mainParam).element(sensor).element(netJsonObject));
// arrayListJsonArrayJsonArrayElement(jsonArray.element(transferFunction).element(isp).element(transferFunction));
// listJsonObjectJsonArrayElement(jsonArray.element(sensorList));
// baseAndJsonObjectElement(jsonArray.element(true).element(mainParam));
// baseAndJsonArrayElement(jsonArray.element(true).element(mobileColor));
// jsonObjectAndJsonArrayElement(jsonArray.element(mainParam).element(isp));
// baseAndJsonObjectAndJsonArrayElement(jsonArray.element(5988).element(sensor).element(transferFunction));
}
/**
* 只包含单一类型的基本元素
* @param jsonArray
*/
public static void singleBaseElement(JSONArray jsonArray) {
jsonArray.element(2988);
jsonArray.element(3988);
jsonArray.element(5988);
jsonArray.element(4988);
// 这个JSONArray只包含int类型, 所以我们传入了Integer.class类对象。根据Integer.class类对象创建Java数组, 来封装JSONArray中的数据。
Object obj = JSONArray.toArray(jsonArray, Integer.class);
Integer[] intArr = (Integer[])obj;
for (Integer item : intArr) {
System.out.println(item);
}
}
/**
* 只包含基本元素
* @param jsonArray
*/
public static void baseElement(JSONArray jsonArray) {
jsonArray.element("HUAWEI P40 Pro");
jsonArray.element(true);
jsonArray.element(5988);
jsonArray.element(2601010188703L);
jsonArray.element(6.58D);
jsonArray.element(JSONNull.getInstance());
// 这个JSONArray包含String、boolean、int、long、double、JSONNull类型, 所以我们传入了Object.class类对象。
Object obj = JSONArray.toArray(jsonArray, Object.class);
Object[] objArr = (Object[])obj;
for (Object object : objArr) {
System.out.println(object);
}
}
/**
* 只包含Map对象的JSON对象类型
* @param jsonArray
*/
public static void mapJsonObjectElement(JSONArray jsonArray) {
Object obj = JSONArray.toArray(jsonArray, Map.class);
Map<String, String>[] mapArr = (Map<String, String>[])obj;
for (Map<String, String> map : mapArr) {
for (Entry<String, String> kv : map.entrySet()) {
System.out.println(kv.getKey() + ":" + kv.getValue());
}
}
}
/**
* 只包含JavaBean对象的JSON对象类型
* @param jsonArray
*/
public static void beanJsonObjectElement(JSONArray jsonArray) {
Object obj = JSONArray.toArray(jsonArray, Sensor.class);
Sensor[] sensorArr = (Sensor[])obj;
for (Sensor sensor : sensorArr) {
System.out.println(sensor);
}
}
/**
* 只包含JSONObject对象的JSON数组类型
* @param jsonArray
*/
public static void jsonObjectJsonObjectElement(JSONArray jsonArray) {
Object obj = JSONArray.toArray(jsonArray, JSONObject.class);
JSONObject[] jsonObjectArr = (JSONObject[])obj;
for (JSONObject jsonObject : jsonObjectArr) {
System.out.println(jsonObject);
}
}
/**
* 同时包含Map对象、JavaBean对象、JSONObject对象三种JSON对象类型, 可以传入一个Map.class类对象, 可以把这三种类型按键和值封装到Map对象里。
* @param jsonArray
*/
public static void jsonObjectElement(JSONArray jsonArray) {
Object obj = JSONArray.toArray(jsonArray, Map.class);
Map<String, Object>[] mapArr = (Map<String, Object>[])obj;
for (Map<String, Object> map : mapArr) {
for (Entry<String, Object> kv : map.entrySet()) {
System.out.println(kv.getKey() + ":" + kv.getValue());
}
}
}
/**
* 包含简单数组、集合、JSONArray的JSON数组类型, 会吧它们中的每一项按指定类型解析。
* 如果内部JSON数组包含String、boolean、int、long、double、JSONNull多种类型的简单数据, 也可以指定Object.class类对象。
* @param jsonArray
*/
public static void arrayListJsonArrayJsonArrayElement(JSONArray jsonArray) {
Object obj = JSONArray.toArray(jsonArray, String.class);
String[][] str2Arr = (String[][])obj;
for (String[] strArr : str2Arr) {
for (String str : strArr) {
System.out.println(str);
}
}
}
/**
* 只包含单一类型的JSONObject的JSON数组类型, 会吧它们中的每一JSONObject项按指定类型解析。
* @param jsonArray
*/
public static void listJsonObjectJsonArrayElement(JSONArray jsonArray) {
Object obj = JSONArray.toArray(jsonArray, Sensor.class);
Sensor[][] Sensor2Arr = (Sensor[][])obj;
for (Sensor[] SensorArr : Sensor2Arr) {
for (Sensor sensor : SensorArr) {
System.out.println(sensor);
}
}
}
/**
* 基本类型和JSON对象类型。我们无法准确的指定一个类型, 基本类型数据按照什么类型来解析, JSON对象类型数据按照什么类型来解析。传入一个Object.class类对象, 那么JSON对象类型的数据, 为Object对象分配键和值的时候会失败。
* @param jsonArray
*/
public static void baseAndJsonObjectElement(JSONArray jsonArray) {
Object obj = JSONArray.toArray(jsonArray, Object.class);
System.out.println(obj);
}
/**
* 基本类型和JSON数组类型, 报array element type mismatch错误。
* @param jsonArray
*/
public static void baseAndJsonArrayElement(JSONArray jsonArray) {
Object obj = JSONArray.toArray(jsonArray, Object.class);
System.out.println(obj);
}
/**
* JSON对象类型和JSON数组类型, 报array element type mismatch错误。
* @param jsonArray
*/
public static void jsonObjectAndJsonArrayElement(JSONArray jsonArray) {
Object obj = JSONArray.toArray(jsonArray, Object.class);
System.out.println(obj);
}
/**
* 基本类型、JSON对象类型和JSON数组类型, 报array element type mismatch错误。
* @param jsonArray
*/
public static void baseAndJsonObjectAndJsonArrayElement(JSONArray jsonArray) {
Object obj = JSONArray.toArray(jsonArray, Object.class);
System.out.println(obj);
}
}
4.3.3. 运行JSONArrayStaticToArrayObjectClass.java