Java-JSON

 

        <!-- fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>

        <!-- gson -->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.2</version>
        </dependency>

fastJson

import static com.alibaba.fastjson.util.TypeUtils.castToBoolean;

import java.io.Serializable;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.RandomAccess;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.ParserConfig;
import com.alibaba.fastjson.util.TypeUtils;

/**
 * JSONArray源码
 */
public class JSONArray1 extends JSON implements List<Object>, Cloneable, RandomAccess, Serializable {

    private final List<Object> list;
    protected transient Object relatedArray;
    protected transient Type   componentType;
    //使用无参构造创建JSONArray的时候，初始化一个空arrayList
    public JSONArray1(){
        this.list = new ArrayList<Object>();
    }
    //使用有参构造，将参数list赋值给JSONArray的属性list
    public JSONArray1(List<Object> list){
        this.list = list;
    }
    //使用无参构造，创建指定参数大小的list
    public JSONArray1(int initialCapacity){
        this.list = new ArrayList<Object>(initialCapacity);
    }

    //set和get方法
    public Object getRelatedArray() {return relatedArray;}
    public void setRelatedArray(Object relatedArray){this.relatedArray = relatedArray;}
    public Type getComponentType() {return componentType;}
    public void setComponentType(Type componentType){this.componentType = componentType;}

    //获取存储数据的list的大小
    public int size() {
        return list.size();
    }
    //判断存储数据的list是否为空
    public boolean isEmpty() {
        return list.isEmpty();
    }
    //判断存储数据的list是否包含某个对象
    public boolean contains(Object o) {
        return list.contains(o);
    }
    //获取存储数据的list的迭代器对象
    public Iterator<Object> iterator() {
        return list.iterator();
    }
    //将存储数据的list转成数组
    public Object[] toArray() {
        return list.toArray();
    }
    //将参数中的数据，添加list中，并将list转成参数中数组的类型的数组返回
    public <T> T[] toArray(T[] a) {
        return list.toArray(a);
    }
    //向存储数据的list中添加元素，添加成功返回true
    public boolean add(Object e) {
        return list.add(e);
    }
    //向存储数据的list中添加元素，返回该JSONArray对象
    public JSONArray1 fluentAdd(Object e) {
        list.add(e);
        return this;
    }
    //从存储数据的list中移除指定元素，移除成功返回true
    public boolean remove(Object o) {
        return list.remove(o);
    }
    //从存储数据的list中移除指定元素，返回该JSONArray对象
    public JSONArray1 fluentRemove(Object o) {
        list.remove(o);
        return this;
    }
    //判断list中是否包含指定集合中的所有元素
    public boolean containsAll(Collection<?> c) {
        return list.containsAll(c);
    }
    //添加指定集合中的所有元素到list中，添加成功返回true
    public boolean addAll(Collection<? extends Object> c) {
        return list.addAll(c);
    }
    //添加指定集合中的所有元素到list中,返回该JSONArray对象
    public JSONArray1 fluentAddAll(Collection<? extends Object> c) {
        list.addAll(c);
        return this;
    }
    //添加指定集合中的所有元素到list中指定下标处,添加成功返回true
    public boolean addAll(int index, Collection<? extends Object> c) {
        return list.addAll(index, c);
    }
    //添加指定集合中的所有元素到list中指定下标处,返回该JSONArray对象
    public JSONArray1 fluentAddAll(int index, Collection<? extends Object> c) {
        list.addAll(index, c);
        return this;
    }
    //从list中删除指定集合中的所有元素，删除成功返回true
    public boolean removeAll(Collection<?> c) {
        return list.removeAll(c);
    }
    //从list中删除指定集合中的所有元素，返回该JSONArray对象
    public JSONArray1 fluentRemoveAll(Collection<?> c) {
        list.removeAll(c);
        return this;
    }
    
    public boolean retainAll(Collection<?> c) {
        return list.retainAll(c);
    }

    public JSONArray1 fluentRetainAll(Collection<?> c) {
        list.retainAll(c);
        return this;
    }
    //清空list集合
    public void clear() {
        list.clear();
    }
    //清空list并返回JSONArray对象
    public JSONArray1 fluentClear() {
        list.clear();
        return this;
    }
    //添加元素到List的指定下标处
    public Object set(int index, Object element) {
        if (index == -1) {
            list.add(element);
            return null;
        }
        
        if (list.size() <= index) {
            for (int i = list.size(); i < index; ++i) {
                list.add(null);
            }
            list.add(element);
            return null;
        }
        
        return list.set(index, element);
    }
    //添加元素到指定下标处，返回JSONArray对象
    public JSONArray1 fluentSet(int index, Object element) {
        set(index, element);
        return this;
    }
    //添加元素到指定下标
    public void add(int index, Object element) {
        list.add(index, element);
    }
    //添加元素到指定下标处，返回JSONArray对象
    public JSONArray1 fluentAdd(int index, Object element) {
        list.add(index, element);
        return this;
    }
    //删除并返回指定下标处的元素
    public Object remove(int index) {
        return list.remove(index);
    }
    //删除指定下标处的元素，返回JSONArray对象
    public JSONArray1 fluentRemove(int index) {
        list.remove(index);
        return this;
    }
    //获取元素第一次出现的下标
    public int indexOf(Object o) {
        return list.indexOf(o);
    }
    //获取元素最后一次出现的下标
    public int lastIndexOf(Object o) {
        return list.lastIndexOf(o);
    }
    //获取list特有的迭代器对象
    public ListIterator<Object> listIterator() {
        return list.listIterator();
    }
    //根据下标获取list特有的迭代器对象
    public ListIterator<Object> listIterator(int index) {
        return list.listIterator(index);
    }
    //截取List
    public List<Object> subList(int fromIndex, int toIndex) {
        return list.subList(fromIndex, toIndex);
    }
    //根据下标获取元素
    public Object get(int index) {
        return list.get(index);
    }
    //根据下标获取元素，并转成JSONObject对象返回
    public JSONObject getJSONObject(int index) {
        Object value = list.get(index);

        if (value instanceof JSONObject) {
            return (JSONObject) value;
        }

        return (JSONObject) toJSON(value);
    }
    //根据下标获取元素，并转成JSONArray对象返回
    public JSONArray1 getJSONArray(int index) {
        Object value = list.get(index);

        if (value instanceof JSONArray1) {
            return (JSONArray1) value;
        }

        return (JSONArray1) toJSON(value);
    }
    //根据下标获取对象并装成指定的对象类型
    public <T> T getObject(int index, Class<T> clazz) {
        Object obj = list.get(index);
        return TypeUtils.castToJavaBean(obj, clazz);
    }
    //根据下标获取元素，并转成Boolean
    public Boolean getBoolean(int index) {
        Object value = get(index);
        if (value == null) {
            return null;
        }
        return castToBoolean(value);
    }
    //根据下标获取元素，并转成Boolean
    public boolean getBooleanValue(int index) {
        Object value = get(index);
        if (value == null) {
            return false;
        }
        return castToBoolean(value).booleanValue();
    }
    /**
     * 根据下标获取对应类型的数据
     * getByte、getByteValue、getShort、getShortValue、getInteger、getIntValue
     * getLong、getLongValue、getFloat、getFloatValue、getDouble、getDoubleValue
     * getBigDecimal、getBigInteger、getString、getDate、getSqlDate、getTimestamp
     */
    //转成指定类型的ArrayList对象
    public <T> List<T> toJavaList(Class<T> clazz) {
        List<T> list = new ArrayList<T>(this.size());

        ParserConfig config = ParserConfig.getGlobalInstance();

        for (Object item : this) {
            T classItem = (T) TypeUtils.cast(item, clazz, config);
            list.add(classItem);
        }

        return list;
    }
    //复制
    @Override
    public Object clone() {
        return new JSONArray1(new ArrayList<Object>(list));
    }
    public boolean equals(Object obj) {
        return this.list.equals(obj);
    }
    public int hashCode() {
        return this.list.hashCode();
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

/**
 * fastjson常用方法介绍
 */
public class TestJSON {
    public static void main(String[] args) {
        //json字符串
        String jsonStr = "{'name':'zhangsan','age':'10'}";
        String jsonStr2 = "{'name':'zhangsan','age':'11'}";
        //将json字符串解析成JSONObject
        JSONObject jsonObj = JSON.parseObject(jsonStr);
        JSONObject jsonObj2 = JSON.parseObject(jsonStr2);
        jsonObj.toJSONString();//转成Json字符串
        jsonObj.isEmpty();//判断是否非空
        jsonObj.containsKey("name");//是否包含指定key
        jsonObj.containsValue("zhangsan");//是否包含指定value
        jsonObj.equals(jsonObj2);//判断两个JSONObject是否相等
        jsonObj.get("name");//使用map中的取值方法获取value
        jsonObj.getString("name");//获取指定key对应的value
        jsonObj.size();//获取长度
        jsonObj.put("core", "a");//添加元素
        jsonObj.remove("name");//删除指定key
        jsonObj.clear();//清空
        Map<String, Object> map = new HashMap<String, Object>();
        jsonObj.putAll(map);//将指定map中的元素添加到JSONObject中
        
        jsonObj.keySet();//获取所有的key
        jsonObj.values();//获取所有的value
        
        Set<Entry<String, Object>> entrySet = jsonObj.entrySet();//获取所有键值对entry
        //遍历
        for (Entry<String, Object> entry : entrySet) {
            String key = entry.getKey();//获取key
            String value = (String) entry.getValue();//获取value
            entry.setValue("呵呵");//修改value值
        }
        
        
        //json字符串转JSONArray
        String str1 = "[{'name':'zhangsan','age':'10'},{'name':'lisi','age':'20'}]";
        String str2 = "[{'name':'zhang','age':'15'},{'name':'wangwu','age':'22'}]";
        JSONArray jsonArray = JSON.parseArray(str1);
        
        String jsonString = jsonArray.toJSONString();//转成json字符串
        
        //遍历这个jsonArray
        for (int i = 0; i < jsonArray.size(); i++) {
            //获取jsonArray中的每一个元素,元素可以为JSONObject、JSONArray
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            //然后通过map中的方法entrySet()方法获取键值对
            Set<Entry<String, Object>> entrySet2 = jsonObject.entrySet();
            for (Entry<String, Object> entry : entrySet2) {
                //然后对entrySet2遍历
                String key = entry.getKey();
                Object value = entry.getValue();
            }
        }
    }
}

GSON

/**
 * 实体类
 */
public class Student {
    private String name;
    private Integer age;
    
    public Student() {
    }
    public Student(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
}

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Iterator;

import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonIOException;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.JsonSyntaxException;
/**
 * 读取json文件
 * JsonObject  就是key和value
 * JsonElement  就是一个个value  但是对应的value也有很多可能性，例如可以是一个数组，可以是一个json对象
 */
public class JsonAnalysis {
    public static void main(String[] args) {
        //1.创建一个json解析器
        JsonParser parser = new JsonParser();
        try {
            /**
             * JsonParser对象中有三个方法：
             *     parse(JsonReader json)
             *     parse(Reader json)
             *     parse(String json) 将指定的JSON字符串解析为解析树
             */
                //2.将流中的json字符串解析并强转成json对象
                JsonObject object = (JsonObject) parser.parse(new FileReader("test.json"));
                
                
                /**
                 * JsonElement对象提供了对所有类型获取的方法。
                 * 
                 * 获取值的方法：
                 * getAsBigDecimal() 
                 * getAsBigInteger() 
                 * getAsBoolean()     
                 * getAsByte() 
                 * getAsCharacter() 
                 * getAsDouble() 
                 * getAsFloat() 
                 * getAsInt() 
                 * getAsLong() 
                 * getAsNumber() 
                 * getAsShort() 
                 * getAsString() 
                 * 
                 * getAsJsonArray() 
                 * getAsJsonNull() 
                 * getAsJsonObject()     
                 * getAsJsonPrimitive() 
                 * 
                 * 判断的方法：
                 * isJsonArray() 是否为一个数组
                 * isJsonNull()  
                 * isJsonObject() 
                 * isJsonPrimitive() 
                 * toString() 
                 */
                
                //连写
                String name = object.get("name").getAsString();
                String age = object.get("age").getAsString();
                
                //获取节点存储的json对象
                JsonObject asJsonObject = object.getAsJsonObject("msg");
                JsonElement jsonElement2 = asJsonObject.get("a");//获取对象中的a节点
                String a = jsonElement2.getAsString();//获取a节点的值
                
                //获取对象中的b节点
                JsonElement jsonElement3 = asJsonObject.get("b");
                String b = jsonElement3.getAsString();//获取b节点的值
                
                Gson gson = new Gson();
                //获取节点存储的json对象
                JsonArray jsonArray = object.getAsJsonArray("core");
                //遍历JsonArray对象
                Iterator it = jsonArray.iterator();
                while(it.hasNext()){
                    JsonElement e = (JsonElement)it.next();
                    //JsonElement转换为JavaBean对象
                    Student jbDemo = gson.fromJson(e, Student.class);
                    System.out.println(jbDemo.getName() + "-" + jbDemo.getAge());  //zhangsan-25  lisi-26
                }
        } catch (JsonIOException e) {
            e.printStackTrace();
        } catch (JsonSyntaxException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

import com.google.gson.Gson;

public class JsonAnalysis2 {
    public static void main(String[] args) {
        /**
         * gson提供的方法：
         *         fromJson(String json, Class<T> classOfT) 
         *         fromJson(JsonElement json, Class<T> classOfT) 
         *     解析json字符串或者JsonElement成指定的对象
         */
        String jsonData = "{'name':'John', 'age':20}";
        Gson gson = new Gson();
        Student stu = gson.fromJson(jsonData,Student.class);
        System.out.println(stu.getName() + "-" + stu.getAge());
    }
}

import com.google.gson.Gson;

public class JsonAnalysis3 {
    public static void main(String[] args) {
        Gson gson = new Gson();
        //解析基本类型数据
        int i = gson.fromJson("1", int.class);  
        double d = gson.fromJson(""1.11"", double.class); 
        double d2 = gson.fromJson("1.11", double.class);
        boolean b = gson.fromJson("true", boolean.class); 
        String s = gson.fromJson("str", String.class);
        
        System.out.println(i);    // 1
        System.out.println(d);    // 1.11 
        System.out.println(d2);    // 1.11  
        System.out.println(b);    // true 
        System.out.println(s);    // str
    }
}

import com.google.gson.Gson;

public class JsonAnalysis4 {
    public static void main(String[] args) {
        Gson gson = new Gson();
        /**
         * toJson(Object src) 返回一个字符串。    对象转成json字符串
         */
        Gson gson1 = new Gson();  
        String s1= gson1.toJson(1);  
        String s2= gson1.toJson(false); 
        String s3= gson1.toJson("str"); 
        
        System.out.println(s1);// 1
        System.out.println(s2);// false 
        System.out.println(s3);//"str" 
    }
}

import com.google.gson.Gson;

public class JsonAnalysis5 {
    public static void main(String[] args) {
        Gson gson = new Gson();
        /**
         * 字符串数组转成json字符串，然后将json字符串转成字符串数组
         */
        String jsonss = "[aa,bb,cc]";
        //将json字符串转成对应的字符串类型的数组
        String[] str = gson.fromJson(jsonss, String[].class);  
        for (String st:str) {  
             System.out.println(st);//遍历得到数组中的元素
        }  
    }
}

import java.util.ArrayList;
import java.util.List;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
/**
 * 解析list
 */
public class JsonAnalysis6 {
    public static void main(String[] args) {
        Gson gson = new Gson();
        //自己创建json字符串
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        String json = gson.toJson(list);//将list转成Json格式的字符串
        
        //将json字符串转成对应的字符串类型的数组
        List<String> strList = gson.fromJson(json, new TypeToken<List<String>>() {}.getType());  
        for (String st:strList) {  
             System.out.println(st);//遍历得到数组中的元素
        }  
    }
}

GSON2

public class User {
    private String name;
    private int age;

    // @SerializedName("email_address") // test5()使用
    // @SerializedName(value="emailAddress",alternate={"email","email_address"})//test6()使用
    private String emailAddress;
    public User() {}
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public User(String name, int age, String emailAddress) {
        this.name = name;
        this.age = age;
        this.emailAddress = emailAddress;
    }
    //set和get方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getEmailAddress() {
        return emailAddress;
    }
    public void setEmailAddress(String emailAddress) {
        this.emailAddress = emailAddress;
    }
}

public class Resulter<T> {
    public int code;
    public String message;
    public T data;
    public Resulter() {}
    //set和get方法
    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

import java.util.ArrayList;
import java.util.List;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

public class TestGson {
    private Gson gson = new Gson();
    /**
     * 测试main
     */
    public static void main(String[] args) {
        TestGson test = new TestGson();
        test.test9();
    }
    /**
     * json字符串转基本数据类型(String虽不是基本数据类型，但是是值传递，与基本数据类型处理相似)
     */
    public void test1() {
        int i = gson.fromJson("100", int.class); // 100
        double d = gson.fromJson("99.99", double.class); // 99.99
        boolean b = gson.fromJson("true", boolean.class); // true
        String str = gson.fromJson("String", String.class); // String

        System.out.println(i);
        System.out.println(d);
        System.out.println(b);
        System.out.println(str);
    }

    /**
     * 基本数据类型转json字符串(String虽不是基本数据类型，但是是值传递，与基本数据类型处理相似)
     */
    public void test2() {
        String jsonNumber = gson.toJson(100); // 100
        String jsonBoolean = gson.toJson(false); // false
        String jsonString = gson.toJson("String"); // "String"

        System.out.println(jsonNumber);
        System.out.println(jsonBoolean);
        System.out.println(jsonString);
    }

    /**
     * java对象转json字符串
     */
    public void test3() {
        User user = new User("ZhangSan", 24);
        String jsonObject = gson.toJson(user); // {"name":"ZhangSan","age":24}
        System.out.println(jsonObject);
    }

    /**
     * json字符串转java对象
     */
    public void test4() {
        String jsonString = "{name:ZhangSan,age:24}";
        User user = gson.fromJson(jsonString, User.class);
        System.out.println(user.getName() + " | " + user.getAge() + " | " + user.getEmailAddress());
    }

    /**
     * @SerializedName()的使用_1
     */
    public void test5() {
        User user = new User("ZhangSan", 24, "abc@163.com");
        String jsonObject = gson.toJson(user);
        // User.emailAddress未加'@SerializedName("email_address")'时的转换效果如下：
        // {"name":"ZhangSan","age":24,"emailAddress":"abc@163.com"}

        // User.emailAddress加了'@SerializedName("email_address")'时的转换效果如下：
        // {"name":"ZhangSan","age":24,"email_address":"abc@163.com"}
        System.out.println(jsonObject);
    }

    /**
     * @SerializedName()的使用_2
     */
    public void test6() {
        String json = "{name:ZhangSan,age:24,emailAddress:abc_1@example.com,"
                + "email:abc_2@example.com,email_address:abc_3@example.com}";
        User user = gson.fromJson(json, User.class);

        System.out.println(user.getEmailAddress()); // abc_3@example.com

        // 当上面的三个属性(email_address、email、emailAddress)都中出现任意一个时均可以得到正确的结果。
        // 注：当多种情况同时出时，以最后一个出现的值为准。
        // 注：alternate需要2.4版本,本次测试的版本不可使用
    }

    /**
     * json字符串转基本类型数组(String虽不是基本数据类型，但是是值传递，与基本数据类型处理相似)
     */
    public void test7() {
        String jsonArray = "[Android,Java,PHP]";
        String[] strings = gson.fromJson(jsonArray, String[].class);
        System.out.println(strings[1]);
    }

    /**
     * TypeToken来实现对泛型的支持_1 将String[].class 直接改为 List<String>.class 是行不通的。需要进行泛型擦除。
     */
    public void test8() {
        String jsonArray = "[Android,Java,PHP]";
        List<String> stringList = gson.fromJson(jsonArray, (new TypeToken<List<String>>() {
        }).getType());
        System.out.println(stringList.get(1));
    }

    /**
     * TypeToken来实现对泛型的支持_2
     */
    public void test9() {
        Resulter<List<User>> result = new Resulter<List<User>>();
        result.setCode(200);
        result.setMessage("success");
        result.setData(new ArrayList<User>() {
            {
                for (int i = 0; i < 2; i++) {
                    this.add(new User("ZhangSan" + i, 25 + i, "abc@163.com"));
                }
            }
        });

        // 不使用TypeToken无法将User的内容转换出来
        // fromJson()方法也是一样需要使用TypeToken指定要转换成的java对象类型
        String gsonStr = gson.toJson(result, (new TypeToken<Resulter<List<User>>>() {
        }).getType());
        System.out.println(gsonStr);
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
import com.google.gson.reflect.TypeToken;

/**
 * @ClassName: GsonUtil
 * @Description: Gson解析json工具类
 */
public class GsonUtil {
    private static Gson gson = null;
    
    static {
        if (gson == null) {
            gson = new Gson();
        }
    }

    private GsonUtil() {}

    /**
     * 将object对象 转成json字符串
     */
    public static String GsonString(Object object) {
        String gsonString = null;
        if (gson != null) {
            gsonString = gson.toJson(object);
        }
        return gsonString;
    }

    /**
     * 将json字符串 转成泛型bean
     */
    public static <T> T GsonToBean(String gsonString, Class<T> cls) {
        T t = null;
        if (gson != null) {
            t = gson.fromJson(gsonString, cls);
        }
        return t;
    }

    /**
     * json字符串 转成list 泛型在编译期类型被擦除导致报错
     */
    public static <T> List<T> GsonToList(String gsonString, Class<T> cls) {
        List<T> list = null;
        if (gson != null) {
            list = gson.fromJson(gsonString, new TypeToken<List<T>>() {
            }.getType());
        }
        return list;
    }

    /**
     * json字符串 转成list 解决泛型问题
     */
    public static <T> List<T> jsonToList(String json, Class<T> cls) {
        Gson gson = new Gson();
        List<T> list = new ArrayList<T>();
        JsonArray array = new JsonParser().parse(json).getAsJsonArray();
        for (final JsonElement elem : array) {
            list.add(gson.fromJson(elem, cls));
        }
        return list;
    }

    /**
     * json字符串中有map的 转成list
     */
    public static <T> List<Map<String, T>> GsonToListMaps(String gsonString) {
        List<Map<String, T>> list = null;
        if (gson != null) {
            list = gson.fromJson(gsonString, new TypeToken<List<Map<String, T>>>() {
            }.getType());
        }
        return list;
    }

    /**
     * json字符串 转成map的
     */
    public static <T> Map<String, T> GsonToMaps(String gsonString) {
        Map<String, T> map = null;
        if (gson != null) {
            map = gson.fromJson(gsonString, new TypeToken<Map<String, T>>() {
            }.getType());
        }
        return map;
    }
}