JSON工具类

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

import net.sf.json.JSONArray;
import net.sf.json.JSONException;
import net.sf.json.JSONObject;
import net.sf.json.util.JSONStringer;

 

public class JSONHelper {  
    private static String TAG = "JSONHelper";  
  
    /** 
     * 将对象转换成Json字符串 
     * @param obj 
     * @return json类型字符串 
     */  
    public static String toJSON(Object obj) {  
        JSONStringer js = new JSONStringer();  
        serialize(js, obj);  
        return js.toString();  
    }  
  
    /** 
     * 序列化为JSON 
     * @param js json对象 
     * @param o 待需序列化的对象 
     */  
    private static void serialize(JSONStringer js, Object o) {  
        if (isNull(o)) {  
            try {  
                js.value(null);  
            } catch (JSONException e) {  
                e.printStackTrace();  
            }  
            return;  
        }  
  
        Class<?> clazz = o.getClass();  
        if (isObject(clazz)) { // 对象   
            serializeObject(js, o);  
        } else if (isArray(clazz)) { // 数组   
            serializeArray(js, o);  
        } else if (isCollection(clazz)) { // 集合   
            Collection<?> collection = (Collection<?>) o;  
            serializeCollect(js, collection);  
        }else if (isMap(clazz)) { // 集合   
            HashMap<?,?> collection = (HashMap<?,?>) o;  
            serializeMap(js, collection);  
        } else { // 单个值   
            try {  
                js.value(o);  
            } catch (JSONException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
  
    /** 
     * 序列化数组  
     * @param js    json对象 
     * @param array 数组 
     */  
    private static void serializeArray(JSONStringer js, Object array) {  
        try {  
            js.array();  
            for (int i = 0; i < Array.getLength(array); ++i) {  
                Object o = Array.get(array, i);  
                serialize(js, o);  
            }  
            js.endArray();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
    /** 
     * 序列化集合 
     * @param js    json对象 
     * @param collection    集合 
     */  
    private static void serializeCollect(JSONStringer js, Collection<?> collection) {  
        try {  
            js.array();  
            for (Object o : collection) {  
                serialize(js, o);  
            }  
            js.endArray();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
      
    /** 
     * 序列化Map 
     * @param js    json对象 
     * @param map   map对象 
     */  
    private static void serializeMap(JSONStringer js, Map<?,?> map) {  
        try {  
            js.object();  
            @SuppressWarnings("unchecked")  
            Map<String, Object> valueMap = (Map<String, Object>) map;  
            Iterator<Map.Entry<String, Object>> it = valueMap.entrySet().iterator();  
            while (it.hasNext()) {  
                Map.Entry<String, Object> entry = (Map.Entry<String, Object>)it.next();  
                js.key(entry.getKey());  
                serialize(js,entry.getValue());  
            }  
            js.endObject();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
    /** 
     * 序列化对象 
     * @param js    json对象 
     * @param obj   待序列化对象 
     */  
    private static void serializeObject(JSONStringer js, Object obj) {  
        try {  
            js.object();  
            Class<? extends Object> objClazz = obj.getClass();  
            Method[] methods = objClazz.getDeclaredMethods();     
            Field[] fields = objClazz.getDeclaredFields();       
            for (Field field : fields) {     
                try {     
                    String fieldType = field.getType().getSimpleName();     
                    String fieldGetName = parseMethodName(field.getName(),"get");     
                    if (!haveMethod(methods, fieldGetName)) {     
                        continue;     
                    }     
                    Method fieldGetMet = objClazz.getMethod(fieldGetName, new Class[] {});     
                    Object fieldVal = fieldGetMet.invoke(obj, new Object[] {});     
                    String result = null;     
                    if ("Date".equals(fieldType)) {     
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.US);     
                        result = sdf.format((Date)fieldVal);    
  
                    } else {     
                        if (null != fieldVal) {     
                            result = String.valueOf(fieldVal);     
                        }     
                    }     
                    js.key(field.getName());  
                    serialize(js, result);    
                } catch (Exception e) {     
                    continue;     
                }     
            }    
            js.endObject();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
    /** 
     * 判断是否存在某属性的 get方法 
     * @param methods   引用方法的数组 
     * @param fieldMethod   方法名称 
     * @return true或者false 
     */  
    public static boolean haveMethod(Method[] methods, String fieldMethod) {  
        for (Method met : methods) {  
            if (fieldMethod.equals(met.getName())) {  
                return true;  
            }  
        }  
        return false;  
    }  
  
    /** 
     * 拼接某属性的 get或者set方法 
     * @param fieldName 字段名称 
     * @param methodType    方法类型 
     * @return 方法名称 
     */  
    public static String parseMethodName(String fieldName,String methodType) {  
        if (null == fieldName || "".equals(fieldName)) {  
            return null;  
        }  
        return methodType + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);  
    }  
      
    /**   
     * 给字段赋值   
     * @param obj  实例对象 
     * @param valMap  值集合 
     */    
    public static void setFieldValue(Object obj, Map<String, String> valMap) {     
        Class<?> cls = obj.getClass();     
        // 取出bean里的所有方法      
        Method[] methods = cls.getDeclaredMethods();     
        Field[] fields = cls.getDeclaredFields();     
    
        for (Field field : fields) {     
            try {       
                String setMetodName = parseMethodName(field.getName(),"set");     
                if (!haveMethod(methods, setMetodName)) {     
                    continue;     
                }     
                Method fieldMethod = cls.getMethod(setMetodName, field     
                        .getType());     
                String value = valMap.get(field.getName());     
                if (null != value && !"".equals(value)) {     
                    String fieldType = field.getType().getSimpleName();     
                    if ("String".equals(fieldType)) {     
                        fieldMethod.invoke(obj, value);     
                    } else if ("Date".equals(fieldType)) {     
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.US);     
                        Date temp = sdf.parse(value);      
                        fieldMethod.invoke(obj, temp);     
                    } else if ("Integer".equals(fieldType)     
                            || "int".equals(fieldType)) {     
                        Integer intval = Integer.parseInt(value);     
                        fieldMethod.invoke(obj, intval);     
                    } else if ("Long".equalsIgnoreCase(fieldType)) {     
                        Long temp = Long.parseLong(value);     
                        fieldMethod.invoke(obj, temp);     
                    } else if ("Double".equalsIgnoreCase(fieldType)) {     
                        Double temp = Double.parseDouble(value);     
                        fieldMethod.invoke(obj, temp);     
                    } else if ("Boolean".equalsIgnoreCase(fieldType)) {     
                        Boolean temp = Boolean.parseBoolean(value);     
                        fieldMethod.invoke(obj, temp);     
                    } else {     
                        System.out.println("setFieldValue not supper type:" + fieldType);     
                    }     
                }     
            } catch (Exception e) {     
                continue;     
            }     
        }     
    
    }   
      
    /** 
     * bean对象转Map 
     * @param obj   实例对象 
     * @return  map集合 
     */  
    public static Map<String, String> beanToMap(Object obj) {     
        Class<?> cls = obj.getClass();     
        Map<String, String> valueMap = new HashMap<String, String>();     
        // 取出bean里的所有方法      
        Method[] methods = cls.getDeclaredMethods();     
        Field[] fields = cls.getDeclaredFields();       
        for (Field field : fields) {     
            try {     
                String fieldType = field.getType().getSimpleName();     
                String fieldGetName = parseMethodName(field.getName(),"get");     
                if (!haveMethod(methods, fieldGetName)) {     
                    continue;     
                }     
                Method fieldGetMet = cls.getMethod(fieldGetName, new Class[] {});     
                Object fieldVal = fieldGetMet.invoke(obj, new Object[] {});     
                String result = null;     
                if ("Date".equals(fieldType)) {     
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.CHINA);     
                    result = sdf.format((Date)fieldVal);     
  
                } else {     
                    if (null != fieldVal) {     
                        result = String.valueOf(fieldVal);     
                    }     
                }     
                valueMap.put(field.getName(), result);     
            } catch (Exception e) {     
                continue;     
            }     
        }     
        return valueMap;     
    
    }     
  
    /** 
     * 给对象的字段赋值 
     * @param obj   类实例 
     * @param fieldSetMethod    字段方法 
     * @param fieldType 字段类型 
     * @param value 
     */  
    public static void setFiedlValue(Object obj,Method fieldSetMethod,String fieldType,Object value){  
             
        try {      
            if (null != value && !"".equals(value)) {      
                if ("String".equals(fieldType)) {     
                    fieldSetMethod.invoke(obj, value.toString());     
                } else if ("Date".equals(fieldType)) {     
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.CHINA);     
                    Date temp = sdf.parse(value.toString());      
                    fieldSetMethod.invoke(obj, temp);     
                } else if ("Integer".equals(fieldType)     
                        || "int".equals(fieldType)) {     
                    Integer intval = Integer.parseInt(value.toString());     
                    fieldSetMethod.invoke(obj, intval);     
                } else if ("Long".equalsIgnoreCase(fieldType)) {     
                    Long temp = Long.parseLong(value.toString());     
                    fieldSetMethod.invoke(obj, temp);     
                } else if ("Double".equalsIgnoreCase(fieldType)) {     
                    Double temp = Double.parseDouble(value.toString());     
                    fieldSetMethod.invoke(obj, temp);     
                } else if ("Boolean".equalsIgnoreCase(fieldType)) {     
                    Boolean temp = Boolean.parseBoolean(value.toString());     
                    fieldSetMethod.invoke(obj, temp);     
                } else {     
                    fieldSetMethod.invoke(obj, value);   
                }   
            }  
                  
        } catch (Exception e) {     
//            Log.e(TAG, TAG  + ">>>>>>>>>>set value error.",e);   
            e.printStackTrace();  
        }     
      
    }  
      
    /** 
     * 反序列化简单对象 
     * @param jo    json对象 
     * @param clazz 实体类类型 
     * @return  反序列化后的实例 
     * @throws JSONException  
     */  
    public static <T> T parseObject(JSONObject jo, Class<T> clazz) throws JSONException {  
        if (clazz == null || isNull(jo)) {  
            return null;  
        }  
  
        T obj = newInstance(clazz);  
        if (obj == null) {  
            return null;  
        }  
        if(isMap(clazz)){   
            setField(obj,jo);  
        }else{  
              // 取出bean里的所有方法      
            Method[] methods = clazz.getDeclaredMethods();     
            Field[] fields = clazz.getDeclaredFields();               
            for (Field f : fields) {  
                String setMetodName = parseMethodName(f.getName(),"set");     
                if (!haveMethod(methods, setMetodName)) {     
                    continue;     
                }                   
                try {  
                    Method fieldMethod = clazz.getMethod(setMetodName, f.getType());  
                    setField(obj,fieldMethod,f, jo);  
                } catch (Exception e) {  
                    e.printStackTrace();  
                }    
            }  
        }  
        return obj;  
    }  
      
    /** 
     * 反序列化简单对象 
     * @param jsonStr   json字符串 
     * @param clazz 实体类类型 
     * @return  反序列化后的实例 
     * @throws JSONException  
     */  
    public static <T> T parseObject(String jsonStr, Class<T> clazz) throws JSONException {  
        if (clazz == null || jsonStr == null || jsonStr.length() == 0) {  
            return null;  
        }  
          
        JSONObject jo = null;  
        jo = new JSONObject(jsonStr);  
        if (isNull(jo)) {  
            return null;  
        }  
  
        return parseObject(jo, clazz);  
    }  
  
    /** 
     * 反序列化数组对象 
     * @param ja    json数组 
     * @param clazz 实体类类型 
     * @return  反序列化后的数组 
     */  
    public static <T> T[] parseArray(JSONArray ja, Class<T> clazz) {  
        if (clazz == null || isNull(ja)) {  
            return null;  
        }  
  
        int len = ja.length();  
  
        @SuppressWarnings("unchecked")  
        T[] array = (T[]) Array.newInstance(clazz, len);  
  
        for (int i = 0; i < len; ++i) {  
            try {  
                JSONObject jo = ja.getJSONObject(i);  
                T o = parseObject(jo, clazz);  
                array[i] = o;  
            } catch (JSONException e) {  
                e.printStackTrace();  
            }  
        }  
  
        return array;  
    }  
  
      
    /** 
     * 反序列化数组对象 
     * @param jsonStr   json字符串 
     * @param clazz 实体类类型 
     * @return  序列化后的数组 
     */  
    public static <T> T[] parseArray(String jsonStr, Class<T> clazz) {  
        if (clazz == null || jsonStr == null || jsonStr.length() == 0) {  
            return null;  
        }  
        JSONArray jo = null;  
        try {  
            jo = new JSONArray(jsonStr);  
        } catch (JSONException e) {  
            e.printStackTrace();  
        }  
  
        if (isNull(jo)) {  
            return null;  
        }  
  
        return parseArray(jo, clazz);  
    }  
  
    /** 
     * 反序列化泛型集合 
     * @param ja    json数组 
     * @param collectionClazz   集合类型 
     * @param genericType   实体类类型 
     * @return 
     * @throws JSONException  
     */  
    @SuppressWarnings("unchecked")  
    public static <T> Collection<T> parseCollection(JSONArray ja, Class<?> collectionClazz,  
            Class<T> genericType) throws JSONException {  
  
        if (collectionClazz == null || genericType == null || isNull(ja)) {  
            return null;  
        }  
  
        Collection<T> collection = (Collection<T>) newInstance(collectionClazz);  
  
        for (int i = 0; i < ja.length(); ++i) {  
            try {  
                JSONObject jo = ja.getJSONObject(i);  
                T o = parseObject(jo, genericType);  
                collection.add(o);  
            } catch (JSONException e) {  
                e.printStackTrace();  
            }  
        }  
  
        return collection;  
    }  
  
    /** 
     * 反序列化泛型集合 
     * @param jsonStr   json字符串 
     * @param collectionClazz   集合类型 
     * @param genericType   实体类类型 
     * @return  反序列化后的数组 
     * @throws JSONException  
     */  
    public static <T> Collection<T> parseCollection(String jsonStr, Class<?> collectionClazz,  
            Class<T> genericType) throws JSONException {  
        if (collectionClazz == null || genericType == null || jsonStr == null  
                || jsonStr.length() == 0) {  
            return null;  
        }  
        JSONArray jo = null;  
        try {  
            //如果为数组，则此处转化时，需要去掉前面的键，直接后面的[]中的值   
            int index = jsonStr.indexOf("[");  
            String arrayString=null;   
              
            //获取数组的字符串   
            if(-1!=index){  
                arrayString = jsonStr.substring(index);  
            }  
              
            //如果为数组，使用数组转化   
            if(null!=arrayString){  
                jo = new JSONArray(arrayString);  
            }  
            else{  
                jo = new JSONArray(jsonStr);  
            }  
              
        } catch (JSONException e) {  
            e.printStackTrace();  
        }  
  
        if (isNull(jo)) {  
            return null;  
        }  
  
        return parseCollection(jo, collectionClazz, genericType);  
    }  
  
    /** 
     * 根据类型创建对象 
     * @param clazz 待创建实例的类型 
     * @return  实例对象 
     * @throws JSONException  
     */  
    @SuppressWarnings({ "unchecked", "rawtypes" })  
    private static <T> T newInstance(Class<T> clazz) throws JSONException {  
        if (clazz == null)  
            return null;  
        T obj = null;  
        if (clazz.isInterface()) {  
            if (clazz.equals(Map.class)) {  
                obj = (T) new HashMap();  
            }else if (clazz.equals(List.class)) {  
                obj = (T) new ArrayList();  
            }else if (clazz.equals(Set.class)) {  
                obj = (T) new HashSet();  
            }else{  
                throw new JSONException("unknown interface: " + clazz);  
            }  
        }else{  
            try {  
                obj = clazz.newInstance();  
            }catch (Exception e) {  
                throw new JSONException("unknown class type: " + clazz);  
            }  
        }     
        return obj;  
    }  
      
    /** 
     * 设定Map的值 
     * @param obj   待赋值字段的对象 
     * @param jo    json实例 
     */   
    private static void setField(Object obj, JSONObject jo) {  
        try {  
            @SuppressWarnings("unchecked")  
            Iterator<String> keyIter = jo.keys();  
            String key;  
            Object value;  
            @SuppressWarnings("unchecked")  
            Map<String, Object> valueMap = (Map<String, Object>) obj;  
            while (keyIter.hasNext()) {  
                key = (String) keyIter.next();  
                value = jo.get(key);                  
                valueMap.put(key, value);  
  
            }  
        } catch (JSONException e) {  
            e.printStackTrace();  
        }  
    }     
      
    /** 
     * 设定字段的值 
     * @param obj   待赋值字段的对象 
     * @param fieldSetMethod    字段方法名 
     * @param field 字段 
     * @param jo    json实例 
     */  
    private static void setField(Object obj, Method fieldSetMethod,Field field, JSONObject jo) {  
        String name = field.getName();  
        Class<?> clazz = field.getType();       
        try {  
            if (isArray(clazz)) { // 数组   
                Class<?> c = clazz.getComponentType();  
                JSONArray ja = jo.optJSONArray(name);  
                if (!isNull(ja)) {  
                    Object array = parseArray(ja, c);  
                    setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), array);  
                }  
            } else if (isCollection(clazz)) { // 泛型集合   
                // 获取定义的泛型类型   
                Class<?> c = null;  
                Type gType = field.getGenericType();  
                if (gType instanceof ParameterizedType) {  
                    ParameterizedType ptype = (ParameterizedType) gType;  
                    Type[] targs = ptype.getActualTypeArguments();  
                    if (targs != null && targs.length > 0) {  
                        Type t = targs[0];  
                        c = (Class<?>) t;  
                    }  
                }  
  
                JSONArray ja = jo.optJSONArray(name);  
                if (!isNull(ja)) {  
                    Object o = parseCollection(ja, clazz, c);  
                    setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);  
                }  
            } else if (isSingle(clazz)) { // 值类型   
                Object o = jo.opt(name);  
                if (o != null) {  
                    setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);  
                }  
            } else if (isObject(clazz)) { // 对象   
                JSONObject j = jo.optJSONObject(name);  
                if (!isNull(j)) {  
                    Object o = parseObject(j, clazz);  
                    setFiedlValue(obj, fieldSetMethod, clazz.getSimpleName(), o);  
                }  
            } else if (isList(clazz)) { // 列表   
//              JSONObject j = jo.optJSONObject(name);   
//              if (!isNull(j)) {   
//                  Object o = parseObject(j, clazz);   
//                  f.set(obj, o);   
//              }   
            } else {  
                throw new Exception("unknow type!");  
            }  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
      
    /** 
     * 设定字段的值  
     * @param obj   待赋值字段的对象 
     * @param field 字段 
     * @param jo    json实例 
     */  
    @SuppressWarnings("unused")  
    private static void setField(Object obj, Field field, JSONObject jo) {  
        String name = field.getName();  
        Class<?> clazz = field.getType();  
        try {  
            if (isArray(clazz)) { // 数组   
                Class<?> c = clazz.getComponentType();  
                JSONArray ja = jo.optJSONArray(name);  
                if (!isNull(ja)) {  
                    Object array = parseArray(ja, c);  
                    field.set(obj, array);  
                }  
            } else if (isCollection(clazz)) { // 泛型集合   
                // 获取定义的泛型类型   
                Class<?> c = null;  
                Type gType = field.getGenericType();  
                if (gType instanceof ParameterizedType) {  
                    ParameterizedType ptype = (ParameterizedType) gType;  
                    Type[] targs = ptype.getActualTypeArguments();  
                    if (targs != null && targs.length > 0) {  
                        Type t = targs[0];  
                        c = (Class<?>) t;  
                    }  
                }  
                JSONArray ja = jo.optJSONArray(name);  
                if (!isNull(ja)) {  
                    Object o = parseCollection(ja, clazz, c);  
                    field.set(obj, o);  
                }  
            } else if (isSingle(clazz)) { // 值类型   
                Object o = jo.opt(name);  
                if (o != null) {  
                    field.set(obj, o);  
                }  
            } else if (isObject(clazz)) { // 对象   
                JSONObject j = jo.optJSONObject(name);  
                if (!isNull(j)) {  
                    Object o = parseObject(j, clazz);  
                    field.set(obj, o);  
                }  
            } else if (isList(clazz)) { // 列表   
                JSONObject j = jo.optJSONObject(name);  
                if (!isNull(j)) {  
                    Object o = parseObject(j, clazz);  
                    field.set(obj, o);  
                }  
            }else {  
                throw new Exception("unknow type!");  
            }  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
    /** 
     * 判断对象是否为空 
     * @param obj   实例 
     * @return 
     */  
    private static boolean isNull(Object obj) {  
//        if (obj instanceof JSONObject) {  
//            return JSONObject.NULL.equals(obj);  
//        }  
        return obj == null;  
    }  
  
    /** 
     * 判断是否是值类型  
     * @param clazz  
     * @return 
     */  
    private static boolean isSingle(Class<?> clazz) {  
        return isBoolean(clazz) || isNumber(clazz) || isString(clazz);  
    }  
  
    /** 
     * 是否布尔值 
     * @param clazz  
     * @return 
     */  
    public static boolean isBoolean(Class<?> clazz) {  
        return (clazz != null)  
                && ((Boolean.TYPE.isAssignableFrom(clazz)) || (Boolean.class  
                        .isAssignableFrom(clazz)));  
    }  
  
    /** 
     * 是否数值  
     * @param clazz  
     * @return 
     */  
    public static boolean isNumber(Class<?> clazz) {  
        return (clazz != null)  
                && ((Byte.TYPE.isAssignableFrom(clazz)) || (Short.TYPE.isAssignableFrom(clazz))  
                        || (Integer.TYPE.isAssignableFrom(clazz))  
                        || (Long.TYPE.isAssignableFrom(clazz))  
                        || (Float.TYPE.isAssignableFrom(clazz))  
                        || (Double.TYPE.isAssignableFrom(clazz)) || (Number.class  
                        .isAssignableFrom(clazz)));  
    }  
  
    /** 
     * 判断是否是字符串  
     * @param clazz  
     * @return 
     */  
    public static boolean isString(Class<?> clazz) {  
        return (clazz != null)  
                && ((String.class.isAssignableFrom(clazz))  
                        || (Character.TYPE.isAssignableFrom(clazz)) || (Character.class  
                        .isAssignableFrom(clazz)));  
    }  
  
    /** 
     * 判断是否是对象 
     * @param clazz  
     * @return 
     */  
    private static boolean isObject(Class<?> clazz) {  
        return clazz != null && !isSingle(clazz) && !isArray(clazz) && !isCollection(clazz) && !isMap(clazz);  
    }  
  
    /** 
     * 判断是否是数组  
     * @param clazz 
     * @return 
     */  
    public static boolean isArray(Class<?> clazz) {  
        return clazz != null && clazz.isArray();  
    }  
  
    /** 
     * 判断是否是集合 
     * @param clazz 
     * @return 
     */  
    public static boolean isCollection(Class<?> clazz) {  
        return clazz != null && Collection.class.isAssignableFrom(clazz);  
    }  
          
    /** 
     * 判断是否是Map 
     * @param clazz 
     * @return 
     */  
    public static boolean isMap(Class<?> clazz) {  
        return clazz != null && Map.class.isAssignableFrom(clazz);  
    }  
      
    /** 
     * 判断是否是列表  
     * @param clazz 
     * @return 
     */  
    public static boolean isList(Class<?> clazz) {  
        return clazz != null && List.class.isAssignableFrom(clazz);  
    }  
      
}