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());

Android之Gson解析


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



Android之Gson解析
提示
Gson使用方法
json序列化
json反序列化
源码下载
参考







提示

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 gson = new Gson();
        JMessage jMessage = gson.fromJson("JSON段", JMessage.class);
 jMessage.getMsg_id()//调用数据

GSON



JSON 介绍


Gson 下载


Gson 解析 和 格式化


Gson 格式化


Gson 解析




解析assets目录下的Json文件


## 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 相当于 树的节点.



## Gson 下载

网址 http://mvnrepository.com/artifact/com.google.code.gson/gson
选择版本，进入下载jar.

 Gson 格式化 和 解析
 Gson 格式化

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


实现步骤 :


获得需要的对象:
 Student stu = new Student();
 stu.setName("张三");
 stu.setAge(18);
 stu.setSex(true);



格式化
 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的取值:


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}}	

步骤 :


获得 解析者
 JsonParser parser = new JsonParser();



获得 根节点元素
 JsonElement element = parser.parse(json);



根据 文档判断根节点属于 什么类型的 Gson节点对象
 // 假如文档 显示 根节点 为对象类型
 // 获得 根节点 的实际 节点类型
 JsonObject root = element.getAsJsonObject();



取得 节点 下 的某个节点的 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();
    }

}