afeilxc
afeilxc

jsonutil 学习使用

  1. package comm;   
  2.   
  3. import java.text.SimpleDateFormat;   
  4. import java.util.ArrayList;   
  5. import java.util.Collection;   
  6. import java.util.Date;   
  7. import java.util.HashMap;   
  8. import java.util.Iterator;   
  9. import java.util.List;   
  10. import java.util.Map;   
  11.   
  12. import net.sf.ezmorph.MorpherRegistry;   
  13. import net.sf.ezmorph.object.DateMorpher;   
  14. import net.sf.json.JSONArray;   
  15. import net.sf.json.JSONObject;   
  16. import net.sf.json.JsonConfig;   
  17. import net.sf.json.processors.JsonValueProcessor;   
  18. import net.sf.json.util.JSONUtils;   
  19. import net.sf.json.xml.XMLSerializer;   
  20.   
  21. public class JsonUtil {   
  22.   
  23.     /**  
  24.      * 设置日期转换格式  
  25.      */  
  26.     static {   
  27.         //注册器   
  28.         MorpherRegistry mr = JSONUtils.getMorpherRegistry();   
  29.   
  30.         //可转换的日期格式，即Json串中可以出现以下格式的日期与时间   
  31.         DateMorpher dm = new DateMorpher(new String[] { Util.YYYY_MM_DD,   
  32.                 Util.YYYY_MM_DD_HH_MM_ss, Util.HH_MM_ss, Util.YYYYMMDD,   
  33.                 Util.YYYYMMDDHHMMSS, Util.HHMMss });   
  34.         mr.registerMorpher(dm);   
  35.     }   
  36.   
  37.     /**  
  38.     * 从json串转换成实体对象  
  39.     * @param jsonObjStr e.g. {'name':'get','dateAttr':'2009-11-12'}  
  40.     * @param clazz Person.class  
  41.     * @return  
  42.     */  
  43.     public static Object getDtoFromJsonObjStr(String jsonObjStr, Class clazz) {   
  44.         return JSONObject.toBean(JSONObject.fromObject(jsonObjStr), clazz);   
  45.     }   
  46.   
  47.     /**  
  48.     * 从json串转换成实体对象，并且实体集合属性存有另外实体Bean  
  49.     * @param jsonObjStr e.g. {'data':[{'name':'get'},{'name':'set'}]}  
  50.     * @param clazz e.g. MyBean.class  
  51.     * @param classMap e.g. classMap.put("data", Person.class)  
  52.     * @return Object  
  53.     */  
  54.     public static Object getDtoFromJsonObjStr(String jsonObjStr, Class clazz, Map classMap) {   
  55.         return JSONObject.toBean(JSONObject.fromObject(jsonObjStr), clazz, classMap);   
  56.     }   
  57.   
  58.     /**  
  59.     * 把一个json数组串转换成普通数组  
  60.     * @param jsonArrStr  e.g. ['get',1,true,null]  
  61.     * @return Object[]  
  62.     */  
  63.     public static Object[] getArrFromJsonArrStr(String jsonArrStr) {   
  64.         return JSONArray.fromObject(jsonArrStr).toArray();   
  65.     }   
  66.   
  67.     /**  
  68.     * 把一个json数组串转换成实体数组  
  69.     * @param jsonArrStr e.g. [{'name':'get'},{'name':'set'}]  
  70.     * @param clazz e.g. Person.class  
  71.     * @return Object[]  
  72.     */  
  73.     public static Object[] getDtoArrFromJsonArrStr(String jsonArrStr, Class clazz) {   
  74.         JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);   
  75.         Object[] objArr = new Object[jsonArr.size()];   
  76.         for (int i = 0; i < jsonArr.size(); i++) {   
  77.             objArr[i] = JSONObject.toBean(jsonArr.getJSONObject(i), clazz);   
  78.         }   
  79.         return objArr;   
  80.     }   
  81.   
  82.     /**  
  83.     * 把一个json数组串转换成实体数组，且数组元素的属性含有另外实例Bean  
  84.     * @param jsonArrStr e.g. [{'data':[{'name':'get'}]},{'data':[{'name':'set'}]}]  
  85.     * @param clazz e.g. MyBean.class  
  86.     * @param classMap e.g. classMap.put("data", Person.class)  
  87.     * @return Object[]  
  88.     */  
  89.     public static Object[] getDtoArrFromJsonArrStr(String jsonArrStr, Class clazz,   
  90.             Map classMap) {   
  91.         JSONArray array = JSONArray.fromObject(jsonArrStr);   
  92.         Object[] obj = new Object[array.size()];   
  93.         for (int i = 0; i < array.size(); i++) {   
  94.             JSONObject jsonObject = array.getJSONObject(i);   
  95.             obj[i] = JSONObject.toBean(jsonObject, clazz, classMap);   
  96.         }   
  97.         return obj;   
  98.     }   
  99.   
  100.     /**  
  101.     * 把一个json数组串转换成存放普通类型元素的集合  
  102.     * @param jsonArrStr  e.g. ['get',1,true,null]  
  103.     * @return List  
  104.     */  
  105.     public static List getListFromJsonArrStr(String jsonArrStr) {   
  106.         JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);   
  107.         List list = new ArrayList();   
  108.         for (int i = 0; i < jsonArr.size(); i++) {   
  109.             list.add(jsonArr.get(i));   
  110.         }   
  111.         return list;   
  112.     }   
  113.   
  114.     /**  
  115.     * 把一个json数组串转换成集合，且集合里存放的为实例Bean  
  116.     * @param jsonArrStr e.g. [{'name':'get'},{'name':'set'}]  
  117.     * @param clazz  
  118.     * @return List  
  119.     */  
  120.     public static List getListFromJsonArrStr(String jsonArrStr, Class clazz) {   
  121.         JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);   
  122.         List list = new ArrayList();   
  123.         for (int i = 0; i < jsonArr.size(); i++) {   
  124.             list.add(JSONObject.toBean(jsonArr.getJSONObject(i), clazz));   
  125.         }   
  126.         return list;   
  127.     }   
  128.   
  129.     /**  
  130.     * 把一个json数组串转换成集合，且集合里的对象的属性含有另外实例Bean  
  131.     * @param jsonArrStr e.g. [{'data':[{'name':'get'}]},{'data':[{'name':'set'}]}]  
  132.     * @param clazz e.g. MyBean.class  
  133.     * @param classMap e.g. classMap.put("data", Person.class)  
  134.     * @return List  
  135.     */  
  136.     public static List getListFromJsonArrStr(String jsonArrStr, Class clazz, Map classMap) {   
  137.         JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);   
  138.         List list = new ArrayList();   
  139.         for (int i = 0; i < jsonArr.size(); i++) {   
  140.             list.add(JSONObject.toBean(jsonArr.getJSONObject(i), clazz, classMap));   
  141.         }   
  142.         return list;   
  143.     }   
  144.   
  145.     /**  
  146.     * 把json对象串转换成map对象  
  147.     * @param jsonObjStr e.g. {'name':'get','int':1,'double',1.1,'null':null}  
  148.     * @return Map  
  149.     */  
  150.     public static Map getMapFromJsonObjStr(String jsonObjStr) {   
  151.         JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);   
  152.   
  153.         Map map = new HashMap();   
  154.         for (Iterator iter = jsonObject.keys(); iter.hasNext();) {   
  155.             String key = (String) iter.next();   
  156.             map.put(key, jsonObject.get(key));   
  157.         }   
  158.         return map;   
  159.     }   
  160.   
  161.     /**  
  162.     * 把json对象串转换成map对象，且map对象里存放的为其他实体Bean  
  163.     * @param jsonObjStr e.g. {'data1':{'name':'get'},'data2':{'name':'set'}}  
  164.     * @param clazz e.g. Person.class  
  165.     * @return Map  
  166.     */  
  167.     public static Map getMapFromJsonObjStr(String jsonObjStr, Class clazz) {   
  168.         JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);   
  169.   
  170.         Map map = new HashMap();   
  171.         for (Iterator iter = jsonObject.keys(); iter.hasNext();) {   
  172.             String key = (String) iter.next();   
  173.             map.put(key, JSONObject.toBean(jsonObject.getJSONObject(key), clazz));   
  174.         }   
  175.         return map;   
  176.     }   
  177.   
  178.     /**  
  179.      * 把json对象串转换成map对象，且map对象里存放的其他实体Bean还含有另外实体Bean  
  180.      * @param jsonObjStr e.g. {'mybean':{'data':[{'name':'get'}]}}  
  181.      * @param clazz e.g. MyBean.class  
  182.      * @param classMap  e.g. classMap.put("data", Person.class)  
  183.      * @return Map  
  184.      */  
  185.     public static Map getMapFromJsonObjStr(String jsonObjStr, Class clazz, Map classMap) {   
  186.         JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);   
  187.   
  188.         Map map = new HashMap();   
  189.         for (Iterator iter = jsonObject.keys(); iter.hasNext();) {   
  190.             String key = (String) iter.next();   
  191.             map.put(key, JSONObject   
  192.                     .toBean(jsonObject.getJSONObject(key), clazz, classMap));   
  193.         }   
  194.         return map;   
  195.     }   
  196.   
  197.     /**  
  198.      * 把实体Bean、Map对象、数组、列表集合转换成Json串  
  199.      * @param obj   
  200.      * @return  
  201.      * @throws Exception String  
  202.      */  
  203.     public static String getJsonStr(Object obj) {   
  204.         String jsonStr = null;   
  205.         //Json配置       
  206.         JsonConfig jsonCfg = new JsonConfig();   
  207.   
  208.         //注册日期处理器   
  209.         jsonCfg.registerJsonValueProcessor(java.util.Date.class,   
  210.                 new JsonDateValueProcessor(Util.YYYY_MM_DD_HH_MM_ss));   
  211.         if (obj == null) {   
  212.             return "{}";   
  213.         }   
  214.   
  215.         if (obj instanceof Collection || obj instanceof Object[]) {   
  216.             jsonStr = JSONArray.fromObject(obj, jsonCfg).toString();   
  217.         } else {   
  218.             jsonStr = JSONObject.fromObject(obj, jsonCfg).toString();   
  219.         }   
  220.   
  221.         return jsonStr;   
  222.     }   
  223.   
  224.     /**  
  225.      * 把json串、数组、集合(collection map)、实体Bean转换成XML  
  226.      * XMLSerializer API：  
  227.      * http://json-lib.sourceforge.net/apidocs/net/sf/json/xml/XMLSerializer.html  
  228.      * 具体实例请参考：  
  229.      * http://json-lib.sourceforge.net/xref-test/net/sf/json/xml/TestXMLSerializer_writes.html  
  230.      * http://json-lib.sourceforge.net/xref-test/net/sf/json/xml/TestXMLSerializer_writes.html  
  231.      * @param obj   
  232.      * @return  
  233.      * @throws Exception String  
  234.      */  
  235.     public static String getXMLFromObj(Object obj) {   
  236.         XMLSerializer xmlSerial = new XMLSerializer();   
  237.   
  238.         //Json配置       
  239.         JsonConfig jsonCfg = new JsonConfig();   
  240.   
  241.         //注册日期处理器   
  242.         jsonCfg.registerJsonValueProcessor(java.util.Date.class,   
  243.                 new JsonDateValueProcessor(Util.YYYY_MM_DD_HH_MM_ss));   
  244.   
  245.         if ((String.class.isInstance(obj) && String.valueOf(obj).startsWith("["))   
  246.                 || obj.getClass().isArray() || Collection.class.isInstance(obj)) {   
  247.             JSONArray jsonArr = JSONArray.fromObject(obj, jsonCfg);   
  248.             return xmlSerial.write(jsonArr);   
  249.         } else {   
  250.             JSONObject jsonObj = JSONObject.fromObject(obj, jsonCfg);   
  251.             return xmlSerial.write(jsonObj);   
  252.         }   
  253.     }   
  254.   
  255.     /**  
  256.      * 从XML转json串  
  257.      * @param xml  
  258.      * @return String  
  259.      */  
  260.     public static String getJsonStrFromXML(String xml) {   
  261.         XMLSerializer xmlSerial = new XMLSerializer();   
  262.         return String.valueOf(xmlSerial.read(xml));   
  263.     }   
  264.   
  265. }   
  266.   
  267. /**  
  268.  * json日期值处理器实现    
  269.  * (C) 2009-9-11, jzj  
  270.  */  
  271. class JsonDateValueProcessor implements JsonValueProcessor {   
  272.   
  273.     private String format = Util.YYYY_MM_DD_HH_MM_ss;   
  274.   
  275.     public JsonDateValueProcessor() {   
  276.   
  277.     }   
  278.   
  279.     public JsonDateValueProcessor(String format) {   
  280.         this.format = format;   
  281.     }   
  282.   
  283.     public Object processArrayValue(Object value, JsonConfig jsonConfig) {   
  284.         return process(value, jsonConfig);   
  285.     }   
  286.   
  287.     public Object processObjectValue(String key, Object value, JsonConfig jsonConfig) {   
  288.         return process(value, jsonConfig);   
  289.     }   
  290.   
  291.     private Object process(Object value, JsonConfig jsonConfig) {   
  292.         if (value instanceof Date) {   
  293.             String str = new SimpleDateFormat(format).format((Date) value);   
  294.             return str;   
  295.         }   
  296.         return value == null ? null : value.toString();   
  297.     }   
  298.   
  299.     public String getFormat() {   
  300.         return format;   
  301.     }   
  302.   
  303.     public void setFormat(String format) {   
  304.         this.format = format;   
  305.     }   
  306.   
  307. }  
package comm;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import net.sf.ezmorph.MorpherRegistry;
import net.sf.ezmorph.object.DateMorpher;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;
import net.sf.json.processors.JsonValueProcessor;
import net.sf.json.util.JSONUtils;
import net.sf.json.xml.XMLSerializer;

public class JsonUtil {

	/**
	 * 设置日期转换格式
	 */
	static {
		//注册器
		MorpherRegistry mr = JSONUtils.getMorpherRegistry();

		//可转换的日期格式，即Json串中可以出现以下格式的日期与时间
		DateMorpher dm = new DateMorpher(new String[] { Util.YYYY_MM_DD,
				Util.YYYY_MM_DD_HH_MM_ss, Util.HH_MM_ss, Util.YYYYMMDD,
				Util.YYYYMMDDHHMMSS, Util.HHMMss });
		mr.registerMorpher(dm);
	}

	/**
	* 从json串转换成实体对象
	* @param jsonObjStr e.g. {'name':'get','dateAttr':'2009-11-12'}
	* @param clazz Person.class
	* @return
	*/
	public static Object getDtoFromJsonObjStr(String jsonObjStr, Class clazz) {
		return JSONObject.toBean(JSONObject.fromObject(jsonObjStr), clazz);
	}

	/**
	* 从json串转换成实体对象，并且实体集合属性存有另外实体Bean
	* @param jsonObjStr e.g. {'data':[{'name':'get'},{'name':'set'}]}
	* @param clazz e.g. MyBean.class
	* @param classMap e.g. classMap.put("data", Person.class)
	* @return Object
	*/
	public static Object getDtoFromJsonObjStr(String jsonObjStr, Class clazz, Map classMap) {
		return JSONObject.toBean(JSONObject.fromObject(jsonObjStr), clazz, classMap);
	}

	/**
	* 把一个json数组串转换成普通数组
	* @param jsonArrStr  e.g. ['get',1,true,null]
	* @return Object[]
	*/
	public static Object[] getArrFromJsonArrStr(String jsonArrStr) {
		return JSONArray.fromObject(jsonArrStr).toArray();
	}

	/**
	* 把一个json数组串转换成实体数组
	* @param jsonArrStr e.g. [{'name':'get'},{'name':'set'}]
	* @param clazz e.g. Person.class
	* @return Object[]
	*/
	public static Object[] getDtoArrFromJsonArrStr(String jsonArrStr, Class clazz) {
		JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
		Object[] objArr = new Object[jsonArr.size()];
		for (int i = 0; i < jsonArr.size(); i++) {
			objArr[i] = JSONObject.toBean(jsonArr.getJSONObject(i), clazz);
		}
		return objArr;
	}

	/**
	* 把一个json数组串转换成实体数组，且数组元素的属性含有另外实例Bean
	* @param jsonArrStr e.g. [{'data':[{'name':'get'}]},{'data':[{'name':'set'}]}]
	* @param clazz e.g. MyBean.class
	* @param classMap e.g. classMap.put("data", Person.class)
	* @return Object[]
	*/
	public static Object[] getDtoArrFromJsonArrStr(String jsonArrStr, Class clazz,
			Map classMap) {
		JSONArray array = JSONArray.fromObject(jsonArrStr);
		Object[] obj = new Object[array.size()];
		for (int i = 0; i < array.size(); i++) {
			JSONObject jsonObject = array.getJSONObject(i);
			obj[i] = JSONObject.toBean(jsonObject, clazz, classMap);
		}
		return obj;
	}

	/**
	* 把一个json数组串转换成存放普通类型元素的集合
	* @param jsonArrStr  e.g. ['get',1,true,null]
	* @return List
	*/
	public static List getListFromJsonArrStr(String jsonArrStr) {
		JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
		List list = new ArrayList();
		for (int i = 0; i < jsonArr.size(); i++) {
			list.add(jsonArr.get(i));
		}
		return list;
	}

	/**
	* 把一个json数组串转换成集合，且集合里存放的为实例Bean
	* @param jsonArrStr e.g. [{'name':'get'},{'name':'set'}]
	* @param clazz
	* @return List
	*/
	public static List getListFromJsonArrStr(String jsonArrStr, Class clazz) {
		JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
		List list = new ArrayList();
		for (int i = 0; i < jsonArr.size(); i++) {
			list.add(JSONObject.toBean(jsonArr.getJSONObject(i), clazz));
		}
		return list;
	}

	/**
	* 把一个json数组串转换成集合，且集合里的对象的属性含有另外实例Bean
	* @param jsonArrStr e.g. [{'data':[{'name':'get'}]},{'data':[{'name':'set'}]}]
	* @param clazz e.g. MyBean.class
	* @param classMap e.g. classMap.put("data", Person.class)
	* @return List
	*/
	public static List getListFromJsonArrStr(String jsonArrStr, Class clazz, Map classMap) {
		JSONArray jsonArr = JSONArray.fromObject(jsonArrStr);
		List list = new ArrayList();
		for (int i = 0; i < jsonArr.size(); i++) {
			list.add(JSONObject.toBean(jsonArr.getJSONObject(i), clazz, classMap));
		}
		return list;
	}

	/**
	* 把json对象串转换成map对象
	* @param jsonObjStr e.g. {'name':'get','int':1,'double',1.1,'null':null}
	* @return Map
	*/
	public static Map getMapFromJsonObjStr(String jsonObjStr) {
		JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);

		Map map = new HashMap();
		for (Iterator iter = jsonObject.keys(); iter.hasNext();) {
			String key = (String) iter.next();
			map.put(key, jsonObject.get(key));
		}
		return map;
	}

	/**
	* 把json对象串转换成map对象，且map对象里存放的为其他实体Bean
	* @param jsonObjStr e.g. {'data1':{'name':'get'},'data2':{'name':'set'}}
	* @param clazz e.g. Person.class
	* @return Map
	*/
	public static Map getMapFromJsonObjStr(String jsonObjStr, Class clazz) {
		JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);

		Map map = new HashMap();
		for (Iterator iter = jsonObject.keys(); iter.hasNext();) {
			String key = (String) iter.next();
			map.put(key, JSONObject.toBean(jsonObject.getJSONObject(key), clazz));
		}
		return map;
	}

	/**
	 * 把json对象串转换成map对象，且map对象里存放的其他实体Bean还含有另外实体Bean
	 * @param jsonObjStr e.g. {'mybean':{'data':[{'name':'get'}]}}
	 * @param clazz e.g. MyBean.class
	 * @param classMap	e.g. classMap.put("data", Person.class)
	 * @return Map
	 */
	public static Map getMapFromJsonObjStr(String jsonObjStr, Class clazz, Map classMap) {
		JSONObject jsonObject = JSONObject.fromObject(jsonObjStr);

		Map map = new HashMap();
		for (Iterator iter = jsonObject.keys(); iter.hasNext();) {
			String key = (String) iter.next();
			map.put(key, JSONObject
					.toBean(jsonObject.getJSONObject(key), clazz, classMap));
		}
		return map;
	}

	/**
	 * 把实体Bean、Map对象、数组、列表集合转换成Json串
	 * @param obj 
	 * @return
	 * @throws Exception String
	 */
	public static String getJsonStr(Object obj) {
		String jsonStr = null;
		//Json配置    
		JsonConfig jsonCfg = new JsonConfig();

		//注册日期处理器
		jsonCfg.registerJsonValueProcessor(java.util.Date.class,
				new JsonDateValueProcessor(Util.YYYY_MM_DD_HH_MM_ss));
		if (obj == null) {
			return "{}";
		}

		if (obj instanceof Collection || obj instanceof Object[]) {
			jsonStr = JSONArray.fromObject(obj, jsonCfg).toString();
		} else {
			jsonStr = JSONObject.fromObject(obj, jsonCfg).toString();
		}

		return jsonStr;
	}

	/**
	 * 把json串、数组、集合(collection map)、实体Bean转换成XML
	 * XMLSerializer API：
	 * http://json-lib.sourceforge.net/apidocs/net/sf/json/xml/XMLSerializer.html
	 * 具体实例请参考：
	 * http://json-lib.sourceforge.net/xref-test/net/sf/json/xml/TestXMLSerializer_writes.html
	 * http://json-lib.sourceforge.net/xref-test/net/sf/json/xml/TestXMLSerializer_writes.html
	 * @param obj 
	 * @return
	 * @throws Exception String
	 */
	public static String getXMLFromObj(Object obj) {
		XMLSerializer xmlSerial = new XMLSerializer();

		//Json配置    
		JsonConfig jsonCfg = new JsonConfig();

		//注册日期处理器
		jsonCfg.registerJsonValueProcessor(java.util.Date.class,
				new JsonDateValueProcessor(Util.YYYY_MM_DD_HH_MM_ss));

		if ((String.class.isInstance(obj) && String.valueOf(obj).startsWith("["))
				|| obj.getClass().isArray() || Collection.class.isInstance(obj)) {
			JSONArray jsonArr = JSONArray.fromObject(obj, jsonCfg);
			return xmlSerial.write(jsonArr);
		} else {
			JSONObject jsonObj = JSONObject.fromObject(obj, jsonCfg);
			return xmlSerial.write(jsonObj);
		}
	}

	/**
	 * 从XML转json串
	 * @param xml
	 * @return String
	 */
	public static String getJsonStrFromXML(String xml) {
		XMLSerializer xmlSerial = new XMLSerializer();
		return String.valueOf(xmlSerial.read(xml));
	}

}

/**
 * json日期值处理器实现  
 * (C) 2009-9-11, jzj
 */
class JsonDateValueProcessor implements JsonValueProcessor {

	private String format = Util.YYYY_MM_DD_HH_MM_ss;

	public JsonDateValueProcessor() {

	}

	public JsonDateValueProcessor(String format) {
		this.format = format;
	}

	public Object processArrayValue(Object value, JsonConfig jsonConfig) {
		return process(value, jsonConfig);
	}

	public Object processObjectValue(String key, Object value, JsonConfig jsonConfig) {
		return process(value, jsonConfig);
	}

	private Object process(Object value, JsonConfig jsonConfig) {
		if (value instanceof Date) {
			String str = new SimpleDateFormat(format).format((Date) value);
			return str;
		}
		return value == null ? null : value.toString();
	}

	public String getFormat() {
		return format;
	}

	public void setFormat(String format) {
		this.format = format;
	}

}

  • JsonUtilTest

Java代码  
  1. package comm.test;   
  2.   
  3. import java.text.SimpleDateFormat;   
  4. import java.util.ArrayList;   
  5. import java.util.Date;   
  6. import java.util.HashMap;   
  7. import java.util.Iterator;   
  8. import java.util.LinkedHashMap;   
  9. import java.util.LinkedHashSet;   
  10. import java.util.List;   
  11. import java.util.Map;   
  12. import java.util.Set;   
  13.   
  14. import junit.framework.TestCase;   
  15.   
  16. import comm.JsonUtil;   
  17.   
  18. /**  
  19.  * JsonUtil测试类  
  20.  * (C) 2009-9-11, jzj  
  21.  */  
  22. public class JsonUtilTest extends TestCase {   
  23.   
  24.     /**  
  25.      * 从json串转换成实体对象，且实体中Date属性能正确转换  
  26.      *  void  
  27.      */  
  28.     public void testGetDtoFromJsonObjStr1() {   
  29.         String json = "{'name':'get','dateAttr':'2009-11-12'}";   
  30.         Person ps = (Person) JsonUtil.getDtoFromJsonObjStr(json, Person.class);   
  31.         //print: get   
  32.         System.out.println(ps.getName());   
  33.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");   
  34.         //print: 2009-11-12   
  35.         System.out.println(sdf.format(ps.getDateAttr()));   
  36.     }   
  37.   
  38.     /**  
  39.      * 从json串转换成实体对象，并且实体集合属性存有另外实体Bean  
  40.      *  void  
  41.      */  
  42.     public void testGetDtoFromJsonObjStr3() {   
  43.         String json = "{'data':[{'name':'get'},{'name':'set'}]}";   
  44.         Map classMap = new HashMap();   
  45.         classMap.put("data", Person.class);   
  46.         MyBean myBean = (MyBean) JsonUtil.getDtoFromJsonObjStr(json, MyBean.class,   
  47.                 classMap);   
  48.         //print: class comm.test.Person name =get          
  49.         System.out.println(myBean.getData().get(0).getClass() + " name ="  
  50.                 + ((Person) myBean.getData().get(0)).getName());   
  51.         //print: class comm.test.Person name =set   
  52.         System.out.println(myBean.getData().get(1).getClass() + " name ="  
  53.                 + ((Person) myBean.getData().get(1)).getName());   
  54.     }   
  55.   
  56.     /**  
  57.      * 把一个json数组串转换成普通数组  
  58.      *  void  
  59.      */  
  60.     public void testGetArrFromJsonArrStr() {   
  61.         String json = "['get',1,true,null]";   
  62.         Object[] objArr = JsonUtil.getArrFromJsonArrStr(json);   
  63.         for (int i = 0; i < objArr.length; i++) {   
  64.             System.out.println(objArr[i].getClass() + " " + objArr[i]);   
  65.         }   
  66.         /*  print:  
  67.             class java.lang.String get  
  68.             class java.lang.Integer 1  
  69.             class java.lang.Boolean true  
  70.             class net.sf.json.JSONNull null  
  71.          */  
  72.     }   
  73.   
  74.     /**  
  75.      * 把一个json数组串转换成实体数组  
  76.      *  void  
  77.      */  
  78.     public void testGetDtoArrFromJsonArrStr1() {   
  79.         String json = "[{'name':'get'},{'name':'set'}]";   
  80.         Object[] objArr = JsonUtil.getDtoArrFromJsonArrStr(json, Person.class);   
  81.         for (int i = 0; i < objArr.length; i++) {   
  82.             System.out.println(objArr[i].getClass() + " name = "  
  83.                     + ((Person) objArr[i]).getName());   
  84.         }   
  85.         /*  print:  
  86.             class comm.test.Person name = get  
  87.             class comm.test.Person name = set  
  88.          */  
  89.     }   
  90.   
  91.     /**  
  92.      * 把一个json数组串转换成实体数组，且数组元素的属性含有另外实例Bean  
  93.      *  void  
  94.      */  
  95.     public void testGetDtoArrFromJsonArrStr2() {   
  96.         String json = "[{'data':[{'name':'get'}]},{'data':[{'name':'set'}]}]";   
  97.         Map classMap = new HashMap();   
  98.         classMap.put("data", Person.class);   
  99.         Object[] objArr = JsonUtil.getDtoArrFromJsonArrStr(json, MyBean.class, classMap);   
  100.         for (int i = 0; i < objArr.length; i++) {   
  101.             System.out.println(((MyBean) objArr[i]).getData().get(0).getClass()   
  102.                     + " name = "  
  103.                     + ((Person) ((MyBean) objArr[i]).getData().get(0)).getName());   
  104.         }   
  105.         /*  print:  
  106.             class comm.test.Person name = get  
  107.             class comm.test.Person name = set  
  108.          */  
  109.     }   
  110.   
  111.     /**  
  112.      * 把一个json数组串转换成存放普通类型元素的集合  
  113.      *  void  
  114.      */  
  115.     public void testGetListFromJsonArrStr1() {   
  116.         String json = "['get',1,true,null]";   
  117.         List list = JsonUtil.getListFromJsonArrStr(json);   
  118.         for (int i = 0; i < list.size(); i++) {   
  119.             System.out.println(list.get(i).getClass() + " " + list.get(i));   
  120.         }   
  121.         /*  print:  
  122.             class java.lang.String get  
  123.             class java.lang.Integer 1  
  124.             class java.lang.Boolean true  
  125.             class net.sf.json.JSONNull null  
  126.          */  
  127.     }   
  128.   
  129.     /**  
  130.      * 把一个json数组串转换成集合，且集合里存放的为实例Bean  
  131.      *  void  
  132.      */  
  133.     public void testGetListFromJsonArrStr2() {   
  134.         String json = "[{'name':'get'},{'name':'set'}]";   
  135.         List list = JsonUtil.getListFromJsonArrStr(json, Person.class);   
  136.         for (int i = 0; i < list.size(); i++) {   
  137.             System.out.println(list.get(i).getClass() + " name = "  
  138.                     + ((Person) list.get(i)).getName());   
  139.         }   
  140.         /*  print:  
  141.             class comm.test.Person name = get  
  142.             class comm.test.Person name = set  
  143.          */  
  144.     }   
  145.   
  146.     /**  
  147.      * 把一个json数组串转换成集合，且集合里的对象的属性含有另外实例Bean  
  148.      *  void  
  149.      */  
  150.     public void testGetListFromJsonArrStr3() {   
  151.         String json = "[{'data':[{'name':'get'}]},{'data':[{'name':'set'}]}]";   
  152.         Map classMap = new HashMap();   
  153.         classMap.put("data", Person.class);   
  154.         List list = JsonUtil.getListFromJsonArrStr(json, MyBean.class, classMap);   
  155.         for (int i = 0; i < list.size(); i++) {   
  156.             System.out.println(((MyBean) list.get(i)).getData().get(0).getClass()   
  157.                     + " name = "  
  158.                     + ((Person) ((MyBean) list.get(i)).getData().get(0)).getName());   
  159.         }   
  160.         /*  print:  
  161.             class comm.test.Person name = get  
  162.             class comm.test.Person name = set  
  163.          */  
  164.     }   
  165.   
  166.     /**  
  167.      * 把json对象串转换成map对象  
  168.      *  void  
  169.      */  
  170.     public void testGetMapFromJsonObjStr() {   
  171.         String json = "{'name':'get','int':1,'double':1.1,'null':null}";   
  172.         Map map = JsonUtil.getMapFromJsonObjStr(json);   
  173.         for (Iterator iter = map.keySet().iterator(); iter.hasNext();) {   
  174.             System.out.println(map.get(iter.next()).getClass());   
  175.         }   
  176.         /*  print:  
  177.             class java.lang.Double  
  178.             class net.sf.json.JSONNull  
  179.             class java.lang.Integer  
  180.             class java.lang.String  
  181.          */  
  182.     }   
  183.   
  184.     /**  
  185.      * 把json对象串转换成map对象，且map对象里存放的为其他实体Bean  
  186.      *  void  
  187.      */  
  188.     public void testGetMapFromJsonObjStr2() {   
  189.         String json = "{'data1':{'name':'get'},'data2':{'name':'set'}}";   
  190.         Map map = JsonUtil.getMapFromJsonObjStr(json, Person.class);   
  191.         for (Iterator iter = map.keySet().iterator(); iter.hasNext();) {   
  192.             String key = (String) iter.next();   
  193.             System.out.println(map.get(key).getClass() + " name="  
  194.                     + ((Person) map.get(key)).getName());   
  195.         }   
  196.         /*  print:  
  197.             class comm.test.Person name=set  
  198.             class comm.test.Person name=get  
  199.          */  
  200.     }   
  201.   
  202.     /**  
  203.      * 把json对象串转换成map对象，且map对象里  
  204.      * 存放的其他实体Bean还含有另外实体Bean  
  205.      *  void  
  206.      */  
  207.     public void testGetMapFromJsonObjStr3() {   
  208.         String json = "{'mybean':{'data':[{'name':'get'}]}}";   
  209.         Map classMap = new HashMap();   
  210.         classMap.put("data", Person.class);   
  211.         Map map = JsonUtil.getMapFromJsonObjStr(json, MyBean.class, classMap);   
  212.         for (Iterator iter = map.keySet().iterator(); iter.hasNext();) {   
  213.             String key = (String) iter.next();   
  214.             Object o = ((MyBean) map.get(key)).getData().get(0);   
  215.             System.out.println(o.getClass() + " name=" + ((Person) o).getName());   
  216.         }   
  217.         /*  print:  
  218.             class comm.test.Person name=get  
  219.          */  
  220.     }   
  221.   
  222.     /**  
  223.      * 实体Bean转json串  
  224.      *  void  
  225.      */  
  226.     public void testgetJsonStr1() {   
  227.         Person ps = new Person();   
  228.         ps.setDateAttr(new Date());   
  229.         ps.setName("get");   
  230.         MyBean myBean = new MyBean();   
  231.         List list = new ArrayList();   
  232.         list.add(ps);   
  233.   
  234.         myBean.setData(list);   
  235.         //print: {"data":[{"dateAttr":"2009-09-12 07:24:54","name":"get"}]}   
  236.         System.out.println(JsonUtil.getJsonStr(myBean));   
  237.     }   
  238.   
  239.     /**  
  240.      * map转json串  
  241.      *  void  
  242.      */  
  243.     public void testgetJsonStr2() {   
  244.         Person ps = new Person();   
  245.         ps.setDateAttr(new Date());   
  246.         ps.setName("get");   
  247.         Map map = new LinkedHashMap();   
  248.         map.put("person1", ps);   
  249.   
  250.         //print: {"person1":{"dateAttr":"2009-09-12 07:24:27","name":"get"}}   
  251.         System.out.println(JsonUtil.getJsonStr(map));   
  252.     }   
  253.   
  254.     /**  
  255.      * 数组转json串  
  256.      *  void  
  257.      */  
  258.     public void testgetJsonStr3() {   
  259.         Person ps = new Person();   
  260.         ps.setDateAttr(new Date());   
  261.         ps.setName("get");   
  262.         Person[] personArr = new Person[1];   
  263.         personArr[0] = ps;   
  264.         //print: [{"dateAttr":"2009-09-12 07:23:54","name":"get"}]   
  265.         System.out.println(JsonUtil.getJsonStr(personArr));   
  266.     }   
  267.   
  268.     /**  
  269.      * list转json串  
  270.      *  void  
  271.      */  
  272.     public void testgetJsonStr4() {   
  273.         Person ps = new Person();   
  274.         ps.setDateAttr(new Date());   
  275.         ps.setName("get");   
  276.         List list = new ArrayList();   
  277.         list.add(ps);   
  278.   
  279.         //print: [{"dateAttr":"2009-09-12 07:22:49","name":"get"}]   
  280.         System.out.println(JsonUtil.getJsonStr(list));   
  281.     }   
  282.   
  283.     /**  
  284.      * set转json串  
  285.      *  void  
  286.      */  
  287.     public void testgetJsonStr5() {   
  288.         Person ps = new Person();   
  289.         ps.setDateAttr(new Date());   
  290.         ps.setName("get");   
  291.         Set set = new LinkedHashSet();   
  292.         set.add(ps);   
  293.   
  294.         //print: [{"dateAttr":"2009-09-12 07:22:16","name":"get"}]   
  295.         System.out.println(JsonUtil.getJsonStr(set));   
  296.     }   
  297.   
  298.     /**  
  299.      * json对象串转XML  
  300.      *  void  
  301.      */  
  302.     public void testGetXMLFromObj1() {   
  303.         System.out.println(JsonUtil   
  304.                 .getXMLFromObj("{/"name/":/"json/",/"bool/":true,/"int/":1}"));   
  305.         /*  print:  
  306.               
  307.               
  308.                 true  
  309.                 1  
  310.                 json  
  311.               
  312.          */  
  313.     }   
  314.   
  315.     /**  
  316.      * json数组串转XML  
  317.      *  void  
  318.      */  
  319.     public void testGetXMLFromObj2() {   
  320.         System.out.println(JsonUtil.getXMLFromObj("[1,2,3]"));   
  321.         /*  print:  
  322.               
  323.               
  324.                 1  
  325.                 2  
  326.                 3  
  327.               
  328.          */  
  329.     }   
  330.   
  331.     /**  
  332.      * java数组转XML  
  333.      *  void  
  334.      */  
  335.     public void testGetXMLFromObj3() {   
  336.         Person ps = new Person();   
  337.         ps.setDateAttr(new Date());   
  338.         ps.setName("get");   
  339.         Person[] personArr = new Person[2];   
  340.         personArr[0] = ps;   
  341.   
  342.         System.out.println(JsonUtil.getXMLFromObj(personArr));   
  343.         /*  print:  
  344.               
  345.               
  346.                   
  347.                     2009-09-12 06:58:55  
  348.                     get  
  349.                   
  350.               
  351.          */  
  352.     }   
  353.   
  354.     /**  
  355.      * list转XML  
  356.      *  void  
  357.      */  
  358.     public void testGetXMLFromObj4() {   
  359.         Person ps = new Person();   
  360.         ps.setDateAttr(new Date());   
  361.         ps.setName("get");   
  362.         List list = new ArrayList();   
  363.         list.add(ps);   
  364.   
  365.         System.out.println(JsonUtil.getXMLFromObj(list));   
  366.         /*  print:  
  367.               
  368.               
  369.                   
  370.                     2009-09-12 07:02:31  
  371.                     get  
  372.                   
  373.               
  374.          */  
  375.     }   
  376.   
  377.     /**  
  378.      * set转XML  
  379.      * void  
  380.      */  
  381.     public void testGetXMLFromObj5() {   
  382.         Person ps = new Person();   
  383.         ps.setDateAttr(new Date());   
  384.         ps.setName("get");   
  385.         Set set = new LinkedHashSet();   
  386.         set.add(ps);   
  387.   
  388.         System.out.println(JsonUtil.getXMLFromObj(set));   
  389.         /*  print:  
  390.               
  391.               
  392.                   
  393.                     2009-09-12 07:04:38  
  394.                     get  
  395.                   
  396.               
  397.          */  
  398.     }   
  399.   
  400.     /**  
  401.      * map转XML  
  402.      *  void  
  403.      */  
  404.     public void testGetXMLFromObj6() {   
  405.         Person ps = new Person();   
  406.         ps.setDateAttr(new Date());   
  407.         ps.setName("get");   
  408.         Map map = new HashMap();   
  409.         map.put("person1", ps);   
  410.   
  411.         System.out.println(JsonUtil.getXMLFromObj(map));   
  412.         /*  print:  
  413.               
  414.               
  415.                   
  416.                     2009-09-12 07:08:35  
  417.                     get  
  418.                   
  419.               
  420.          */  
  421.     }   
  422.   
  423.     /**  
  424.      * 实体Bean转XML  
  425.      *  void  
  426.      */  
  427.     public void testGetXMLFromObj7() {   
  428.         Person ps = new Person();   
  429.         ps.setDateAttr(new Date());   
  430.         ps.setName("get");   
  431.         System.out.println(JsonUtil.getXMLFromObj(ps));   
  432.         /*  print:  
  433.               
  434.               
  435.                 2009-09-12 07:13:02  
  436.                 get  
  437.               
  438.          */  
  439.     }   
  440.   
  441.     /**  
  442.      * 从XML对象串转json串  
  443.      *  void  
  444.      */  
  445.     public void testGetJsonStrFromXML1() {   
  446.         String xml = "2009-09-12 07:13:02"  
  447.                 + "get";   
  448.         //print: {"dateAttr":"2009-09-12 07:13:02","name":"get"}   
  449.         System.out.println(JsonUtil.getJsonStrFromXML(xml));   
  450.     }   
  451.   
  452.     /**  
  453.      * 从XML数组串转json串  
  454.      *  void  
  455.      */  
  456.     public void testGetJsonStrFromXML2() {   
  457.         String xml = "2009-09-12 07:04:38"  
  458.                 + "get";   
  459.         //print: [{"dateAttr":"2009-09-12 07:04:38","name":"get"}]   
  460.         System.out.println(JsonUtil.getJsonStrFromXML(xml));   
  461.     }   
  462. }

你可能感兴趣的:(JavaEE,json,string,object,bean,list,encoding)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • 每日一题——第九十题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • WPF中的ComboBox控件几种数据绑定的方式 互联网打工人no1 wpfc#
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享C++Leetcode题解
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
  • docker igotyback eureka云原生
    Docker容器的文件系统是隔离的，但是可以通过挂载卷（Volumes）或绑定挂载（BindMounts）将宿主机的文件系统目录映射到容器内部。要查看Docker容器的映射路径，可以使用以下方法：查看容器配置：使用dockerinspect命令可以查看容器的详细配置信息，包括挂载的卷。例如：bashdockerinspect在输出的JSON格式中，查找"Mounts"部分，这里会列出所有的挂载信息
  • 在Ubuntu中编译含有JSON的文件出现报错 芝麻糊76 Linuxkill_buglinuxubuntujson
    在ubuntu中进行JSON相关学习的时候，我发现了一些小问题，决定与大家进行分享，减少踩坑时候出现不必要的时间耗费截取部分含有JSON部分的代码进行展示char*str="{\"title\":\"JSONExample\",\"author\":{\"name\":\"JohnDoe\",\"age\":35,\"isVerified\":true},\"tags\":[\"json\",\"
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • Xinference如何注册自定义模型 玩人工智能的辣条哥 人工智能AI大模型Xinference
    环境：Xinference问题描述：Xinference如何注册自定义模型解决方案：1.写个model_config.json，内容如下{"version":1,"context_length":2048,"model_name":"custom-llama-3","model_lang":["en","ch"],"model_ability":["generate","chat"],"model
  • 一文掌握python常用的list（列表）操作 程序员neil pythonpython开发语言
    目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
  • python中的深拷贝与浅拷贝 anshejd70787 python
    深拷贝和浅拷贝浅拷贝的时候，修改原来的对象，浅拷贝的对象不会发生改变。1、对象的赋值对象的赋值实际上是对象之间的引用：当创建一个对象，然后将这个对象赋值给另外一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。当对对象做赋值或者是参数传递或者作为返回值的时候，总是传递原始对象的引用，而不是一个副本。如下所示：>>>aList=["kel","abc",123]>>>bLis
  • 用Python实现读取统计单词个数 程序媛了了 python游戏java
    完整实例代码：fromcollectionsimportCounterdefpythonit():danci={}withopen("pythonit.txt","r",encoding="utf-8")asf:foriinf:words=i.strip().split()forwordinwords:ifwordnotindanci:danci[word]=1else:danci[word]+=
  • 2024.9.6 Python，华为笔试题总结，字符串格式化，字符串操作，广度优先搜索解决公司组织绩效互评问题，无向图 RaidenQ python华为leetcode算法力扣广度优先无向图
    1.字符串格式化name="Alice"age=30formatted_string="Name:{},Age:{}".format(name,age)print(formatted_string)或者name="Alice"age=30formatted_string=f"Name:{name},Age:{age}"print(formatted_string)2.网络健康检查第一行有两个整数m
  • 2024.8.22 Python，链表两数之和，链表快速反转，二叉树的深度，二叉树前中后序遍历，N叉树递归遍历，翻转二叉树 RaidenQ python链表开发语言
    1.链表两数之和输入：l1=[2,4,3],l2=[5,6,4]输出：[7,0,8]解释：342+465=807.示例2：输入：l1=[0],l2=[0]输出：[0]示例3：输入：l1=[9,9,9,9,9,9,9],l2=[9,9,9,9]输出：[8,9,9,9,0,0,0,1]昨天的这个题，用自己的办法写的麻烦的要死，然后刚才一看chat归类的办法，感觉自己像个智障。classListNode
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Vue中table合并单元格用法 weixin_30613343 javascriptViewUI
    地名结果人名性别{{item.name}}已完成未完成{{item.groups[0].name}}{{item.groups[0].sex}}{{item.groups[son].name}}{{item.groups[son].sex}}exportdefault{data(){return{list:[{name:'地名1',result:'1',groups:[{name:'张三',sex
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • tiff批量转png 诺有缸的高飞鸟 opencv图像处理pythonopencv图像处理
    目录写在前面代码完写在前面1、本文内容tiff批量转png2、平台/环境opencv,python3、转载请注明出处：https://blog.csdn.net/qq_41102371/article/details/132975023代码importnumpyasnpimportcv2importosdeffindAllFile(base):file_list=[]forroot,ds,fsin
  • iOS内存管理简单理解 烧烤有点辣
    什么是引用计数引用计数（ReferenceCount）是一个简单而有效的管理对象生命周期的方式。当我们创建一个新对象的时候，它的引用计数为1，当有一个新的指针指向这个对象时，我们将其引用计数加1，当某个指针不再指向这个对象是，我们将其引用计数减1，当对象的引用计数变为0时，说明这个对象不再被任何指针指向了，这个时候我们就可以将对象销毁，回收内存。由于引用计数简单有效，除了Objective-C和S
  • 更改npm镜像源为淘宝镜像 骆小骆 基于node.js
    npm常用指令后缀*最近复习了一下node.js整理了一下跟node.js相关的指令后缀*--save、-S参数意思是把模块的版本信息保存到dependencies（生产环境依赖）中，即你的package.json文件的dependencies字段中；–--save-dev、-D参数意思是把模块版本信息保存到devDependencies（开发环境依赖）中，即你的package.json文件的de
  • COCO 格式的数据集转化为 YOLO 格式的数据集 QYQY77 YOLOpython
    """--json_path输入的json文件路径--save_path保存的文件夹名字，默认为当前目录下的labels。"""importosimportjsonfromtqdmimporttqdmimportargparseparser=argparse.ArgumentParser()parser.add_argument('--json_path',default='./instances
  • 非对称加密算法原理与应用2——RSA私钥加密文件 私语茶馆 云部署与开发架构及产品灵感记录RSA2048私钥加密
    作者：私语茶馆1.相关章节（1）非对称加密算法原理与应用1——秘钥的生成-CSDN博客第一章节讲述的是创建秘钥对，并将公钥和私钥导出为文件格式存储。本章节继续讲如何利用私钥加密内容，包括从密钥库或文件中读取私钥，并用RSA算法加密文件和String。2.私钥加密的概述本文主要基于第一章节的RSA2048bit的非对称加密算法讲述如何利用私钥加密文件。这种加密后的文件，只能由该私钥对应的公钥来解密。
  • 粒子群优化 (PSO) 在三维正弦波函数中的应用 subject625Ruben 机器学习人工智能matlab算法
    在这篇博客中，我们将展示如何使用粒子群优化（PSO）算法求解三维正弦波函数，并通过增加正弦波扰动，使优化过程更加复杂和有趣。本文将介绍目标函数的定义、PSO参数设置以及算法执行的详细过程，并展示搜索空间中的动态过程和收敛曲线。1.目标函数定义我们使用的目标函数是一个三维正弦波函数，定义如下：objectiveFunc=@(x)sin(sqrt(x(1).^2+x(2).^2))+0.5*sin(5
  • 自定义队列 junjun2018
    队列：像排队吃饭一样，先到的先点菜，后来的后点菜。以下代码展示使用单向列表实现的队列。//链表是以节点为单位的，对于单向链表，每个节点中包含一个值和指向下一个对象的引用publicclassNode{Objectvalue;Nodenext;publicNode(Objectvalue){this.value=value;}publicObjectgetValue(){returnvalue;}p
  • 《 C++ 修炼全景指南：四 》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表 Lenyiin 技术指南C++修炼全景指南c++list链表stl
    本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
  • 使用由 Python 编写的 lxml 实现高性能 XML 解析 hunyxv python笔记pythonxml
    转载自：文章lxml简介Python从来不出现XML库短缺的情况。从2.0版本开始，它就附带了xml.dom.minidom和相关的pulldom以及SimpleAPIforXML(SAX)模块。从2.4开始，它附带了流行的ElementTreeAPI。此外，很多第三方库可以提供更高级别的或更具有python风格的接口。尽管任何XML库都足够处理简单的DocumentObjectModel(DOM
  • LeetCode[位运算] - #137 Single Number II Cwind javaAlgorithmLeetCode题解位运算
    原题链接：#137 Single Number II  要求： 给定一个整型数组，其中除了一个元素之外，每个元素都出现三次。找出这个元素 注意：算法的时间复杂度应为O(n)，最好不使用额外的内存空间   难度：中等   分析： 与#136类似，都是考察位运算。不过出现两次的可以使用异或运算的特性 n XOR n = 0, n XOR 0 = n，即某一
  • 《JavaScript语言精粹》笔记 aijuans JavaScript
    0、JavaScript的简单数据类型包括数字、字符创、布尔值（true/false）、null和undefined值，其它值都是对象。 1、JavaScript只有一个数字类型，它在内部被表示为64位的浮点数。没有分离出整数，所以1和1.0的值相同。 2、NaN是一个数值，表示一个不能产生正常结果的运算结果。NaN不等于任何值，包括它本身。可以用函数isNaN(number)检测NaN,但是
  • 你应该更新的Java知识之常用程序库 Kai_Ge java
    在很多人眼中，Java 已经是一门垂垂老矣的语言，但并不妨碍 Java 世界依然在前进。如果你曾离开 Java，云游于其它世界，或是每日只在遗留代码中挣扎，或许是时候抬起头，看看老 Java 中的新东西。 Guava Guava[gwɑ:və]，一句话，只要你做Java项目，就应该用Guava（Github）。 guava 是 Google 出品的一套 Java 核心库，在我看来，它甚至应该
  • HttpClient 120153216 httpclient
    /** * 可以传对象的请求转发，对象已流形式放入HTTP中 */ public static Object doPost(Map<String,Object> parmMap,String url) { Object object = null; HttpClient hc = new HttpClient(); String fullURL
  • Django model字段类型清单 2002wmj django
    Django 通过 models 实现数据库的创建、修改、删除等操作，本文为模型中一般常用的类型的清单，便于查询和使用： AutoField：一个自动递增的整型字段，添加记录时它会自动增长。你通常不需要直接使用这个字段；如果你不指定主键的话，系统会自动添加一个主键字段到你的model。(参阅自动主键字段) BooleanField：布尔字段,管理工具里会自动将其描述为checkbox。 Cha
  • 在SQLSERVER中查找消耗CPU最多的SQL 357029540 SQL Server
    返回消耗CPU数目最多的10条语句 SELECT TOP 10    total_worker_time/execution_count AS avg_cpu_cost, plan_handle,    execution_count,    (SELECT SUBSTRING(text, statement_start_of
  • Myeclipse项目无法部署，Undefined exploded archive location 7454103 eclipseMyEclipse
    做个备忘！ 错误信息为：       Undefined exploded archive location 原因：           在工程转移过程中，导致工程的配置文件出错； 解决方法：    
  • GMT时间格式转换 adminjun GMT时间转换
    普通的时间转换问题我这里就不再罗嗦了，我想大家应该都会那种低级的转换问题吧，现在我向大家总结一下如何转换GMT时间格式，这种格式的转换方法网上还不是很多，所以有必要总结一下，也算给有需要的朋友一个小小的帮助啦。 1、可以使用 SimpleDateFormat SimpleDateFormat    EEE-三位星期 d-天 MMM-月 yyyy-四位年
  • Oracle数据库新装连接串问题 aijuans oracle数据库
    割接新装了数据库，客户端登陆无问题，apache/cgi-bin程序有问题，sqlnet.log日志如下： Fatal NI connect error 12170.   VERSION INFORMATION:         TNS for Linux: Version 10.2.0.4.0 - Product
  • 回顾java数组复制 ayaoxinchao java数组
    在写这篇文章之前，也看了一些别人写的，基本上都是大同小异。文章是对java数组复制基础知识的回顾，算是作为学习笔记，供以后自己翻阅。首先，简单想一下这个问题：为什么要复制数组？我的个人理解：在我们在利用一个数组时，在每一次使用，我们都希望它的值是初始值。这时我们就要对数组进行复制，以达到原始数组值的安全性。java数组复制大致分为3种方式：①for循环方式 ②clone方式 ③arrayCopy方
  • java web会话监听并使用spring注入 bewithme Java Web
            在java web应用中，当你想在建立会话或移除会话时，让系统做某些事情，比如说，统计在线用户，每当有用户登录时，或退出时，那么可以用下面这个监听器来监听。        import java.util.ArrayList; import java.ut
  • NoSQL数据库之Redis数据库管理(Redis的常用命令及高级应用) bijian1013 redis数据库NoSQL
    一 .Redis常用命令         Redis提供了丰富的命令对数据库和各种数据库类型进行操作，这些命令可以在Linux终端使用。         a.键值相关命令         b.服务器相关命令 1.键值相关命令       &
  • java枚举序列化问题 bingyingao java枚举序列化
    对象在网络中传输离不开序列化和反序列化。而如果序列化的对象中有枚举值就要特别注意一些发布兼容问题: 1.加一个枚举值 新机器代码读分布式缓存中老对象，没有问题，不会抛异常。 老机器代码读分布式缓存中新对像，反序列化会中断，所以在所有机器发布完成之前要避免出现新对象，或者提前让老机器拥有新增枚举的jar。 2.删一个枚举值 新机器代码读分布式缓存中老对象，反序列
  • 【Spark七十八】Spark Kyro序列化 bit1129 spark
    当使用SparkContext的saveAsObjectFile方法将对象序列化到文件，以及通过objectFile方法将对象从文件反序列出来的时候，Spark默认使用Java的序列化以及反序列化机制，通常情况下，这种序列化机制是很低效的，Spark支持使用Kyro作为对象的序列化和反序列化机制，序列化的速度比java更快，但是使用Kyro时要注意，Kyro目前还是有些bug。 Spark
  • Hybridizing OO and Functional Design bookjovi erlanghaskell
      推荐博文： Tell Above, and Ask Below - Hybridizing OO and Functional Design 文章中把OO和FP讲的深入透彻，里面把smalltalk和haskell作为典型的两种编程范式代表语言，此点本人极为同意，smalltalk可以说是最能体现OO设计的面向对象语言，smalltalk的作者Alan kay也是OO的最早先驱，
  • Java-Collections Framework学习与总结-HashMap BrokenDreams Collections
            开发中常常会用到这样一种数据结构，根据一个关键字，找到所需的信息。这个过程有点像查字典，拿到一个key，去字典表中查找对应的value。Java1.0版本提供了这样的类java.util.Dictionary(抽象类)，基本上支持字典表的操作。后来引入了Map接口，更好的描述的这种数据结构。  &nb
  • 读《研磨设计模式》-代码笔记-职责链模式-Chain Of Responsibility bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /** * 业务逻辑：项目经理只能处理500以下的费用申请，部门经理是1000，总经理不设限。简单起见，只同意“Tom”的申请 * bylijinnan */ abstract class Handler { /*
  • Android中启动外部程序 cherishLC android
    1、启动外部程序 引用自： http://blog.csdn.net/linxcool/article/details/7692374 //方法一 Intent intent=new Intent(); //包名 包名+类名（全路径） intent.setClassName("com.linxcool", "com.linxcool.PlaneActi
  • summary_keep_rate coollyj SUM
    BEGIN /*DECLARE minDate varchar(20) ; DECLARE maxDate varchar(20) ;*/ DECLARE stkDate varchar(20) ; DECLARE done int default -1; /* 游标中 注册服务器地址 */ DE
  • hadoop hdfs 添加数据目录出错 daizj hadoophdfs扩容
    由于原来配置的hadoop data目录快要用满了，故准备修改配置文件增加数据目录，以便扩容，但由于疏忽，把core-site.xml, hdfs-site.xml配置文件dfs.datanode.data.dir 配置项增加了配置目录，但未创建实际目录，重启datanode服务时，报如下错误： 2014-11-18 08:51:39,128 WARN org.apache.hadoop.h
  • grep 目录级联查找 dongwei_6688 grep
           在Mac或者Linux下使用grep进行文件内容查找时，如果给定的目标搜索路径是当前目录，那么它默认只搜索当前目录下的文件，而不会搜索其下面子目录中的文件内容，如果想级联搜索下级目录，需要使用一个“-r”参数： grep -n -r "GET" .   上面的命令将会找出当前目录“.”及当前目录中所有下级目录
  • yii 修改模块使用的布局文件 dcj3sjt126com yiilayouts
    方法一：yii模块默认使用系统当前的主题布局文件，如果在主配置文件中配置了主题比如: 'theme'=>'mythm', 那么yii的模块就使用 protected/themes/mythm/views/layouts 下的布局文件； 如果未配置主题，那么 yii的模块就使用  protected/views/layouts 下的布局文件， 总之默认不是使用自身目录 pr
  • 设计模式之单例模式 come_for_dream 设计模式单例模式懒汉式饿汉式双重检验锁失败无序写入
                    今天该来的面试还没来，这个店估计不会来电话了，安静下来写写博客也不错，没事翻了翻小易哥的博客甚至与大牛们之间的差距，基础知识不扎实建起来的楼再高也只能是危楼罢了，陈下心回归基础把以前学过的东西总结一下。   *********************************
  • 8、数组 豆豆咖啡 二维数组数组一维数组
      一、概念       数组是同一种类型数据的集合。其实数组就是一个容器。   二、好处       可以自动给数组中的元素从0开始编号，方便操作这些元素   三、格式   //一维数组 1,元素类型[] 变量名 = new 元素类型[元素的个数] int[] arr =
  • Decode Ways hcx2013 decode
    A message containing letters from A-Z is being encoded to numbers using the following mapping: 'A' -> 1 'B' -> 2 ... 'Z' -> 26 Given an encoded message containing digits, det
  • Spring4.1新特性——异步调度和事件机制的异常处理 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • squid3(高命中率)缓存服务器配置 liyonghui160com
        系统:centos 5.x   需要的软件:squid-3.0.STABLE25.tar.gz 1.下载squid wget http://www.squid-cache.org/Versions/v3/3.0/squid-3.0.STABLE25.tar.gz tar zxf squid-3.0.STABLE25.tar.gz &&
  • 避免Java应用中NullPointerException的技巧和最佳实践 pda158 java
    1) 从已知的String对象中调用equals()和equalsIgnoreCase()方法，而非未知对象。 　　总是从已知的非空String对象中调用equals()方法。因为equals()方法是对称的，调用a.equals(b)和调用b.equals(a)是完全相同的，这也是为什么程序员对于对象a和b这么不上心。如果调用者是空指针，这种调用可能导致一个空指针异常 Object unk
  • 如何在Swift语言中创建http请求 shoothao httpswift
    概述：本文通过实例从同步和异步两种方式上回答了”如何在Swift语言中创建http请求“的问题。 如果你对Objective-C比较了解的话，对于如何创建http请求你一定驾轻就熟了，而新语言Swift与其相比只有语法上的区别。但是，对才接触到这个崭新平台的初学者来说，他们仍然想知道“如何在Swift语言中创建http请求？”。 在这里,我将作出一些建议来回答上述问题。常见的
  • Spring事务的传播方式 uule spring事务
    传播方式：        新建事务       required       required_new   - 挂起当前         非事务方式运行       supports   &nbs
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他