精华内容
参与话题
问答
  • Gson

    千次阅读 2018-04-24 08:08:02
    GSON是Google开发的Java API,用于转换Java对象和Json对象。 引用这个主要为了减少格式错误导致程序异常。 gson和其他现有java json类库最大的不同时gson需要序列化得实体类不需要使用annotation来标识需要序列化...

    GSON是Google开发的Java API,用于转换Java对象和Json对象。

    引用这个主要为了减少格式错误导致程序异常。

    gson和其他现有java json类库最大的不同时gson需要序列化得实体类不需要使用annotation来标识需要序列化得字段,同时gson又可以通过使用annotation来灵活配置需要序列化的字段。

     

    一、添加依赖

    添加Google的GSON包 这里记得是在Android Studio中写的 Gradle构建的

    compile 'com.google.code.gson:gson:2.6.2'
    gson = new GsonBuilder()  
                       .setLenient()// json宽松  
                       .enableComplexMapKeySerialization()//支持Map的key为复杂对象的形式  
                       .serializeNulls() //智能null  
                       .setPrettyPrinting()// 调教格式  
                       .disableHtmlEscaping() //默认是GSON把HTML 转义的  
                       .create(); 

     

    二、Gson高级使用

    GsonBuilder

    这里主要用到 将对象转成json字符串 记得当时手机端查询自身sqlite数据库,然后将结果拼成字符串传递给后台服务器。后台解析json,获取结果。

    对象中存在null的情况,同样在字符串中体现出来。

                    Gson gson = new Gson();
    
                    //查询每个表 返回需要的json字符串
                    //CRM_PRO_DT
    
                    CRM_PRO_DT model = new CRM_PRO_DT();
                    CRM_PRO_DT_Dao dao = new CRM_PRO_DT_Dao(getActivity());
                    List<CRM_PRO_DT> list = new ArrayList<CRM_PRO_DT>();
                    list = dao.queryForEq("ID", SB_ID);
                    if (list.size() != 0) {
    
                        model.setCCBH(list.get(0).getCCBH() == null ? "" : list.get(0).getCCBH());
                        model.setZZRQ(list.get(0).getZZRQ() == null ? "" : list.get(0).getZZRQ());
                        model.setKZFS(list.get(0).getKZFS() == null ? "" : list.get(0).getKZFS());
                        model.setSBSYDD(list.get(0).getSBSYDD() == null ? "" : list.get(0).getSBSYDD());
    
    
                        HashMap<String, Object> map = new HashMap<String, Object>();
                        map.put("CCBH", list.get(0).getCCBH() == null ? "" : list.get(0).getCCBH());
                        map.put("ZCDM", null);
    
                        String jsonstr = gson.toJson(map);
    
                        GsonBuilder gsonBuilder = new GsonBuilder();
    
    
                        //null也序列化出来
                        String jsonstr2 = gsonBuilder.serializeNulls().create().toJson(map);
                        String jsonstr3 = gsonBuilder.serializeNulls().create().toJson(model);
    
                        //想序列化谁就序列化谁(没有@Expose注释的属性将不会被序列化.。)
                        String jsonstr4 = gsonBuilder.excludeFieldsWithoutExposeAnnotation().create().toJson(model);
    
    
                    }
    @Expose //(标有注解 才序列化)
        @DatabaseField(columnName = "CCBH")
        private String CCBH;

     

    三、拼接json字符串

    Gson直接解析HashMap拼接json

    Gson gson = new GsonBuilder().serializeNulls().create();
                        HashMap<String, Object> map = new HashMap<>();
                        map.put("ID",list.get(i).getMYID());
                        map.put("JYLB",list.get(i).getJYLB());
                        map.put("YJ",list.get(i).getYJ());
                        map.put("EJ",list.get(i).getEJ());
                        map.put("SJ",list.get(i).getSJ());
                        map.put("SEQ",list.get(i).getSEQ());
                        map.put("SEQ_JL",list.get(i).getSEQ_JL());
    
                        map.put("JYJG","符合");
                        map.put("SHUJU", null);
    
    //                    json += gsonBuilder.serializeNulls().create().toJson(map) + ",";
                        json += gson.toJson(map) + ",";

     

     

     

    四、Gson解析 array数组

    1、array数组举例:

    [{"ID":1,"JYLB":"A","YJ":"1技术资料","EJ":"1.1制造资料","SJ":"液压电梯制造单位提供了以下用中文描述的出厂随机文件:(1)制造许可证明文件;","SEQ":1,"SEQ_JL":1,"JYJG":"符合","SHUJU":null},{"ID":1,"JYLB":"A","YJ":"1技术资料","EJ":"1.1制造资料","SJ":"液压电梯制造单位提供了以下用中文描述的出厂随机文件:(1)制造许可证明文件;","SEQ":1,"SEQ_JL":1,"JYJG":"符合","SHUJU":null}]

    2、主要代码

    首先创建model,然后将json数据转为对象,直接操作对象,不用去考虑类型转换。

     

    fromJson方法就是下面这个方法,将一个Json数据转换为对象。

    提供两个参数,分别是json字符串以及需要转换成对象的类型。

     new TypeToken<List<City>>(){}.getType()  就是说要把Json数据转换成List<City>类型的结果。

            Gson gson=new Gson();  
      
            List<City> rs=new ArrayList<City>();  
      
            Type type = new TypeToken<ArrayList<City>>() {}.getType();  
      
            rs=gson.fromJson(str, type);  

     

     

    基本的json解析,需要考虑类型的转换,而gosn创建model的时候已经考虑进去了。

            // 解析json数组
    		JSONArray array = new JSONArray(str);
    		for (int i = 0; i < array.length(); i++) {
    			JSONObject object = (JSONObject) array.get(i);
    
    			Double positive_prob = (Double) object.get("positive_prob");
    
    			System.out.println("positive_prob:" + positive_prob);
    		}

    因为获取到的数据类型不确定,这种方法很容易出现类型转换错误。

    Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.Double
    	at com.baidu.ai.Sample.main(Sample.java:98)

     

     

     

    展开全文
  • Google Gson API 介绍与使用

    万次阅读 2018-11-23 13:22:01
    Gson Summary 编码示例 Gson toJson 与 fromJson JsonObject、JsonArray、JsonParser 字段值为 null 时是否序列化 Gson Summary Java解析Json最常用的类库有:google 的Gson、阿里巴巴的FastJson、以及 ...

    目录

    Gson 概述与下载

    Gson (反)序列化 Java 对象

    JsonElement  Json 元素

    JsonObject Json 对象

    JsonArray Json 数组

    JsonParser Json 解析

    GsonBuilder 构建 Gson


    Gson 概述与下载

    1、Java 解析 Json 最常用的类库有:google 的 Gson阿里巴巴的 FastJson、以及 Jackson。这些都是非常优秀而且常用的库。

    2、GSON 是 Google 提供的用来在 Java 对象和 JSON 数据之间进行映射的 Java 类库,可以快速的将一个 Json 字符转成一个 Java 对象,或者将一个 Java 对象转化为 Json 字符串。

    3、gson 在 github 上开源地址:https://github.com/google/gson

    二进制开发包下载:gson 二进制开发包下载地址:https://search.maven.org/artifact/com.google.code.gson/gson/2.8.5/jar

     gson-2.8.4.jar下载gson-2.8.5.jar下载

    Maven 依赖:gson 在 Maven 仓库地址:https://mvnrepository.com/artifact/com.google.code.gson/gson

    <!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.8.5</version>
    </dependency>

    Gson (反)序列化 Java 对象

    1、com.google.gson.Gson 提供 toJson() 和 fromJson() 方法用于序列化与反序列化  Java 对象。

    2、Gson 对象的 toJson 方法可以将 Java 基本数据类型、以及 POJO 对象、List、Map 、JsonElement  等转为 json 格式的字符串,

    3、Gson 对象的 fromJson 方法做与 toJson 相反的操作,将 json 格式的字符串转为基本数据类型、 POJO 对象、List、Map 、JsonElement  等

    对象序列化
     T fromJson(String json, Class<T> classOfT) 将指定的 Json 反序列化为指定类的对象,如果指定的类是泛型类型,则使用 fromJson(String, Type)方法。
    T fromJson(String json, Type typeOfT) 将指定的 Json 反序列化为指定类型的对象,如果指定的对象是泛型类型,则此方法很有用,对于非泛型对象,请改用 fromJson(String json, Class<T> classOfT)
    T fromJson(JsonElement json, Class<T> classOfT) 将指定的 json 元素反序列化为指定类型的对象,如果指定的类是泛型类型,则使用 fromJson(JsonElement, Type) 方法。
    T fromJson(JsonElement json, Type typeOfT)  
    T fromJson(Reader json, Class<T> classOfT)
    T fromJson(Reader json, Type typeOfT)
    将从指定字符输入流读取的Json反序列化为指定类的对象,如果指定的类是泛型类型,则调用 {@link#fromJson(Reader,type)}
    序列化为对象
    String toJson(Object src) 将指定的对象序列化为其等效的Json表示形式,当指定的对象不是泛型类型时,应使用此方法,如果对象是泛型类型,请改用 toJson(object,type).
    String toJson(Object src, Type typeOfSrc) 将指定的对象(包括泛型类型的对象)序列化为其等效的Json表示形式,对于非泛型对象,请改用{@link#toJson(Object)}
    String toJson(JsonElement jsonElement) 将 JsonElement 转换为其等效的JSON表示形式。
    JsonElement toJsonTree(Object src) 将指定的对象序列化为 JsonElement 的等效表示形式,当指定的对象不是泛型类型时,应使用此方法;如果对象是泛型类型,请改用{@link#toJsonTree(object,type)}
    JsonElement toJsonTree(Object src, Type typeOfSrc)  

    API 演示源码:https://github.com/wangmaoxiong/apache-study/blob/master/src/main/java/com/wmx/gson/GsonTest.java

    JsonElement  Json 元素

    1、JsonObject、JsonArray、JsonPrimitive、JsonNull 都是 JsonElement 的子类,JsonElement  常用方法:

    JsonElement deepCopy() 返回此元素的深层副本,克隆。
     BigDecimal getAsBigDecimal() 将此元素作为 BigDecimal 类型获取,如果元素不是 JsonPrimitive,则引发 ClassCastException,
    如果元素不是有效的 BigDecimate,则 @throws NumberFormatException。
    如果元素属于 JsonArray 类型,但包含多个元素,则引发 IllegalStateException。
    BigInteger getAsBigInteger() 将此元素作为 BigInteger  类型获取,如果元素不是 JsonPrimitive,则引发 ClassCastException,
    如果元素不是有效的 BigInteger ,则 @throws NumberFormatException。
    如果元素属于 JsonArray 类型,但包含多个元素,则引发 IllegalStateException。
    boolean getAsBoolean() 将此元素作为原始布尔值获取,如果元素不是 JsonPrimitive 并且不是有效的布尔值,则引发 ClassCastException,
    如果元素属于 JsonArray 类型,但包含多个元素,则引发IllegalStateException
    byte getAsByte() 将此元素作为原始 byte  值获取,如果元素不是 JsonPrimitive 并且不是有效的布尔值,则引发 ClassCastException,
    如果元素属于 JsonArray 类型,但包含多个元素,则引发IllegalStateException

    其它 Java 基本数据类型也是同理:

    double getAsDouble()、char getAsCharacter()、float getAsFloat()、int getAsInt()、long getAsLong()、short getAsShort()

    JsonArray getAsJsonArray() 将此元素作为 JsonArray 获取,如果元素是其他类型的元素,则会生成 IlleglastateException 异常,
    因此最好先调用 isJsonArray() 方法确保该元素是所需的类型,然后再使用此方法。
    JsonObject getAsJsonObject() 将此元素作为 JsonObject 获取,如果元素是其他类型的元素,则会引发 IlleglastateException 异常,
    因此最好先通过调用 isJsonObject() 方法来确保该元素是所需类型之后使用此方法。
    JsonPrimitive getAsJsonPrimitive()

    将此元素作为 JsonPrimitive 获取,如果元素是其他类型的元素,则会引发 IlleglastateException 异常,
    因此最好先通过调用 isJsonPrimitive() 方法来确保该元素是所需的类型之后再使用此方法。

    JsonPrimitive 值可以是 Java 字符串、Java 基本数据类型及其包装器类型。

    boolean isJsonArray()

    验证此元素是否为数组,如果此元素属于 JsonArray 类型,则返回 true,否则返回 false。

    boolean isJsonNull()

    验证此元素是否表示 null 值,如果此元素的类型为 JsonNull,则返回 true,否则返回 false。

    boolean isJsonObject()

    验证此元素是否为 JsonObject 对象。

    boolean isJsonPrimitive()

    以验证此元素是否为 Java 数据类型。
        /**
         * JsonPrimitive getAsJsonPrimitive():
         * 将此元素作为 JsonPrimitive 获取,如果元素是其他类型的元素,则会引发 IlleglastateException 异常,
         * 因此最好先通过调用 isJsonPrimitive() 方法来确保该元素是所需的类型之后再使用此方法。JsonPrimitive 值可以是 Java 字符串、Java 基本数据类型及其包装器类型。
         */
        @Test
        public void test12() {
            String json = "[\"本级小计\",368.00,328.00,]";
            JsonElement sourceJsonElement = new JsonParser().parse(json);
            JsonArray jsonArray = sourceJsonElement.getAsJsonArray();
            for (int i = 0; i < jsonArray.size(); i++) {
                JsonElement jsonElement = jsonArray.get(i);
                if (jsonElement.isJsonPrimitive()) {
                    JsonPrimitive jsonPrimitive = jsonElement.getAsJsonPrimitive();
                    if (jsonPrimitive.isString()) {
                        System.out.println(jsonPrimitive.getAsString());
                    } else if (jsonPrimitive.isNumber()) {
                        System.out.println(jsonPrimitive.getAsDouble());
                    }
                }
            }
        }

    API 演示源码:

    https://github.com/wangmaoxiong/apache-study/blob/master/src/main/java/com/wmx/gson/JsonObjectTest.java

    https://github.com/wangmaoxiong/apache-study/blob/master/src/main/java/com/wmx/gson/JsonArrayTest.java

    JsonObject Json 对象

    add(String property, JsonElement value) 添加一个健-值对的成员,名称必须是字符串,但值可以是任意的 JsonElement 类型。
    addProperty(String property, Boolean value) 添加布尔成员的便利方法,指定的值将转换为布尔值的 JsonPrimitive。
    addProperty(String property, Character value) 添加 char 成员的便利方法,指定的值将转换为字符的 JsonPrimitive。
    addProperty(String property, Number value) 添加 Number  成员的便利方法,指定的值将转换为数字的 JsonPrimitive。
    addProperty(String property, String value) 添加 String 成员的便利方法,指定的值将转换为数字的 JsonPrimitive。
    Set<Map.Entry<String, JsonElement>> entrySet() 返回此对象的所有成员,集合是有序的,与元素的添加顺序相同。
    JsonElement get(String memberName) 返回具有指定名称的成员。
    JsonArray getAsJsonArray(String memberName) 获取指定成员作为 JsonArray 的便利方法。
    JsonObject getAsJsonObject(String memberName) 获取指定成员作为 JsonObject 的便利方法。
    JsonPrimitive getAsJsonPrimitive(String memberName) 获取指定成员作为 JsonPrimitive  的便利方法。
    boolean has(String memberName) 检查此对象中是否存在具有指定名称的成员的便利方法。
    Set<String> keySet() 返回所有成员的 key 值。
    JsonElement remove(String property) 从此 JsonObject 中删除指定的属性,返回被删除的属性。
    int size() 返回对象中键/值对的数目。
        /**
         * int size():返回对象中键/值对的数目。
         * Set<String> keySet():返回所有成员的键值
         */
        @Test
        public void jsonObject7() {
            String json = "{\"pId\":9527,\"pName\":\"华安\",\"isMarry\":true}";
            JsonObject jsonObject = new JsonParser().parse(json).getAsJsonObject();
            System.out.println(jsonObject.size());
            Set<String> keySet = jsonObject.keySet();//3
            System.out.println(keySet);//[pId, pName, isMarry]
        }

    API 演示源码:https://github.com/wangmaoxiong/apache-study/blob/master/src/main/java/com/wmx/gson/JsonObjectTest.java

    JsonArray Json 数组

    JsonArray()

    JsonArray(int capacity)

    两个构造器,一个是创建空的 Json 数组,一个是指定初始容量。
    add( Boolean value) 将指定的布尔值添加到 json 数组,如 value 为 null,则添加 JsonNull。
    add(Character value) 将指定的 Character  值添加到 json 数组,如 value 为 null,则添加 JsonNull。
    add(Number value) 将指定的 Number  值添加到 json 数组,如 value 为 null,则添加 JsonNull。
    add(String value) 将指定的 String  值添加到 json 数组,如 value 为 null,则添加 JsonNull。
    add(JsonElement value) 将指定的 JsonElement  值添加到 json 数组,如 value 为 null,则添加 JsonNull。
    addAll(JsonArray array) 将指定数组中的所有元素添加到此 json 数组。
    boolean contains(JsonElement element) 如果此数组包含指定的元素,则返回true。
    JsonElement get(int i) 返回数组的第 i 个元素,如果下标越界,则抛异常
    Iterator<JsonElement> iterator() 返回一个迭代器来导航数组的元,由于数组是一个有序列表,迭代器按照元素插入的顺序导航元素。
    JsonElement remove(int index) 删除此数组中指定位置的元素,向左移动任何后续元素(从其索引中减去一个),返回从数组中删除的元素。
    boolean remove(JsonElement element) 从该数组中删除第一个出现的指定元素(如果存在)。如果数组不包含元素,则它将保持不变。
    JsonElement set(int index, JsonElement element) 将此数组中指定位置的元素替换为指定元素,元素不能为null。
    int size() 返回数组的大小。
        @Test
        public void test4() {
            JsonArray jsonArray = new JsonParser().parse("[{\"code\":200,\"msg\":\"成功\"}]").getAsJsonArray();
            JsonArray deepCopy = jsonArray.deepCopy();
            deepCopy.add("Yes");
            System.out.println(jsonArray);//[{"code":200,"msg":"成功"}]
            System.out.println(deepCopy);//[{"code":200,"msg":"成功"},"Yes"]
        }

    API 演示源码:https://github.com/wangmaoxiong/apache-study/blob/master/src/main/java/com/wmx/gson/JsonArrayTest.java

    JsonParser Json 解析

    1、JsonParser 用于将 Json 字符内容解析为  json 元素 JsonElement。

    JsonElement parse(Reader json) 将指定的 JSON 字符串字符输入流解析为 Json 元素,如果指定的文本不是有效的 JSON 字符串,则抛出 JsonParseException 异常。
    JsonElement parse(String json) 将指定的 JSON 字符串解析为 Json 元素,如果指定的文本不是有效的 JSON 字符串,则抛出 JsonParseException 异常。
        @Test
        public void test1() {
            String json = "{\"id\":1000,\"name\":\"华安\",\"birthday\":\"Jul 13, 2020 8:46:42 PM\",\"marry\":true}";
            JsonParser jsonParser = new JsonParser();
            JsonElement jsonElement = jsonParser.parse(json);
            JsonObject jsonObject = jsonElement.getAsJsonObject();
            System.out.println(jsonObject);//{"id":1000,"name":"华安","birthday":"Jul 13, 2020 8:46:42 PM","marry":true}
        }

    API 演示源码:https://github.com/wangmaoxiong/apache-study/blob/master/src/main/java/com/wmx/gson/JsonParserTest.java

    GsonBuilder 构建 Gson

    1、对于默认配置的 Gson,直接使用 new Gson 更简单,当需要设置默认值以外的配置选项时,使用 GsonBuilder 构建器,调用它的各种配置方法,最后调用 create 方法创建 Gson 对象。

    GsonBuilder serializeNulls() 序列化空字段,默认情况下,Gson 序列化期间会忽略所有为 null 的字段
    GsonBuilder setDateFormat(String pattern) 根据提供的模式序列化 Date 日期对象,可以多次调用,但只有最后一次调用将用于决定序列化格式。

     GsonBuilder setFieldNamingPolicy(FieldNamingPolicy namingConvention)

    1、配置为在序列化和反序列化期间将特定命名策略应用于对象的字段。

    2、namingConvention:用于序列化和反序列化的 JSON 字段命名约定/策略,可选值如下:

    IDENTITY:使用对象默认的字段名称
    UPPER_CAMEL_CASE:使用驼峰命名
    UPPER_CAMEL_CASE_WITH_SPACES:将 Java 字段名的第一个'字母'在序列化为JSON格式时大写,单词之间用空格隔开
    LOWER_CASE_WITH_UNDERSCORES:使用此命名策略将把 Java 字段名从大小写形式修改为全小写字段名,其中单词之间由下划线分隔
    LOWER_CASE_WITH_DASHES:使用此命名策略将把 Java 字段名从大小写形式修改为全小写字段名,其中单词之间用破折号(-)分隔
    LOWER_CASE_WITH_DOTS:使用此命名策略将 Java 字段名从大小写形式修改为全小写字段名,其中每个单词用点(.)分隔。

        @Test
        public void test1() {
            Gson gson = new GsonBuilder()
                    .serializeNulls()
                    .setDateFormat("yyyy-MM-dd HH:mm:ss")
                    .setFieldNamingPolicy(FieldNamingPolicy.IDENTITY)
                    .create();
    
            Person person = new Person();
            person.setId(100);
            person.setBirthday(new Date());
    
            String toJson = gson.toJson(person);
            //{"id":100,"name":null,"birthday":"2020-07-19 11:37:35","marry":null}
            System.out.println(toJson);
    
            Person person1 = gson.fromJson(toJson, Person.class);
            //Person{id=100, name='null', birthday=Sun Jul 19 11:37:35 CST 2020, marry=null}
            System.out.println(person1);
        }

    API 演示源码:https://github.com/wangmaoxiong/apache-study/blob/master/src/main/java/com/wmx/gson/GsonBuilderTest.java

    展开全文
  • Gson基本用法

    万次阅读 多人点赞 2018-05-12 14:25:03
    Gson是谷歌官方推出的支持 JSON -- Java Object 相互转换的 Java序列化/反序列化 库,之前由于没有用过,所以学习一下。 1. 导入Android Studio工程 dependencies { implementation '...

    Gson是谷歌官方推出的支持 JSON -- Java Object 相互转换的 Java序列化/反序列化 库,之前由于没有用过,所以学习一下。

    1. 导入Android Studio工程

    dependencies {
        implementation 'com.google.code.gson:gson:2.8.4'
    }
    

    2. 简单的 Java Object 序列化/反序列化

    序列化

    假如有一个User类,拥有 name, email, age, isDeveloper 四个属性,如下:

    User userObject = new User(  
        "Norman", 
        "norman@futurestud.io", 
        26, 
        true
    );
    

    使用Gson将它序列化:

    Gson gson = new Gson();
    String userJson = gson.toJson(userObject);
    

    得到的结果如下:

    {
    	"isDeveloper":true,
    	"name":"Norman",
    	"age":26,
    	"email":"norman@futurestud.io"
    }
    

    反序列化

    先定义一段JSON字符串

    String userJson = "{'isDeveloper':false,'name':'xiaoqiang','age':26,'email':'578570174@qq.com'}";
    

    Gson反序列化

    User user = gson.fromJson(userJson, User.class);
    

    debug一下,查看结果
    这里写图片描述
    反序列化成功!

    3. 嵌套 Java Object 的序列化/反序列化

    也就是说,一个类里面还包含有其它类。比如User类里面还有个用户地址UserAddress类,JSON结构如下:

    {
        "age": 26,
        "email": "578570174@qq.com",
        "isDeveloper": true,
        "name": "chenrenxiang",
    
        "userAddress": {
            "city": "Magdeburg",
            "country": "Germany",
            "houseNumber": "42A",
            "street": "Main Street"
        }
    }
    

    那么这种Java Object该如何序列化/反序列化呢?和上面一样。也就是说和 2 里面介绍的方法一样


    4. Array 和 List 的序列化/反序列化

    序列化
    序列化和前面介绍的方法是一样的

    反序列化
    那就有些不同了,不然也不用分开写。

    1 Array的反序列化
    先假设有一个name数组,定义JSON格式如下:

    String namesJson = "['xiaoqiang','chenrenxiang','hahaha']";
    

    然后使用Gson去反序列化它:

    Gson gson = new Gson();
    String[] nameArray = gson.fromJson(namesJson, String[].class);
    

    得到的nameArray如下:
    这里写图片描述
    其实这和 2 里面介绍的反序列化方法仍然是一样的。可以看到,Gson的反序列化都是调用 Gson.fromJson(...)方法,传入JSON字符串,以及这段JSON字符串对应的Object类型。

    2 List的反序列化

    String userJson = "[{'isDeveloper':false,'name':'xiaoqiang','age':26,'email':'578570174@qq.com'},{'isDeveloper':true,'name':'xiaoqiang123','age':27,'email':'578570174@gmail.com'}]";
    
    Gson gson = new Gson();
    Type userListType = new TypeToken<ArrayList<User>>(){}.getType();
    
    List<User> userList = gson.fromJson(userJson, userListType); 
    

    对于List,反序列化时必须提供它的Type,通过Gson提供的TypeToken<T>.getType()方法可以定义当前List的Type。反序列化后结果如下:

    这里写图片描述

    那么,如果一个Java Object里包含List类型的变量,该如何反序列化这个Object呢?答案是,和 2 一样就行了,无需为其内部的List提供Type

    5. Map 和 Set 的序列化/反序列化

    Map我平时用的较多,Set用的就很少了,它们的序列化/反序列化方法和List都是一样的,反序列化的时候需要提供Type

    6. 变量值为null时的序列化/反序列化

    仍然以User类为例,如果一个User对象,里面的某个值为null,那么其序列化出来后的结果会是什么样的呢?

    先看序列化,我们先初始化一个User对象,并把其中的email变量赋值为null,再用Gson来序列化它,如下:

        User user = new User(true, "chenrenxiang", 27, null);
        Gson gson = new Gson();
        String userJson = gson.toJson(user);
    

    debug一下,得到结果如下:
    这里写图片描述

    可见,当某个变量值为null时,Gson在序列化的时候直接把这个变量忽略了。

    再来看下反序列化, 先定义一段JSON字符串,只给它一个变量值name,用User类来反序列化它,看得到的结果会是什么。

       String userJson = "{'name':'xiaoqiang'}";
       Gson gson = new Gson();
       User user = gson.fromJson(userJson, User.class);
    

    这里写图片描述
    对于JSON字符串里没有的变量,Gson在反序列化时会给它一个默认值,int类型默认为0,bool类型默认为false,String类型默认为null。

    有人不禁要问了,如果JSON字符串里某个变量的值为null,反序列化后的结果会是什么呢?我测试过了,和没有的结果是一样的。

    7. 控制序列化/反序列化 的变量名称

    仍然以User对象为例,目前User对象里有四个变量nameageemailisDeveloper。假如,某一天,JSON字符串的变量名name变成了fullName,无需紧张,我们不用把User类里的变量name改为fullName,然后把它的getset方法都改了,然后把用到get/set方法的地方全改过来。只需要用Gson提供的注解方法@SerializedName就行了,如下:

    public class User {
        private boolean isDeveloper;
        @SerializedName("fullName")
        private String name;
        private int age;
        private String email;
        ...
    }
    

    这样虽然JSON字符串里的变量名为fullName,但是反序列化后fullName的值会映射给name。同样,把一个User对象序列化,变量name会自动转换为fullName

    然而现实远比想象中复杂,这个JSON有时候传的是fullName,有时候传的是name,这时该怎么办呢? 不用担心,@SerializedName 接受两个参数,valuealternate ,顾名思义,alternate 是备选变量名,比如下面这段代码:

    public class User {
        private boolean isDeveloper;
        @SerializedName(value = "name", alternate = "fullName")
        private String name;
        private int age;
        private String email;
        ...
    }
    

    如果JSON传的是name,那么就用name的值,如果传的是fullName,那么就用fullName的值。需要注意的是,alternate只是反序列化JSON的一个备选变量名,它不会影响序列化,User对象序列化后,会使用value定义的名称为变量名。

    又想到有一个问题,在定义了value和alternate的情况下,假如JSON同时传来了name和fullName,User的name变量会接受哪个值呢? 经过测试,它会都接受。这样也是很合理的,因为Gson会对JSON中的变量一个一个地去解析,既然它可以接受name,也可以接受fullName,那么当同时传来这两个变量时,它就会分别把它们解析出来,并把值赋给User对象中的name变量。那么,name变量的值就会是后解析的那个JSON变量的值,因为它会把前一个值覆盖掉。

    8. 序列化/反序列化过程中忽略某些变量

    也许会出现这样的需求,在将某个对象序列化时,对象中的某些变量是不需要的。有可能在反序列化某个JSON字符串时,某些变量的值也是不需要的。这时就可以使用Gson提供的@Expose注解方法。使用方法如下:

    public class User {  
        @Expose()
        String name; // 参与序列化/反序列化
    
        @Expose(serialize = false, deserialize = false)
        String email; // 不参与序列化,也不参与反序列化
    
        @Expose(serialize = false)
        int age; // 只参与反序列化
    
        @Expose(deserialize = false)
        boolean isDeveloper; // 只参与序列化
    }
    

    使用这个方法,可以非常灵活地控制对象的某个/某些变量参不参与序列化/反序列化

    然而! 要使用这个注解来控制序列化/反序列化,就不能使用默认的Gson对象,新建Gson对象的方法如下:

    GsonBuilder builder = new GsonBuilder();  
    builder.excludeFieldsWithoutExposeAnnotation();  
    Gson gson = builder.create(); 
    

    另一个选择transient关键字 ,使用这个关键字,可以直接让变量不参与序列化/反序列化,如下:

    public class User {  
        String name;
        String email;
        int age;
        boolean transient isDeveloper; //不参与序列化/反序列化
    }
    

    当然,使用默认的Gson对象就可以。


    以上是这两天学到的Gson的基本用法,如果想进一步了解,可以参考Future Studio的 Gson教程

    展开全文
  • Gson介绍

    万次阅读 多人点赞 2018-03-21 17:45:38
    Gson介绍:GSON是Google提供的用来在Java对象和JSON数据之间进行映射的Java类库。可以将一个Json字符转成一个Java对象,或者将一个Java转化为Json字符串。特点: a、快速、高效 b、代码量少、简洁 c、面向对象 d...

    Gson介绍:

    GSON是Google提供的用来在Java对象和JSON数据之间进行映射的Java类库。可以将一个Json字符转成一个Java对象,或者将一个Java转化为Json字符串。
    特点: a、快速、高效
          b、代码量少、简洁
          c、面向对象
            d、数据传递和解析方便
     
    Gson的pom依赖:
            <dependency>
                <groupId>com.google.code.gson</groupId>
                <artifactId>gson</artifactId>
                <version>2.8.0</version>
            </dependency>

    Gson的创建方式:

      方式一:

    Gson gson = new gson();

      方式二:通过GsonBuilder(),可以配置多种配置。

    复制代码
    Gson gson = new GsonBuilder()
                            .setLenient()// json宽松  
                            .enableComplexMapKeySerialization()//支持Map的key为复杂对象的形式  
                            .serializeNulls() //智能null  
                            .setPrettyPrinting()// 调教格式  
                            .disableHtmlEscaping() //默认是GSON把HTML 转义的
                            .create();  
    复制代码

    Gson的基本用法:

    注:JavaBean:

    复制代码
    @NoArgsConstructor
    @AllArgsConstructor
    @Setter
    @Getter
    @ToString
    @Builder
    public class PersonJson {
        private String name;
        private Integer age;
        private String hobby;
    }
    //hobby是在后面的例子中添加的。要么就name,age两个属性,要么就三个。
    //上面的注解是lombok的注解,起到简化Bean类的作用。
    复制代码

    Gson提供了public String toJson(Objcet obj)方法,可以将对象转化为json字符串。

    JavaBean转化为json字符串

    复制代码
    public class IndexTest {
        PersonJson person;
        @Before
        public void prepare() {
            person = new PersonJson("栗霖",18);
        }
    
        @Test
        public void index() {
            Gson gson = new Gson();
            System.out.println(gson.toJson(person));
            System.out.println("---------------");
            Gson gson1 = new GsonBuilder().create();
            System.out.println(gson1.toJson(person));
        }
    }
    复制代码

    结果:

    List Map 转化为json字符串

    复制代码
    public class IndexTest {
        PersonJson person;
        List<PersonJson> list = new ArrayList<>();
        Map<String,PersonJson> map = new HashMap<>();
        @Before
        public void prepare() {
            person = new PersonJson("栗霖",18);
            list.add(person);
            map.put(person.getName(),person);
        }
    
        @Test
        public void index() {
            Gson gson = new Gson();
            System.out.println("---->List convert json" + gson.toJson(list));
            System.out.println("------------------------");
            System.out.println("---->map convert json" + gson.toJson(map));
        }
    }
    复制代码

    结果:

     

    Gson提供了public T fromJson(String jsonStr,T.class)方法,可以将json字符串转化为Java对象 

    json字符串转化为JavaBean

    复制代码
    public class SecondTest {
        @Test
        public void index() {
            String jsonStr = "{\"name\":\"栗霖\",\"age\":\"18\"}";
            Gson gson = new GsonBuilder().create();
            PersonJson p = gson.fromJson(jsonStr,PersonJson.class);
            System.out.println("---->jsonStr convert javaBean " + p.getName() + " " + p.getAge());
        }
    }
    复制代码

    结果:

    json字符串转化为list集合

    复制代码
    public class SecondTest {
        @Test
        public void index() {
            String listJsonStr = "[{\"name\":\"栗霖\",\"age\":\"18\"},{\"name\":\"栗霖之雨\",\"age\":\"18\"}]";
            Gson gson = new GsonBuilder().create();
            List<PersonJson> list = gson.fromJson(listJsonStr,new TypeToken<ArrayList<PersonJson>>(){}.getType());
            System.out.println("---->listJsonStr convert List " + list);
        }
    }
    复制代码

    结果:

    json的抽象基类JsonElemetn:

    JsonNull其实就是Null字段

    复制代码
    public class SecondTest {
        @Test
        public void index() {
            //JsonNull jsonNull = new JsonNull();该方法已经过时
            JsonNull jsonNull = JsonNull.INSTANCE;
            System.out.println("---->jsonNull  " + jsonNull);
        }
    }
    复制代码

    结果:

    jsonPrimitive可以帮助我们获取带转义字符的字符串。这个就不写了。感觉没啥用到。

    创建JsonObject:

      可以通过addProperty(String,Object)向JsonObject添加属性,跟hashmap类似。

    复制代码
    public class SecondTest {
        @Test
        public void index() {
            JsonObject jsonObject = new JsonObject();
            jsonObject.addProperty("name","栗霖");
            jsonObject.addProperty("age",18);
            System.out.println("---->create jsonObject  " + jsonObject);
        }
    }
    复制代码

    结果:

    创建JsonArray

    复制代码
    public class SecondTest {
        @Test
        public void index() {
            JsonArray jsonArray = new JsonArray();
            jsonArray.add("a");
            jsonArray.add("b");
            jsonArray.add("c");
            jsonArray.add("d");
            System.out.println("---->create jsonArray: " + jsonArray);
        }
    }
    复制代码

    结果:

    JsonObject嵌套数组或者说JsonObject嵌套JsonArray

    复制代码
    public class SecondTest {
        @Test
        public void index() {
            JsonObject jsonObject = new JsonObject();
            jsonObject.addProperty("name","栗霖");
            jsonObject.addProperty("age",18);
            JsonArray jsonArray = new JsonArray();
            jsonArray.add("是码农");
            jsonArray.add("以前喜欢玩游戏");
            jsonArray.add("现在只敢小心积累");
            jsonArray.add("只怕突然白了头");
            jsonObject.add("status",jsonArray);
            System.out.println("---->create jsonArray: " + jsonObject);
        }
    }
    复制代码

    结果:


     

    Gson注解

    重命名注解:@SerializedName

    当你调用其他服务时,他们返回的json KEY值与你的Bean属性名称不对应怎么办?

    这时候就需要@SerializedName啦。他可以帮助你解决这个问题!

    实体类:

    复制代码
    @NoArgsConstructor
    @AllArgsConstructor
    @Setter
    @Getter
    @ToString
    @Builder
    public class PersonJson {
        private String name;
        private Integer age;
        //这里只是随便举个例子,千万不要用中文!!!
        @SerializedName(value = "爱好")
        private String hobby;
    }
    复制代码

    示例:

    复制代码
    public class SecondTest {
        JsonObject jsonObject;
        JsonArray jsonArray;
    
        @Before
        public void index() {
            jsonObject = new JsonObject();
            jsonObject.addProperty("name","栗霖");
            jsonObject.addProperty("age",18);
            jsonArray = new JsonArray();
            jsonArray.add("是码农");
            jsonArray.add("以前喜欢玩游戏");
            jsonArray.add("现在只敢小心积累");
            jsonArray.add("只怕突然白了头");
            jsonObject.addProperty("爱好",jsonArray.toString());
        }
    
        @Test
        public void formal() {
            Gson gson = new GsonBuilder().create();
            PersonJson personJson = gson.fromJson(jsonObject.toString(),PersonJson.class);
            System.out.println("---->String: " + personJson);
        }
    }
    复制代码

    结果:

    @serializedName

    除了value属性外,还可以使用alternate属性,这个值可以替换前面的值,将传入的json进行修改。

    注:value的值不能出现在alternate中,alternate是备选字段。

    @SerializedName(value = "hobby", alternate = {"interest","be fond of"})

    过滤注解@Expose

    注:默认是既可以序列化,也可以反序列化。一定要配合GsonBuilder一起使用

      该注解是加在JavaBean的属性上使用的。

      配合这个使用哦Gson gson = new GsonBuilder().excludeFieldWithoutExposeAnnotation().create();

    有四种使用方式:

      1)不使用@Expose注解等同于@Expose(deserialize = false, serialize = false)不做任何解析

      2)@Expose(deserialize = true, serialize = false)只解析使用,可以反序列化,不可以序列化。

      3)@Expose(deserialize = false, serialize = true)可以序列化,不可以反序列化。

      4)@Expose(deserialize = false, serialize = true)既可以序列化,也可以反序列化。

    注:这里的序列化指:将对象转化为json字符串。反序列化指:将json字符串转化成对象。

    版本控制注解@Since(float v)

    结合GsonBuilder().serVersion(n)使用。当n>=v时,才会解析。

    注:也是加在JavaBean属性上使用的。

    版本控制注解@Util(float v)

    与@Since相反,这次是n<v时才能够解析。

    使用TypeAdapter来实现序列化与反序列化。

    使用TypeAdapter来序列化和反序列化

    代码:

    复制代码
    public class FiveTest {
        @Test
        public void index() {
            Gson gson = new GsonBuilder().create();
            TypeAdapter<PersonJson> typeAdapter = gson.getAdapter(PersonJson.class);
            String json = "{\"name\":\"栗霖\",\"age\":\"18\",\"hobby\":\"我很是很喜欢FromSoftWare的。大爱宫崎英高,赞美太阳\"}";
            PersonJson p = new PersonJson("栗霖",18,"混系列忠实粉丝");
    
            System.out.println("---->序列化:是将对象转化为字符串 : " + typeAdapter.toJson(p));
            try {
                System.out.println("---->反序列化:是将字符串转化为对象 : "+ typeAdapter.fromJson(json));
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    复制代码

    结果:

     

    Gson的容错机制

    为什么容错:

      如果Bean中定义的是int,但是返回的json对应的是一个""空字串怎么办?这就依赖到了Gson的容错机制。

    1)创建宽松Gson

    遇到问题,停止解析,以防止报错,功能相对较弱。

    Gson gson = new GsonBuilder()
                            .setLenient()//宽松
                            .create();

    2)自定义TypeAdapter

    该方法更倾向于整体防止出现异常。

    复制代码
    public class ThirdTest {
    
        public static class PersonTypeAdapter extends TypeAdapter<PersonJson> {
            @Override
            public void write(JsonWriter jsonWriter, PersonJson personJson) throws IOException {
                jsonWriter.beginObject();
                jsonWriter.name("name").value(personJson.getName());
                jsonWriter.name("age").value(personJson.getAge());
                jsonWriter.name("hobby").value(personJson.getHobby());
                jsonWriter.endObject();
            }
    
            @Override
            public PersonJson read(JsonReader jsonReader) throws IOException {
                PersonJson personJson = new PersonJson();
                jsonReader.beginObject();
                while (jsonReader.hasNext()) {
                    switch (jsonReader.nextName()) {
                        case "name":
                            personJson.setName(jsonReader.nextString());
                            break;
                        case "age":
                            try {
                                personJson.setAge(Integer.valueOf(jsonReader.nextString()));
                            } catch (Exception e) {
                            }
                            break;
                        case "hobby":
                            personJson.setHobby(jsonReader.nextString());
                    }
                }
                jsonReader.endObject();
                return personJson;
            }
        }
    
        @Test
        public void index() {
            Gson gson = new Gson();
    
            String json = "{\"name\":\"栗霖\",\"age\":\"\",\"hobby\":\"篮球吧,读书吧,steam吧\"}";
    
            System.out.println("----> " + json );
    
            try {
                PersonJson p1 = gson.fromJson(json,PersonJson.class);
                System.out.println("---->默认解析 " + p1);
            }catch (Exception e) {
                System.out.println("---->异常解析,这里json字符串缺失了age的值,真的是怕一转眼就白了头啊" +e);
            }
    
            Gson gson1 = new GsonBuilder().registerTypeAdapter(PersonJson.class,new PersonTypeAdapter()).create();
    
            try {
                PersonJson p2 = gson1.fromJson(json,PersonJson.class);
                System.out.println("---->自定义Adapter 默认解析 "+p2);
            }catch (Exception e) {
                System.out.println("---->自定义adapter 异常解析" + e);
            }
    
            try {
                PersonTypeAdapter personTypeAdapter = new PersonTypeAdapter();
                PersonJson p3 = personTypeAdapter.fromJson(json);
                System.out.println("---->自定义Adapter 默认解析 " + p3);
            }catch (Exception e){
                System.out.println("---->自定义Adapter 异常解析 " +e);
            }
        }
    }
    复制代码

    结果:

    3)使用注解jsonAdapter,其实质也是自定义Adapter

      该方法更倾向于某一个属性的保护。

    实体类:

    public class PersonJson {
        private String name;
        @JsonAdapter(IntegerTypeAdapter.class)
        private Integer age;
        private String hobby;
    }

    Adapter:

    复制代码
    public class IntegerTypeAdapter extends TypeAdapter<Integer>{
        @Override
        public void write(JsonWriter jsonWriter, Integer integer) throws IOException {
            jsonWriter.value(integer);
        }
    
        @Override
        public Integer read(JsonReader jsonReader) throws IOException {
            int i = 0;
            try {
                i = Integer.valueOf(jsonReader.nextString());
            }catch (Exception e){}
            return i;
        }
    }
    复制代码

    测试类:

    复制代码
    public class FourTest {
    
        @Test
        public void index() {
            Gson gson = new Gson();
            String json = "{\"name\":\"栗霖\",\"age\":\"\",\"hobby\":\"篮球吧,读书吧,steam吧\"}";
    
            try {
                PersonJson p1 = gson.fromJson(json,PersonJson.class);
                System.out.println("---->默认解析 " + p1);
            }catch (Exception e) {
                System.out.println("---->异常解析,这里json字符串缺失了age的值,真的是怕一转眼就白了头啊" +e);
            }
    
            try {
                PersonJson p2 = gson.fromJson(json,PersonJson.class);
                System.out.println("---->默认解析 " + p2);
            }catch (Exception e) {
                System.out.println("---->异常解析" + e);
            }
        }
    }
    复制代码

    结果:

     本文参考:http://blog.csdn.net/axuanqq/article/details/51441590,学习整理。如果你觉得喜欢不妨点个赞,如果你觉得哪里有问题欢迎留言讨论。

    展开全文
  • Gson的基本介绍和使用

    万次阅读 2016-01-15 17:50:26
    JSON是我们在实际开发最常用的数据交换格式,GSON则是谷歌提供的用来解析Json数据的一个Java类库,在进行Gson介绍之前我们通过以下几个部分对Gson进行深入的了解。 一、JSON的简介 JSON(JavaScript Object Notation...
  • GSON下载

    2019-12-06 13:14:05
    http://repo1.maven.org/maven2/com/google/code/gson/gson/
  • Gson详解(二)

    2019-07-09 17:27:10
    1.复杂Json转成对象 比如:jsonString:{"response":{"content":"\n\t","msg":"成功","code":"0","data{"content":"\n\t","VIN":"LDC12345678901234"},"cmd":"ScanVINCode"}} ... Gson gson = new Gson(); ...
  • Gson各种版本下载

    千次阅读 2019-05-30 15:24:33
    http://repo1.maven.org/maven2/com/google/code/gson/gson/
  • Gson详解(一)

    千次阅读 2019-06-06 11:01:11
    一.Gson说明 Gson(又称Google Gson)是Google公司发布的一个开放源代码的Java库,主要用途为序列化Java对象为JSON字符串,或反序列化JSON字符串成Java对象。而JSON(JavaScript Object Notation) 是一种轻量级的...
  • Gson使用

    2018-12-04 16:52:01
    Gson使用 Java对象和Json之间的互转,一般用的比较多的两个类库是Jackson和Gson,下面记录一下Gson的学习使用。 基础概念:  Serialization:序列化,使Java对象到Json字符串的过程。  Deserialization:反序列...
  • Gson使用简单教程

    千次阅读 2017-01-10 14:56:59
    Gson gson = new Gson(); gson.toJson(1); // 转换后的JSON为1 gson.toJson("abcd"); // 转换后的JSON为"abcd" gson.toJson(new Long(10)); //转换后的JSON为10 gson.toJson(new int[]{1, 2
  • Android GSON使用

    千次阅读 2019-10-27 20:22:51
    Android GSON使用 使用场景及作用:Gson 是用来解析和生成Json,在实际项目中广泛使用。注意定义定对像的属性值必须和json中的保持一致,不然会解析失败。当然这就要求后台命名规范。 集成 dependencies { ...
  • Gson使用指南(一) 你真的会用Gson吗?Gson使用指南(二) 你真的会用Gson吗?Gson使用指南(三) 你真的会用Gson吗?Gson使用指南(四) 注:此系列基于Gson 2.4。本次的主要内容: 字段过滤的几种方法 基于@Expose...
  • gson 使用讲解

    2016-05-14 22:36:23
    学习就像烧水,断断续续烧是万万不可的,还需坚持不间断
  • 非常详细的json使用方法。包括对象和json之间的相互转换,集合和json之间的相互转换,自己按照节点解析。gson功能真的很强大。
  • 详解Gson使用(三)使用注解

    万次阅读 2016-05-12 19:17:14
    项目地址: Github:https://github.com/smileysx/GsonTest Oschina:https://git.oschina.net/ysx_xx/GsonText 详解Gson使用(一)简单对象转化 ... 详解Gson使用(二)带泛型
  • Android-Gson使用详解

    2017-10-08 00:20:28
    Gson解析默认使用方法很简单,将json转换成对象用Gson.fromJson(),将对象转化成json用Gson.toJson()即可。Gson解析解析数组和List也是用相同的方法。当解析List的时候,可能会遇到泛型操作。此时需要使用TypeToken...
  • Android Gson使用

    千次阅读 2019-06-28 23:45:56
    1.基本使用 GSON库主要就是可以将一段JSON格式的字符串自动映射成一个对象或者一个集合,从而不需要我们再手动去编写代码进行解析了。 不过需要添加相关依赖implementation 'com.google.code.gson:gson:2.8.2' {...
  • Gson使用指南

    2016-11-25 20:18:13
    原文出处:简书@怪盗kidou,http://www.jianshu.com/p/e740196225a4JSON (官网) 是一种文本形式的数据交换格式,它比XML更轻量、比二进制容易阅读和编写,调式也更加方便。其重要性不言而喻。...Gson使用指南(一
  • Android studio 中Gson使用实例

    千次阅读 2018-07-05 16:02:56
    step1:在工程的build.gradle中添加依赖库step2:使用Gson...1) 数组转json 字符串Gson g = new Gson(); String jsonString = g.toJson(labelInfo.boundingBox);2) json字符串转数组Gson gson = new Gson(); int [] ...
  • android Gson 使用的四种方式

    千次阅读 2017-07-31 08:37:36
    相对于较为传统的Json解析来说,google共享的开源Gson在解析速度和所使用的内存在有着明显的优势,虽然说阿里巴巴也提供了fastgson包,但是它跟Gson的处理速度大同小异,只是底层实现的原理不同,在这里就来学习一下...
  • Gson项目使用全解析

    千次阅读 2017-05-12 10:28:12
    Gson项目使用全解析 概述 json的解析jar包很多,有gson,fastjson,net.sf.json,org.json等等,做为开发人员只要了解一种或2种工具即可,人推荐gson和fastjson,因为gson稳定,容错率好,是goole出的,而且fastjson...
  • 使用Gson详解

    千次阅读 2015-01-26 10:12:41
    Gson gson=new Gson(); Person person=gson.fromJson(jsonData,Person.class); 解析json数组: 需要用到TypeToken将期望解析成的数据类型传入到fromJson()方法中: List people=gson.fromJson(jsonData,...
  • Android中Gson使用

    千次阅读 2014-11-18 11:38:38
    目前的客户端大都有和服务端进行交互,而数据的格式基本就是json了,于是在Android开发中就经常用到json解析,方便的是Google已经为我们提供了一个很棒的json解析库–gson,那么今天就来总结分享下gson的各种用法。...
  • gson使用

    千次阅读 2010-06-25 23:24:00
    json gson
  • Gson使用指南(一) JSON (官网) 是一种文本形式的数据交换格式,它比XML更轻量、比二进制容易阅读和编写,调式也更加方便。其重要性不言而喻。解析和生成的方式很多,Java中最常用的类库有:JSON-Java、Gson、...
  • 详解Gson使用(一)简单对象转化

    万次阅读 2016-05-12 19:16:35
    JSON是一种轻量级的数据交换格式。 易于人阅读和编写,同时也易于机器解析和生成(一般用于提升网络传输速率)。 在之前我写过一篇文章,《Android解析json数据》 ... 介绍了json和用JSONObject、JSONArray解析json数据...
  • Gson使用指南(一) 你真的会用Gson吗?Gson使用指南(二) 你真的会用Gson吗?Gson使用指南(三) 你真的会用Gson吗?Gson使用指南(四) 注:此系列基于Gson 2.4。上一篇文章 你真的会用Gson吗?Gson使用指南(一) ...
  • 【Gson】【2】Gson使用演示

    千次阅读 2013-12-16 16:58:19
    3、【原始类型演示】 ...Gson gson = new Gson(); gson.toJson(1); // 转换后的JSON为1 gson.toJson("abcd"); // 转换后的JSON为"abcd" gson.toJson(new Long(10)); //转换后的JSON为10 gson.toJ
  • 关于Gson的一些使用方法总结

    千次阅读 2018-07-09 16:55:42
    1. 基本使用方法[fromJson/toJson] 将字符串解析成相应的对象 or 将对象Json化 这个应该是最常用的吧 Gson gson = new Gson(); String result = gson.fromJson(&amp;amp;quot;str&amp;amp;quot;,String....

空空如也

1 2 3 4 5 ... 20
收藏数 71,984
精华内容 28,793
关键字:

gson