精华内容
参与话题
问答
  • gson解析

    2017-12-06 19:36:03
    gson解析json数组

    1解析一般json数据

    Gson gson = new Gson();
    TypeBean bean = gson.fromJson(str, TypeBean.class);
    2解析json数组

    Gson gson = new Gson();
    List<TypeBean> typeBean = gson.fromJson(str, new TypeToken<List<TypeBean>>() {}.getType());

    展开全文
  • Gson解析

    2016-08-20 16:07:42
    Android之Gson解析 Android之Gson解析 Gson使用方法 json序列化 json反序列化 源码下载 参考提示JSON的解析-JSONObject和JSONArray 请看: http://blog.csdn.net/Peng_Hong_fu/article/details/52252986 使用Gson前,...

    Android之Gson解析

    无意苦争春,一任群芳妒 – 陆游

    提示

    JSON的解析-JSONObject和JSONArray 请看: http://blog.csdn.net/Peng_Hong_fu/article/details/52252986
    使用Gson前,导入gson库和使用GsonFormat 请看: Android studio导入gson

    Gson的使用是依附一个Bean对象


    首先建立Person的一个Bean对象

    public class Person {
        private String name;
        private int age;
    
        @Override
        public String toString() {
            return "Person{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
        ........Setter and Getter......
    }

    Gson使用方法

    json序列化

    添加json数据,将bean里面的内容转换为json内容

    • json序列化1
      /**
       *加入的数据是{"name":"peng","age":"19"}
       *一个对象
       */
        Person p =new Person();
        p.setName("peng");
        p.setAge(19);
    
        Gson gson =new Gson();
        System.out.println(gson.toJson(p));

    • json序列化2
      /**
       *加入的数据是[{"name":"peng","age":"19"},
       *           {"name":"peng","age":"19"}]
       * 数组里包含两个对象
       */
        List<Person> list =new ArrayList<>();
        Person p =new Person();
        p.setName("peng");
        p.setAge(19);
    
        Person q =new Person();
        q.setName("jack");
        q.setAge(20);
    
        list.add(p);
        list.add(q);
        Gson gson =new Gson();
        System.out.println(gson.toJson(list));

    • json序列化3

    这次添加的是一个复杂的json数据,包括数组和对象的组合
    这需要一个新的bean类
    使用Android studio的GsonFormat 功能可以快速的生成以下的BaoBao类
    具体方法在上方的提示给出

    public class BaoBao {
        private String name;
        private String age;
        private List<OtherBean> other;
    
       ....Getter and Setter....
    
        public static class OtherBean {
            private String name;
            private String age;
            private String id;
    
            ....Getter and Setter....
        }
    }
           /*添加的数据是 {"name":"宝强","age":"32",
                         "other":[{"name":"小马","age":"22","id":"1"},
                             {"name":"小蓉","age":"32","id":"2"},
                             {"name":"小王","age":"42","id":"3"}]}
            */
            BaoBao b =new BaoBao();
            b.setName("宝强");
            b.setAge("32");
    
            List<BaoBao.OtherBean> list =new ArrayList<>();
            /**
             * 如果你重写了OtherBean的构造函数
             * 你也可以这样加数据
             * BaoBao.OtherBean ob= new BaoBao.OtherBean("小马","22","1");
             */
            BaoBao.OtherBean ob= new BaoBao.OtherBean();
            ob.setName("小马");
            ob.setAge("22");
            ob.setId("1");
    
            BaoBao.OtherBean ob1= new BaoBao.OtherBean();
            ob1.setName("小荣");
            ob1.setAge("32");
            ob1.setId("2");
    
            BaoBao.OtherBean ob2= new BaoBao.OtherBean();
            ob2.setName("小王");
            ob2.setAge("42");
            ob2.setId("3");
    
            list.add(ob);
            list.add(ob1);
            list.add(ob2);
    
            b.setOther(list);
    
            Gson gson = new Gson();
            System.out.println(gson.toJson(b));

    添加结果
    添加结果

    json反序列化

    json解析 ,从Json对象封装出一个一个的bean对象

    • 解析1
     解析 {'name':'peng','age':'12'}
      String str = "{'name':'zhangsan','age':'12'}";
        Person person =new Person();
        Gson gson =new Gson();
    
        /*person =gson.fromJson("{name:'zhangsan'}",Person.class);*/
        person =gson.fromJson(str,Person.class);
        System.out.println(person.getName()+"  " + person.getAge());

    解析结果
    解析一


    • 解析2
     二.解析 [{'name':'peng','age':'23'},{'name':'jack','age':'22'}]
    String jsonData = "[{'name':'peng','age':'23'},{'name':'jack','age':'22'}]";
        Gson gson = new Gson();
        Type listType  = new TypeToken<List<Person>>(){}.getType();
        List<Person> list =gson.fromJson(jsonData ,listType);
        //use List or LinkList
        for(Person p:list) {
         System.out.println(p.getName()+" "+p.getAge());
         }
    /**
    *下面解析的方法和上面的方法有同样的效果
    */
       String jsonData = "[{\"name\":\"baoqiang\",\"age\":23},{\"name\":\"sunyang\",\"age\":34}]";
            Type listType = new TypeToken<LinkedList<Person>>(){}.getType();
            Gson gson = new Gson();
            LinkedList<Person> linklist = gson.fromJson(jsonData, listType);
            for (Iterator iterator = linklist.iterator(); iterator.hasNext();) {
                Person person = (Person) iterator.next();
                System.out.println(person.getName());
                System.out.println(person.getAge());
            }

    解析结果
    解析二


    • 解析3
      这里解析一个复杂的json数据,包括数组和对象的组合
    {"name":"宝强","age":"32",
    "other":[{"name":"小马","age":"22","id":"1"},
       {"name":"小蓉","age":"32","id":"2"},
       {"name":"小王","age":"42","id":"3"}]
    }

    解析代码

                String str = "{\"name\":\"宝强\",\"age\":\"32\",\n" +
                        "\"other\":[{\"name\":\"小马\",\"age\":\"22\",\"id\":\"1\"},\n" +
                        "   {\"name\":\"小蓉\",\"age\":\"32\",\"id\":\"2\"},\n" +
                        "   {\"name\":\"小王\",\"age\":\"42\",\"id\":\"3\"}]\n" +
                        "}";
                Gson gson = new Gson();
                BaoBao js = gson.fromJson(str, BaoBao.class);
                System.out.println("name:" + js.getName() + " age:" + js.getAge());
                List<BaoBao.OtherBean> list = js.getOther();
                for (BaoBao.OtherBean ob : list){
                    System.out.println("name:"+ob.getName() + " id:" + ob.getId() + " age:" + ob.getAge());
                }

    2016年8月29号更新内容
    直接通过GsonFormat生成的bean对象提取

    Gson gson = new Gson();
    BaoBao js = gson.fromJson(str, BaoBao.class);
    //因为定义了bean对象,可以直接通过下面的方法提取,get(0)为第一个数组
    System.out.println(js.getOther().get(0).getName()+js.getOther().get(0).getAge());
    //取出的结果为 小马 22

    解析结果
    解析三

    源码下载

    GitHub地址:https://github.com/PengHongfu/Gson.git

    参考

    android Gson的使用 http://blog.csdn.net/kongzhichen/article/details/10135051
    Android Gson解析json详解 http://www.open-open.com/lib/view/open1407376535942.html

    展开全文
  • GSON解析

    2020-08-28 17:46:08
    Gson gson = new Gson(); JMessage jMessage = gson.fromJson("JSON段", JMessage.class); jMessage.getMsg_id()//调用数据
            Gson gson = new Gson();
            JMessage jMessage = gson.fromJson("JSON段", JMessage.class);
     jMessage.getMsg_id()//调用数据
    
    展开全文
  • gson解析工具类

    2017-03-02 20:27:46
    gson解析工具类
  • Gson解析嵌套json

    2016-07-28 17:03:02
    Gson解析嵌套json
  • JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,易于阅读和编写,同时也易于机器解析和生成。接下来通过本文给大家介绍JAVA使用Gson解析json数据实例解析,需要的朋友参考下吧
  • GSON 解析 JSON

    2018-11-02 15:14:39
    Gson 解析 和 格式化 Gson 格式化 Gson 解析 解析assets目录下的Json文件 ## Json 介绍 Json 全称 JavaScript Object Natation ,用来描述数据结构,它是基于纯文本的数据格式,是一种轻量级的数据交换...

    GSON


    ## Json 介绍

    Json 全称 JavaScript Object Natation ,用来描述数据结构,它是基于纯文本的数据格式,是一种轻量级的数据交换格式。广泛应用于 服务端 与 客户端 的数据交互。

    • 格式

      Json 以 key-value的形式存储数据;

      Key的取值 为 String 类型;

      Value的取值 为 String,boolean,Number,数组,Object,null;

      Json 串 以 { 开始, 以 } 结尾;

      Json 串中 数组 是 以 [ 开始, 以 ] 结尾;

      Json 串中 Object 是 以 { 开始, 以 } 结尾;

    • 案例

      基本类型 :

        {
            "name": "张三",
            "age": 18,
            "sex": true
        }
      

      数组类型 :

        [               
        		{
                    "name": "张三",
                    "age": 18,
                    "sex": true
                },
                {
                    "name": "李四",
                    "age": 19,
                    "sex": false
                }
        ]
      

      对象嵌套 :

        {
            "name": "teacher",
            "computer": {
                "CPU": "intel7",
                "disk": "512G"
            },
            "students": [
                {
                    "name": "张三",
                    "age": 18,
                    "sex": true
                },
                {
                    "name": "李四",
                    "age": 19,
                    "sex": false
                }
            ]
        }
      
    • 树状结构

      json 字符串相当于一个倒挂的树, key 相当于 树的节点.

    json树状结构

    ## Gson 下载

    Gson 格式化 和 解析

    Gson 格式化


    将 java 对象 格式化为 Json 字符串.

    • 实现步骤 :

      1. 获得需要的对象:

         Student stu = new Student();
         stu.setName("张三");
         stu.setAge(18);
         stu.setSex(true);
        
      2. 格式化

         Gson gson = new Gson();
         //将 对象 转化成 json 字符串
         String json = gson.toJson(stu)
        

    Gson 解析


    将 Json 字符串 解析 成 java 对象.

    • Gson 的 节点对象:

      JsonElement : 所有的节点 都是 JsonElement 对象.

      JsonPrimitive : 基本的 数据类型的 节点 对象, JsonElement 的子类.

      JsonNull : 代表 空节点 对象,即 有 key,value 为空,JsonElement 的子类.

      JsonObject : 对象 数据类型的 节点 对象, JsonElement 的 子类.

      JsonArray : 数组 数据类型的 节点 对象, JsonElement 的 子类.

    • JsonElement的取值:

      1. JsonPrimitive : value 的 取值对应 java

    int,double,float,long,short,boolean,char,byte,String,BigDecimal,BigInteger,Number
    ```
    2. JsonObject : value 的 取值对应 java 的 Object 对象.

    3. `JsonArray` : value 的 取值对应 java 的 List 及其子类对象.
    
    • Json的解析成 java 对象

      json:

        {'name':'张三','age':18,'sex':true}	
      

      代码:

        Gson gson = new Gson();
        // 将json 转化成 java 对象
        Student stu = gson.fromJson(json, Student.class);
      
    • Json 解析 成 List

      json:

        [{'name':'小1','age':18,'sex':true},{'name':'小2','age':19,'sex':false},{'name':'小3','age':20,'sex':true},{'name':'小4','age':21,'sex':false},{'name':'小5','age':22,'sex':true}]
      

      代码:

        Gson gson = new Gson();
        // 将 json 转化 成 List泛型
        List<Student> stus = gson.fromJson(json, new TypeToken<List<Student>>() {}.getType());
      
    • Json 解析 成 map

      json:

        {'小3':{'name':'小3','age':20,'sex':true},'小4':{'name':'小4','age':21,'sex':false},'小5':{'name':'小5','age':22,'sex':true},'小1':{'name':'小1','age':18,'sex':true},'小2':{'name':'小2','age':19,'sex':false}}
      

      代码:

        Gson gson = new Gson();
        // 将 json 转化 成 Map泛型
        Map<String,Student> map = gson.fromJson(json, new TypeToken<Map<String,Student>>() {}.getType());
      
    • Json 节点 的解析

      json:

        {'flag':true,'data':{'name':'张三','age':18,'sex':true}}	
      

      步骤 :

      1. 获得 解析者

         JsonParser parser = new JsonParser();
        
      2. 获得 根节点元素

         JsonElement element = parser.parse(json);
        
      3. 根据 文档判断根节点属于 什么类型的 Gson节点对象

         // 假如文档 显示 根节点 为对象类型
         // 获得 根节点 的实际 节点类型
         JsonObject root = element.getAsJsonObject();
        
      4. 取得 节点 下 的某个节点的 value

         // 获得 flag 节点的值, flag 节点为基本数据节点
         JsonPrimitive flagJson = root.getAsJsonPrimitive("flag");
         // 基本节点取值
         boolean flag = flagJson.getAsBoolean();
        
         // 获得 data 节点的值,data 节点为Object数据节点
         JsonObject dataJson = root.getAsJsonObject("data");
         // 将节点上的数据转换为对象
         Student stu = new Gson().fromJson(dataJson,Student.class);
        

    完整代码

     public static void main(String[] args) {
    		// json 节点解析
    		String json = "{'flag':true,'data':{'name':'张三','age':18,'sex':true}}";
    		
    		// 1.获得 解析者
    		JsonParser parser = new JsonParser();
    
    		// 2.获得 根节点元素
    		JsonElement element = parser.parse(json);
    
    		// 3.根据 文档判断根节点属于 什么类型的 Gson节点对象
    		JsonObject root = element.getAsJsonObject();
    
    		// 4. 取得 节点 下 的某个节点的 value
    		JsonPrimitive flagJson = root.getAsJsonPrimitive("flag");
    		boolean flag = flagJson.getAsBoolean();
    
    		JsonObject dataJson = root.getAsJsonObject("data");
    		Student student = new Gson().fromJson(dataJson, Student.class);
    
    		System.out.println(flag);
    		System.out.println(student);
    
    	}
    

    ## 解析assets目录下的Json文件

    /**
     * 解析assets目录下的json文件并存入String[]数组中
     */
    private List<City> parseJson2List() {
        StringBuilder stringBuilder = new StringBuilder();
        try {
            AssetManager manager = getAssets();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(manager.open("citys.json")));
            String line = "";
            while ((line = bufferedReader.readLine())!=null) {
                stringBuilder.append(line);
            }
    
            //得到json的字符串
            String json = stringBuilder.toString();
            //解析json
            Gson gson = new Gson();
            TypeToken<List<City>> typeToken = new TypeToken<List<City>>() {};
            List<City> cityList = gson.fromJson(json,typeToken.getType());
            //返回city列表
            return cityList ;
    
    
        } catch (IOException e) {
            e.printStackTrace();
        }
    
    }
    
    展开全文
  • gson 解析jsonWelcome to Gson Example Tutorial. In last post we looked at the Java JSON API and you can easily tell that it’s not convenient to use it. Whether you have to convert JSON to Java Object ...
  • Gson Gson is a Java library that can be used to convert Java Objects into their JSON representation. It can also be used to convert a JSON string to an equivalent Java object. Gson can work with ...

空空如也

1 2 3 4 5 ... 20
收藏数 6,804
精华内容 2,721
关键字:

gson解析