005_JSONArray对象静态方法

最新推荐文章于 2022-11-11 10:20:23 发布

自由与束缚JavaJavaScript

最新推荐文章于 2022-11-11 10:20:23 发布

阅读量651

点赞数

分类专栏： Json-lib学习

本文链接：https://blog.csdn.net/aihiao/article/details/116151641

版权

Json-lib学习专栏收录该内容

9 篇文章 0 订阅

订阅专栏

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

自由与束缚JavaJavaScript

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
005_JSONArray对象静态方法

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.
复制链接

扫一扫

专栏目录