ANDROID轻量级JSON序列化和反序列化

[java]  view plain copy

1. import java.lang.reflect.Array;  
2. import java.lang.reflect.Field;  
3. import java.lang.reflect.Method;  
4. import java.lang.reflect.ParameterizedType;  
5. import java.lang.reflect.Type;  
6. import java.text.SimpleDateFormat;  
7. import java.util.ArrayList;  
8. import java.util.Collection;  
9. import java.util.Date;  
10. import java.util.HashMap;  
11. import java.util.HashSet;  
12. import java.util.Iterator;  
13. import java.util.List;  
14. import java.util.Locale;  
15. import java.util.Map;  
16. import java.util.Set;  
17.   
18. import org.json.JSONArray;  
19. import org.json.JSONException;  
20. import org.json.JSONObject;  
21. import org.json.JSONStringer;  
22.   
23. import android.util.Log;  
24.   
25.   
26. /** 
27.  * @author keane 
28.  *  
29.  */  
30. public class JSONHelper {  
31.     private static String TAG = "JSONHelper";  
32.   
33.     /** 
34.      * 将对象转换成Json字符串 
35.      * @param obj 
36.      * @return json类型字符串 
37.      */  
38.     public static String toJSON(Object obj) {  
39.         JSONStringer js = new JSONStringer();  
40.         serialize(js, obj);  
41.         return js.toString();  
42.     }  
43.   
44.     /** 
45.      * 序列化为JSON 
46.      * @param js json对象 
47.      * @param o 待需序列化的对象 
48.      */  
49.     private static void serialize(JSONStringer js, Object o) {  
50.         if (isNull(o)) {  
51.             try {  
52.                 js.value(null);  
53.             } catch (JSONException e) {  
54.                 e.printStackTrace();  
55.             }  
56.             return;  
57.         }  
58.   
59.         Class<?> clazz = o.getClass();  
60.         if (isObject(clazz)) { // 对象  
61.             serializeObject(js, o);  
62.         } else if (isArray(clazz)) { // 数组  
63.             serializeArray(js, o);  
64.         } else if (isCollection(clazz)) { // 集合  
65.             Collection<?> collection = (Collection<?>) o;  
66.             serializeCollect(js, collection);  
67.         }else if (isMap(clazz)) { // 集合  
68.             HashMap<?,?> collection = (HashMap<?,?>) o;  
69.             serializeMap(js, collection);  
70.         } else { // 单个值  
71.             try {  
72.                 js.value(o);  
73.             } catch (JSONException e) {  
74.                 e.printStackTrace();  
75.             }  
76.         }  
77.     }  
78.   
79.     /** 
80.      * 序列化数组  
81.      * @param js    json对象 
82.      * @param array 数组 
83.      */  
84.     private static void serializeArray(JSONStringer js, Object array) {  
85.         try {  
86.             js.array();  
87.             for (int i = 0; i < Array.getLength(array); ++i) {  
88.                 Object o = Array.get(array, i);  
89.                 serialize(js, o);  
90.             }  
91.             js.endArray();  
92.         } catch (Exception e) {  
93.             e.printStackTrace();  
94.         }  
95.     }  
96.   
97.     /** 
98.      * 序列化集合 
99.      * @param js    json对象 
100.      * @param collection    集合 
101.      */  
102.     private static void serializeCollect(JSONStringer js, Collection<?> collection) {  
103.         try {  
104.             js.array();  
105.             for (Object o : collection) {  
106.                 serialize(js, o);  
107.             }  
108.             js.endArray();  
109.         } catch (Exception e) {  
110.             e.printStackTrace();  
111.         }  
112.     }  
113.       
114.     /** 
115.      * 序列化Map 
116.      * @param js    json对象 
117.      * @param map   map对象 
118.      */  
119.     private static void serializeMap(JSONStringer js, Map<?,?> map) {  
120.         try {  
121.             js.object();  
122.             @SuppressWarnings("unchecked")  
123.             Map<String, Object> valueMap = (Map<String, Object>) map;  
124.             Iterator<Map.Entry<String, Object>> it = valueMap.entrySet().iterator();  
125.             while (it.hasNext()) {  
126.                 Map.Entry<String, Object> entry = (Map.Entry<String, Object>)it.next();  
127.                 js.key(entry.getKey());  
128.                 serialize(js,entry.getValue());  
129.             }  
130.             js.endObject();  
131.         } catch (Exception e) {  
132.             e.printStackTrace();  
133.         }  
134.     }  
135.   
136.     /** 
137.      * 序列化对象 
138.      * @param js    json对象 
139.      * @param obj   待序列化对象 
140.      */  
141.     private static void serializeObject(JSONStringer js, Object obj) {  
142.         try {  
143.             js.object();  
144.             Class<? extends Object> objClazz = obj.getClass();  
145.             Method[] methods = objClazz.getDeclaredMethods();     
146.             Field[] fields = objClazz.getDeclaredFields();       
147.             for (Field field : fields) {     
148.                 try {     
149.                     String fieldType = field.getType().getSimpleName();     
150.                     String fieldGetName = parseMethodName(field.getName(),"get");     
151.                     if (!haveMethod(methods, fieldGetName)) {     
152.                         continue;     
153.                     }     
154.                     Method fieldGetMet = objClazz.getMethod(fieldGetName, new Class[] {});     
155.                     Object fieldVal = fieldGetMet.invoke(obj, new Object[] {});     
156.                     String result = null;     
157.                     if ("Date".equals(fieldType)) {     
158.                         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.US);     
159.                         result = sdf.format((Date)fieldVal);    
160.   
161.                     } else {     
162.                         if (null != fieldVal) {     
163.                             result = String.valueOf(fieldVal);     
164.                         }     
165.                     }     
166.                     js.key(field.getName());  
167.                     serialize(js, result);    
168.                 } catch (Exception e) {     
169.                     continue;     
170.                 }     
171.             }    
172.             js.endObject();  
173.         } catch (Exception e) {  
174.             e.printStackTrace();  
175.         }  
176.     }  
177.   
178.     /** 
179.      * 判断是否存在某属性的 get方法 
180.      * @param methods   引用方法的数组 
181.      * @param fieldMethod   方法名称 
182.      * @return true或者false 
183.      */  
184.     public static boolean haveMethod(Method[] methods, String fieldMethod) {  
185.         for (Method met : methods) {  
186.             if (fieldMethod.equals(met.getName())) {  
187.                 return true;  
188.             }  
189.         }  
190.         return false;  
191.     }  
192.   
193.     /** 
194.      * 拼接某属性的 get或者set方法 
195.      * @param fieldName 字段名称 
196.      * @param methodType    方法类型 
197.      * @return 方法名称 
198.      */  
199.     public static String parseMethodName(String fieldName,String methodType) {  
200.         if (null == fieldName || "".equals(fieldName)) {  
201.             return null;  
202.         }  
203.         return methodType + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);  
204.     }  
205.       
206.     /**   
207.      * 给字段赋值   
208.      * @param obj  实例对象 
209.      * @param valMap  值集合 
210.      */    
211.     public static void setFieldValue(Object obj, Map<String, String> valMap) {     
212.         Class<?> cls = obj.getClass();     
213.         // 取出bean里的所有方法     
214.         Method[] methods = cls.getDeclaredMethods();     
215.         Field[] fields = cls.getDeclaredFields();     
216.     
217.         for (Field field : fields) {     
218.             try {       
219.                 String setMetodName = parseMethodName(field.getName(),"set");     
220.                 if (!haveMethod(methods, setMetodName)) {     
221.                     continue;     
222.                 }     
223.                 Method fieldMethod = cls.getMethod(setMetodName, field     
224.                         .getType());     
225.                 String value = valMap.get(field.getName());     
226.                 if (null != value && !"".equals(value)) {     
227.                     String fieldType = field.getType().getSimpleName();     
228.                     if ("String".equals(fieldType)) {     
229.                         fieldMethod.invoke(obj, value);     
230.                     } else if ("Date".equals(fieldType)) {     
231.                         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.US);     
232.                         Date temp = sdf.parse(value);      
233.                         fieldMethod.invoke(obj, temp);     
234.                     } else if ("Integer".equals(fieldType)     
235.                             || "int".equals(fieldType)) {     
236.                         Integer intval = Integer.parseInt(value);     
237.                         fieldMethod.invoke(obj, intval);     
238.                     } else if ("Long".equalsIgnoreCase(fieldType)) {     
239.                         Long temp = Long.parseLong(value);     
240.                         fieldMethod.invoke(obj, temp);     
241.                     } else if ("Double".equalsIgnoreCase(fieldType)) {     
242.                         Double temp = Double.parseDouble(value);     
243.                         fieldMethod.invoke(obj, temp);     
244.                     } else if ("Boolean".equalsIgnoreCase(fieldType)) {     
245.                         Boolean temp = Boolean.parseBoolean(value);     
246.                         fieldMethod.invoke(obj, temp);     
247.                     } else {     
248.                         System.out.println("setFieldValue not supper type:" + fieldType);     
249.                     }     
250.                 }     
251.             } catch (Exception e) {     
252.                 continue;     
253.             }     
254.         }     
255.     
256.     }   
257.       
258.     /** 
259.      * bean对象转Map 
260.      * @param obj   实例对象 
261.      * @return  map集合 
262.      */  
263.     public static Map<String, String> beanToMap(Object obj) {     
264.         Class<?> cls = obj.getClass();     
265.         Map<String, String> valueMap = new HashMap<String, String>();     
266.         // 取出bean里的所有方法     
267.         Method[] methods = cls.getDeclaredMethods();     
268.         Field[] fields = cls.getDeclaredFields();       
269.         for (Field field : fields) {     
270.             try {     
271.                 String fieldType = field.getType().getSimpleName();     
272.                 String fieldGetName = parseMethodName(field.getName(),"get");     
273.                 if (!haveMethod(methods, fieldGetName)) {     
274.                     continue;     
275.                 }     
276.                 Method fieldGetMet = cls.getMethod(fieldGetName, new Class[] {});     
277.                 Object fieldVal = fieldGetMet.invoke(obj, new Object[] {});     
278.                 String result = null;     
279.                 if ("Date".equals(fieldType)) {     
280.                     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.CHINA);     
281.                     result = sdf.format((Date)fieldVal);     
282.   
283.                 } else {     
284.                     if (null != fieldVal) {     
285.                         result = String.valueOf(fieldVal);     
286.                     }     
287.                 }     
288.                 valueMap.put(field.getName(), result);     
289.             } catch (Exception e) {     
290.                 continue;     
291.             }     
292.         }     
293.         return valueMap;     
294.     
295.     }     
296.   
297.     /** 
298.      * 给对象的字段赋值 
299.      * @param obj   类实例 
300.      * @param fieldSetMethod    字段方法 
301.      * @param fieldType 字段类型 
302.      * @param value 
303.      */  
304.     public static void setFiedlValue(Object obj,Method fieldSetMethod,String fieldType,Object value){  
305.              
306.         try {      
307.             if (null != value && !"".equals(value)) {      
308.                 if ("String".equals(fieldType)) {     
309.                     fieldSetMethod.invoke(obj, value.toString());     
310.                 } else if ("Date".equals(fieldType)) {     
311.                     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.CHINA);     
312.                     Date temp = sdf.parse(value.toString());      
313.                     fieldSetMethod.invoke(obj, temp);     
314.                 } else if ("Integer".equals(fieldType)     
315.                         || "int".equals(fieldType)) {     
316.                     Integer intval = Integer.parseInt(value.toString());     
317.                     fieldSetMethod.invoke(obj, intval);     
318.                 } else if ("Long".equalsIgnoreCase(fieldType)) {     
319.                     Long temp = Long.parseLong(value.toString());     
320.                     fieldSetMethod.invoke(obj, temp);     
321.                 } else if ("Double".equalsIgnoreCase(fieldType)) {     
322.                     Double temp = Double.parseDouble(value.toString());     
323.                     fieldSetMethod.invoke(obj, temp);     
324.                 } else if ("Boolean".equalsIgnoreCase(fieldType)) {     
325.                     Boolean temp = Boolean.parseBoolean(value.toString());     
326.                     fieldSetMethod.invoke(obj, temp);     
327.                 } else {     
328.                     fieldSetMethod.invoke(obj, value);   
329.                     Log.e(TAG, TAG  + ">>>>setFiedlValue -> not supper type" + fieldType);     
330.                 }   
331.             }  
332.                   
333.         } catch (Exception e) {     
334. //            Log.e(TAG, TAG  + ">>>>>>>>>>set value error.",e);  
335.             e.printStackTrace();  
336.         }     
337.       
338.     }  
339.       
340.     /** 
341.      * 反序列化简单对象 
342.      * @param jo    json对象 
343.      * @param clazz 实体类类型 
344.      * @return  反序列化后的实例 
345.      * @throws JSONException  
346.      */  
347.     public static <T> T parseObject(JSONObject jo, Class<T> clazz) throws JSONException {  
348.         if (clazz == null || isNull(jo)) {  
349.             return null;  
350.         }  
351.   
352.         T obj = newInstance(clazz);  
353.         if (obj == null) {  
354.             return null;  
355.         }  
356.         if(isMap(clazz)){   
357.             setField(obj,jo);  
358.         }else{  
359.               // 取出bean里的所有方法     
360.             Method[] methods = clazz.getDeclaredMethods();     
361.             Field[] fields = clazz.getDeclaredFields();               
362.             for (Field f : fields) {  
363.                 String setMetodName = parseMethodName(f.getName(),"set");     
364.                 if (!haveMethod(methods, setMetodName)) {     
365.                     continue;     
366.                 }                   
367.                 try {  
368.                     Method fieldMethod = clazz.getMethod(setMetodName, f.getType());  
369.                     setField(obj,fieldMethod,f, jo);  
370.                 } catch (Exception e) {  
371.                     e.printStackTrace();  
372.                 }    
373.             }  
374.         }  
375.         return obj;  
376.     }  
377.       
378.     /** 
379.      * 反序列化简单对象 
380.      * @param jsonStr   json字符串 
381.      * @param clazz 实体类类型 
382.      * @return  反序列化后的实例 
383.      * @throws JSONException  
384.      */  
385.     public static <T> T parseObject(String jsonStr, Class<T> clazz) throws JSONException {  
386.         if (clazz == null || jsonStr == null || jsonStr.length() == 0) {  
387.             return null;  
388.         }  
389.           
390.         JSONObject jo = null;  
391.         jo = new JSONObject(jsonStr);  
392.         if (isNull(jo)) {  
393.             return null;  
394.         }  
395.   
396.         return parseObject(jo, clazz);  
397.     }  
398.   
399.     /** 
400.      * 反序列化数组对象 
401.      * @param ja    json数组 
402.      * @param clazz 实体类类型 
403.      * @return  反序列化后的数组 
404.      */  
405.     public static <T> T[] parseArray(JSONArray ja, Class<T> clazz) {  
406.         if (clazz == null || isNull(ja)) {  
407.             return null;  
408.         }  
409.   
410.         int len = ja.length();  
411.   
412.         @SuppressWarnings("unchecked")  
413.         T[] array = (T[]) Array.newInstance(clazz, len);  
414.   
415.         for (int i = 0; i < len; ++i) {  
416.             try {  
417.                 JSONObject jo = ja.getJSONObject(i);  
418.                 T o = parseObject(jo, clazz);  
419.                 array[i] = o;  
420.             } catch (JSONException e) {  
421.                 e.printStackTrace();  
422.             }  
423.         }  
424.   
425.         return array;  
426.     }  
427.   
428.       
429.     /** 
430.      * 反序列化数组对象 
431.      * @param jsonStr   json字符串 
432.      * @param clazz 实体类类型 
433.      * @return  序列化后的数组 
434.      */  
435.     public static <T> T[] parseArray(String jsonStr, Class<T> clazz) {  
436.         if (clazz == null || jsonStr == null || jsonStr.length() == 0) {  
437.             return null;  
438.         }  
439.         JSONArray jo = null;  
440.         try {  
441.             jo = new JSONArray(jsonStr);  
442.         } catch (JSONException e) {  
443.             e.printStackTrace();  
444.         }  
445.   
446.         if (isNull(jo)) {  
447.             return null;  
448.         }  
449.   
450.         return parseArray(jo, clazz);  
451.     }  
452.   
453.     /** 
454.      * 反序列化泛型集合 
455.      * @param ja    json数组 
456.      * @param collectionClazz   集合类型 
457.      * @param genericType   实体类类型 
458.      * @return 
459.      * @throws JSONException  
460.      */  
461.     @SuppressWarnings("unchecked")  
462.     public static <T> Collection<T> parseCollection(JSONArray ja, Class<?> collectionClazz,  
463.             Class<T> genericType) throws JSONException {  
464.   
465.         if (collectionClazz == null || genericType == null || isNull(ja)) {  
466.             return null;  
467.         }  
468.   
469.         Collection<T> collection = (Collection<T>) newInstance(collectionClazz);  
470.   
471.         for (int i = 0; i < ja.length(); ++i) {  
472.             try {  
473.                 JSONObject jo = ja.getJSONObject(i);  
474.                 T o = parseObject(jo, genericType);  
475.                 collection.add(o);  
476.             } catch (JSONException e) {  
477.                 e.printStackTrace();  
478.             }  
479.         }  
480.   
481.         return collection;  
482.     }  
483.   
484.     /** 
485.      * 反序列化泛型集合 
486.      * @param jsonStr   json字符串 
487.      * @param collectionClazz   集合类型 
488.      * @param genericType   实体类类型 
489.      * @return  反序列化后的数组 
490.      * @throws JSONException  
491.      */  
492.     public static <T> Collection<T> parseCollection(String jsonStr, Class<?> collectionClazz,  
493.             Class<T> genericType) throws JSONException {  
494.         if (collectionClazz == null || genericType == null || jsonStr == null  
495.                 || jsonStr.length() == 0) {  
496.             return null;  
497.         }  
498.         JSONArray jo = null;  
499.         try {  
500.             //如果为数组，则此处转化时，需要去掉前面的键，直接后面的[]中的值  
501.             int index = jsonStr.indexOf("[");  
502.             String arrayString=null;   
503.               
504.             //获取数组的字符串  
505.             if(-1!=index){  
506.                 arrayString = jsonStr.substring(index);  
507.             }  
508.               
509.             //如果为数组，使用数组转化  
510.             if(null!=arrayString){  
511.                 jo = new JSONArray(arrayString);  
512.             }  
513.             else{  
514.                 jo = new JSONArray(jsonStr);  
515.             }  
516.               
517.         } catch (JSONException e) {  
518.             e.printStackTrace();  
519.         }  
520.   
521.         if (isNull(jo)) {  
522.             return null;  
523.         }  
524.   
525.         return parseCollection(jo, collectionClazz, genericType);  
526.     }  
527.   
528.     /** 
529.      * 根据类型创建对象 
530.      * @param clazz 待创建实例的类型 
531.      * @return  实例对象 
532.      * @throws JSONException  
533.      */  
534.     @SuppressWarnings({ "unchecked", "rawtypes" })  
535.     private static <T> T newInstance(Class<T> clazz) throws JSONException {  
536.         if (clazz == null)  
537.             return null;  
538.         T obj = null;  
539.         if (clazz.isInterface()) {  
540.             if (clazz.equals(Map.class)) {  
541.                 obj = (T) new HashMap();  
542.             }else if (clazz.equals(List.class)) {  
543.                 obj = (T) new ArrayList();  
544.             }else if (clazz.equals(Set.class)) {  
545.                 obj = (T) new HashSet();  
546.             }else{  
547.                 throw new JSONException("unknown interface: " + clazz);  
548.             }  
549.         }else{  
550.             try {  
551.                 obj = clazz.newInstance();  
552.             }catch (Exception e) {  
553.                 throw new JSONException("unknown class type: " + clazz);  
554.             }  
555.         }     
556.         return obj;  
557.     }  
558.       
559.     /** 
560.      * 设定Map的值 
561.      * @param obj   待赋值字段的对象 
562.      * @param jo    json实例 
563.      */  
564.     private static void setField(Object obj, JSONObject jo) {  
565.         try {  
566.             @SuppressWarnings("unchecked")  
567.             Iterator<String> keyIter = jo.keys();  
568.             String key;  
569.             Object value;  
570.             @SuppressWarnings("unchecked")  
571.             Map<String, Object> valueMap = (Map<String, Object>) obj;  
572.             while (keyIter.hasNext()) {  
573.                 key = (String) keyIter.next();  
574.                 value = jo.get(key);                  
575.                 valueMap.put(key, value);  
576.   
577.             }  
578.         } catch (JSONException e) {  
579.             e.printStackTrace();  
580.         }  
581.     }     
582.       
583.     /** 
584.      * 设定字段的值 
585.      * @param obj   待赋值字段的对象 
586.      * @param fieldSetMethod    字段方法名 
587.      * @param field 字段 
588.      * @param jo    json实例 
589.      */  
590.     private static void setField(Object obj, Method fieldSetMethod,Field field, JSONObject jo) {  
591.         String name = field.getName();  
592.         Class<?> clazz = field.getType();       
593.         try {  
594.             if (isArray(clazz)) { // 数组  
595.                 Class<?> c = clazz.getComponentType();  
596.                 JSONArray ja = jo.optJSONArray(name);  
597.                 if (!isNull(ja)) {  
598.                     Object array = parseArray(ja, c);  
599.                     setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), array);  
600.                 }  
601.             } else if (isCollection(clazz)) { // 泛型集合  
602.                 // 获取定义的泛型类型  
603.                 Class<?> c = null;  
604.                 Type gType = field.getGenericType();  
605.                 if (gType instanceof ParameterizedType) {  
606.                     ParameterizedType ptype = (ParameterizedType) gType;  
607.                     Type[] targs = ptype.getActualTypeArguments();  
608.                     if (targs != null && targs.length > 0) {  
609.                         Type t = targs[0];  
610.                         c = (Class<?>) t;  
611.                     }  
612.                 }  
613.   
614.                 JSONArray ja = jo.optJSONArray(name);  
615.                 if (!isNull(ja)) {  
616.                     Object o = parseCollection(ja, clazz, c);  
617.                     setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);  
618.                 }  
619.             } else if (isSingle(clazz)) { // 值类型  
620.                 Object o = jo.opt(name);  
621.                 if (o != null) {  
622.                     setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);  
623.                 }  
624.             } else if (isObject(clazz)) { // 对象  
625.                 JSONObject j = jo.optJSONObject(name);  
626.                 if (!isNull(j)) {  
627.                     Object o = parseObject(j, clazz);  
628.                     setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);  
629.                 }  
630.             } else if (isList(clazz)) { // 列表  
631. //              JSONObject j = jo.optJSONObject(name);  
632. //              if (!isNull(j)) {  
633. //                  Object o = parseObject(j, clazz);  
634. //                  f.set(obj, o);  
635. //              }  
636.             } else {  
637.                 throw new Exception("unknow type!");  
638.             }  
639.         } catch (Exception e) {  
640.             e.printStackTrace();  
641.         }  
642.     }  
643.       
644.     /** 
645.      * 设定字段的值  
646.      * @param obj   待赋值字段的对象 
647.      * @param field 字段 
648.      * @param jo    json实例 
649.      */  
650.     @SuppressWarnings("unused")  
651.     private static void setField(Object obj, Field field, JSONObject jo) {  
652.         String name = field.getName();  
653.         Class<?> clazz = field.getType();  
654.         try {  
655.             if (isArray(clazz)) { // 数组  
656.                 Class<?> c = clazz.getComponentType();  
657.                 JSONArray ja = jo.optJSONArray(name);  
658.                 if (!isNull(ja)) {  
659.                     Object array = parseArray(ja, c);  
660.                     field.set(obj, array);  
661.                 }  
662.             } else if (isCollection(clazz)) { // 泛型集合  
663.                 // 获取定义的泛型类型  
664.                 Class<?> c = null;  
665.                 Type gType = field.getGenericType();  
666.                 if (gType instanceof ParameterizedType) {  
667.                     ParameterizedType ptype = (ParameterizedType) gType;  
668.                     Type[] targs = ptype.getActualTypeArguments();  
669.                     if (targs != null && targs.length > 0) {  
670.                         Type t = targs[0];  
671.                         c = (Class<?>) t;  
672.                     }  
673.                 }  
674.                 JSONArray ja = jo.optJSONArray(name);  
675.                 if (!isNull(ja)) {  
676.                     Object o = parseCollection(ja, clazz, c);  
677.                     field.set(obj, o);  
678.                 }  
679.             } else if (isSingle(clazz)) { // 值类型  
680.                 Object o = jo.opt(name);  
681.                 if (o != null) {  
682.                     field.set(obj, o);  
683.                 }  
684.             } else if (isObject(clazz)) { // 对象  
685.                 JSONObject j = jo.optJSONObject(name);  
686.                 if (!isNull(j)) {  
687.                     Object o = parseObject(j, clazz);  
688.                     field.set(obj, o);  
689.                 }  
690.             } else if (isList(clazz)) { // 列表  
691.                 JSONObject j = jo.optJSONObject(name);  
692.                 if (!isNull(j)) {  
693.                     Object o = parseObject(j, clazz);  
694.                     field.set(obj, o);  
695.                 }  
696.             }else {  
697.                 throw new Exception("unknow type!");  
698.             }  
699.         } catch (Exception e) {  
700.             e.printStackTrace();  
701.         }  
702.     }  
703.   
704.     /** 
705.      * 判断对象是否为空 
706.      * @param obj   实例 
707.      * @return 
708.      */  
709.     private static boolean isNull(Object obj) {  
710.         if (obj instanceof JSONObject) {  
711.             return JSONObject.NULL.equals(obj);  
712.         }  
713.         return obj == null;  
714.     }  
715.   
716.     /** 
717.      * 判断是否是值类型  
718.      * @param clazz  
719.      * @return 
720.      */  
721.     private static boolean isSingle(Class<?> clazz) {  
722.         return isBoolean(clazz) || isNumber(clazz) || isString(clazz);  
723.     }  
724.   
725.     /** 
726.      * 是否布尔值 
727.      * @param clazz  
728.      * @return 
729.      */  
730.     public static boolean isBoolean(Class<?> clazz) {  
731.         return (clazz != null)  
732.                 && ((Boolean.TYPE.isAssignableFrom(clazz)) || (Boolean.class  
733.                         .isAssignableFrom(clazz)));  
734.     }  
735.   
736.     /** 
737.      * 是否数值  
738.      * @param clazz  
739.      * @return 
740.      */  
741.     public static boolean isNumber(Class<?> clazz) {  
742.         return (clazz != null)  
743.                 && ((Byte.TYPE.isAssignableFrom(clazz)) || (Short.TYPE.isAssignableFrom(clazz))  
744.                         || (Integer.TYPE.isAssignableFrom(clazz))  
745.                         || (Long.TYPE.isAssignableFrom(clazz))  
746.                         || (Float.TYPE.isAssignableFrom(clazz))  
747.                         || (Double.TYPE.isAssignableFrom(clazz)) || (Number.class  
748.                         .isAssignableFrom(clazz)));  
749.     }  
750.   
751.     /** 
752.      * 判断是否是字符串  
753.      * @param clazz  
754.      * @return 
755.      */  
756.     public static boolean isString(Class<?> clazz) {  
757.         return (clazz != null)  
758.                 && ((String.class.isAssignableFrom(clazz))  
759.                         || (Character.TYPE.isAssignableFrom(clazz)) || (Character.class  
760.                         .isAssignableFrom(clazz)));  
761.     }  
762.   
763.     /** 
764.      * 判断是否是对象 
765.      * @param clazz  
766.      * @return 
767.      */  
768.     private static boolean isObject(Class<?> clazz) {  
769.         return clazz != null && !isSingle(clazz) && !isArray(clazz) && !isCollection(clazz) && !isMap(clazz);  
770.     }  
771.   
772.     /** 
773.      * 判断是否是数组  
774.      * @param clazz 
775.      * @return 
776.      */  
777.     public static boolean isArray(Class<?> clazz) {  
778.         return clazz != null && clazz.isArray();  
779.     }  
780.   
781.     /** 
782.      * 判断是否是集合 
783.      * @param clazz 
784.      * @return 
785.      */  
786.     public static boolean isCollection(Class<?> clazz) {  
787.         return clazz != null && Collection.class.isAssignableFrom(clazz);  
788.     }  
789.           
790.     /** 
791.      * 判断是否是Map 
792.      * @param clazz 
793.      * @return 
794.      */  
795.     public static boolean isMap(Class<?> clazz) {  
796.         return clazz != null && Map.class.isAssignableFrom(clazz);  
797.     }  
798.       
799.     /** 
800.      * 判断是否是列表  
801.      * @param clazz 
802.      * @return 
803.      */  
804.     public static boolean isList(Class<?> clazz) {  
805.         return clazz != null && List.class.isAssignableFrom(clazz);  
806.     }  
807.       
808. }  

ANDROID JSON解析工具类，不需要第三方包，支持集合，直接贴代码。

调用测试代码：

[java]  view plain copy

1. public class User{  
2.     private String name;  
3.     private String password;  
4.     public String getName() {  
5.         return name;  
6.     }  
7.     public void setName(String name) {  
8.         this.name = name;  
9.     }  
10.     public String getPassword() {  
11.         return password;  
12.     }  
13.     public void setPassword(String password) {  
14.         this.password = password;  
15.     }  
16.       
17. }  
18.   
19. void testObj(){  
20.     try {  
21.         User user = new User();  
22.         user.setName("abcd");  
23.         user.setPassword("123456");  
24.           
25.         User user1 = new User();  
26.         user.setName("abcdf");  
27.         user.setPassword("1234567");  
28.           
29.         String jsonStrUser = JSONHelper.toJSON(user);   //序列化  
30.         User jsonUser = JSONHelper.parseObject(jsonStrUser, User.class);    //反序列化        
31.         Map mapUser = JSONHelper.parseObject(jsonStrUser, HashMap.class);   //反序列化            
32.           
33.           
34.         List sourceList = new ArrayList<User>();  
35.         sourceList.add(user);  
36.         sourceList.add(user1);            
37.         String jsonStrUserList = JSONHelper.toJSON(sourceList);         //序列化  
38.         List listUser = (List) JSONHelper.parseCollection(jsonStrUserList, List.class, User.class); //反序列化  
39.     } catch (JSONException e) {  
40.         e.printStackTrace();  
41.     }  
42.       
43. }