浅谈Android中的json解析

引言

对于一个App开发的Android 开发者而言，json解析算是家常便饭吧，json可以说整个app的地基，时刻都在支撑着我们的app的各种交互。那么，json在Android应用中到底是什么，扮演着怎么样的角色，下面就跟着我一起去揭开json的神秘面纱吧。

一，json是神马东东

json其实就是一种轻量级的文本数据交换格式，是JavaScript Object Notation，JavaScript的对象表示法。是用于数据的标记、存储和传输。
json的值可以是

• 数字（整数或者浮点数）
• 字符串（在双引号内）
• 逻辑值(true 或 false)
• 数组(使用方括号[]包围)
• 对象( 使用花括号{}包围)
• null
  那么我们来看看json具体是怎么个表示法的：
  先看看个实例：

｛"skill":{          "web":[                 {                  "name":"html",                  "year":"5"                 },                 {                  "name":"ht",                  "year":"4"                 }],           "database":[                  {                  "name":"h",                  "year":"2"                 }]`}}

从上面的数据结构中，不难看出json其实就有如下几种形式：
(1)“名称／值”对
无序、一个对象用“｛｝”包括，名称和值间用“：”相隔，对象间用“，”隔开；
eg:

"name":"html"

(2)对象
一个JSON对象包括多个名称/值对，在花括号里书写
eg:

{ "name":"html","year":"5"}

(3)数组
数组以“［］”包括，数据的对象用逗号隔开
eg:

              [{                "name":"html",                "year":"5"               },               {                "name":"ht",                "year":"4"               }]

其实就是
数组 [ 对象 { 值/对”” } ]
数组包含对象，对象包含值/对
小结：
JSON中有且只有两种结构：对象和数组。
1、对象：对象在js中表示为“{}”括起来的内容，数据结构为 {key：value,key：value,…}的键值对的结构，在面向对象的语言中，key为对象的属性，value为对应的属性值，所以很容易理解，取值方法为 对象.key 获取属性值，这个属性值的类型可以是 数字、字符串、数组、对象几种。

2、数组：数组在js中是中括号“[]”括起来的内容，数据结构为 [“java”,”javascript”,”vb”,…]，取值方式和所有语言中一样，使用索引获取，字段值的类型可以是 数字、字符串、数组、对象几种。
好了，以上就是json的一些基本语法介绍，那么接下来就进入到我们的重点，json数据的解析。

json解析

我们知道json中就两种结构array和object，因此就有这个两个类进行解析。
我们用例子来说明怎么个解析法：
eg:

1.{"name":"sam","age":18,"weight":60} //json1 一个json对象2.[12,13,15]                    //json2 一个数字数组3.[{"name":"sam","age":18},{"name":"leo","age":19},{"name":"sky", "age":20}] //json3 json array中有object

我们先来说说第一个json数据如何解析：
（1）json对象的解析

1.JSONObject jsonObj = new JSONObject(json1);2.String name = jsonObj.optString("name");3.int age = jsonObj.optInt("age");4.int weight = jsonObj.optInt("weight");

从上面你是否注意到了一个方法：opt类型
其实除了上面的，还有几个比较常见的：

1.Object opt（String name）2.boolean optBoolean(String name)3.double optDouble(String name)4.JSONArray optJSONArray(String name)5.JSONObject optJSONObject(String name)

这些方法在解析时，如果对应字段不存在会返回空值或者0，不会报错，因为系统已经对null进行了处理。当然除了上面这种方法，还可以用这些方法：

1.Object get(String name)2.boolean getBoolean(String name)3.int getInt(String name)

但这些方法需要我们自己判null，不然字段不存在时会崩溃，因为代码不会去判断是否存在该字段，需要你自己去判断，否则的话会报错。自己判断的话使用has(String name)来判断。

（2）json数组的解析
看看我们上面例子中第二个json数据怎么解析

1.JSONArray jsonArray = new JSONArray(json2);2.for (int = 0; i < jsonArray.length();i++) {    int age = jsonArray.optInt(i); }

从上面可以看到数组的话解析方法和对象差不多，只是将键值替换为在数组中的下标。另外也是有optXXX（int index）和getXXX（int index）方法的，opt也是安全的，即对应index无值的时候，不会报错，返回空，推荐使用。

(3)json对象跟json数组混合在一起的解析
我们再来看看例子中第三个json数据该如何去解析

1.JSONArray jsonArray = new JSONArray(json3);for (int = 0; i < jsonArray.length();i++) {  2.  JSONObject jsonObject = jsonArray.optJSONObject(i);    String name = jsonObject.optString("name");    int age = jsonObject.optInt("age");}

用上面的解析我们可以看出来，其实就是一层一层去解析，一个节点一个节点的去解析，先解析最外层的数组，然后再一层一层去解析里面对应的json对象。

Gson解析

接下来我们介绍一种流弊的解析方法，Gson解析

Gson是google的开源解析库，它的解析方式就是：基于事件驱动，根据所需要取的数据通过建立一个对应于JSON数据的JavaBean类就可以通过简单的操作解析出所需JSON数据

gson解析的步骤：
(1)创建一个与JSON数据对应的JavaBean类（用作存储需要解析的数据）
GSON解析的关键是重点是要根据json数据里面的结构写出一个对应的javaBean，规则是：

1. JSON的大括号对应一个对象，对象里面有key和value(值)。在JavaBean里面的类属性要和key同名
2. JSON的方括号对应一个数组，所以在JavaBeanBean里面对应的也是数组，数据里面可以有值或者对象
3. 如果数组里面只有值没有key，就说明它只是一个纯数组，如果里面有值有key，则说明是对象数组。纯数组对应JavaBean里面的数组类型，对象数组要在Bean里面建立一个内部类，类属性就是对应的对象里面的key，建立了之后要创建一个这个内部类的对象，名字对应数组名。
4. 对象里面嵌套对象时候，也要建立一个内部类，和对象数组一样，这个内部类对象的名字就是父对象的key
   注意：JavaBean类里的属性不一定要全部和JSON数据里的所有key相同，可以按需取数据，也就是你想要哪种数据，就把对应的key属性写出来，注意名字一定要对应‘
   下面我们举例子来看看这个JavaBean要怎么处理：
   1.简单的JSON数据1（对象）
   eg：

String json = "{"id":1,"name":"小明","sex":"男","age":18,"height":175}";

步骤1：创建简单的JSON数据对应的JavaBean类

public class EntityStudent {    private int id;    private String name;    private String sex;    private int age;    private int height;    public void setId(int id){        this.id = id;    }    public void setName(String name){        this.name = name;    }    public void setSex(String sex){        this.sex = sex;    }    public void setAge(int age){        this.age = age;    }    public void setHeight(int height){        this.height = height;    }    public int getId(){        return id;    }    public String getName(){        return name;    }    public String getSex(){        return sex;    }    public int getAge(){        return age;    }    public int getHeight(){        return  height;    }    public void show(){         Log.d("wu","id=" + id + ","+"name=" + name+","+"sex="             + sex+","+"age=" + age+","+"height=" + height)    }}

2,复杂的JSON数据（具备嵌套）
eg:

{"translation":["车"],  "basic":    {      "phonetic":"kɑː",      "explains":["n. 汽车；车厢","n. (Car)人名；(土)贾尔；(法、西)卡尔；(塞)察尔"]},  "query":"car",  "errorCode":0,  "web":[{"value":["汽车","车子","小汽车"],"key":"Car"},         {"value":["概念车","概念车","概念汽车"],"key":"concept car"},         {"value":["碰碰车","碰撞用汽车","碰碰汽车"],"key":"bumper car"}]}

步骤1：复杂的JSON数据对应的JavaBean类

public class student {    public String[] translation;      //["车"]数组    public basic basic;                //basic对象里面嵌套着对象，创建一个basic内部类对象    public  static class basic{        //建立内部类        public String phonetic;        public String[] explains;    }    public String query;    public int errorCode;    public List<wb> web;            //web是一个对象数组，创建一个                 //web内部类对象    public static class wb{                        public String[] value;            public String key;        }    public void show(){        //输出数组        for (int i = 0;i<translation.length;i++)        {        System.out.println(translation[i]);        }        //输出内部类对象        System.out.println(basic.phonetic);        //输出内部类数组        for (int i = 0;i<basic.explains.length;i++){            System.out.println(basic.explains[i]);        }        System.out.println(query);        System.out.println(errorCode);        for (int i = 0;i<web.size();i++){            for(int j = 0; j<web.get(i).value.length;j++)            {                System.out.println(web.get(i).value[j]);            }            System.out.println(web.get(i).key);        }    }    }

是不是觉得根据JSON文本数据去转换成JavaBean实体类很复杂呢？其实还有个简单的方法，JSON字符串转Java实体类

步骤2：下载并导入GSON需要的库
Gson库

步骤3：用Gson进行转换

public class MainActivity extends AppCompatActivity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        Gson gson = new Gson();        //创建JavaBean类的对象      Student student = new EntityStudent();        String json = "{\"id\":1,\"name\":\"小明\",\"sex\":\"男\",\"age\":18,\"height\":175}";       //用GSON方法将JSON数据转为单个类实体        student = gson.fromJson(json,Student.class);       //调用student方法展示解析的数据        student.show();      //将Java集合转换为json        String json2 = gson.toJson(List);        System.out.println(json2);    }}

小结：
利用GSON方法进行解析，关键在于根据json数据里面的结构写出一个对应的javaBean，而解析过程非常简单：

JavaBean对象 = gson.fromJson(son,javaBean类类名.class);

3.基于本地json数据的文档解析

基于文档驱动，类似于XML的DOM解析方法，先把全部文件读入到内存中，然后遍历所有数据，然后根据需要检索想要的数据。
例如：需要解析的JSON数据

{"student":[               {"id":1,"name":"小明","sex":"男","age":18,"height":175},              {"id":2,"name":"小红","sex":"女","age":19,"height":165},               {"id":3,"name":"小强","sex":"男","age":20,"height":185}            ],"cat":"it"}

读入本地assets文件夹里面的student.son并解析

public class MainActivity extends AppCompatActivity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        EntityStudent student = new EntityStudent();        try {            //从assets获取json文件            InputStreamReader isr = new InputStreamReader(this.getClass().getClassLoader().getResourceAsStream("assets/" + "student.json"));            //字节流转字符流           BufferedReader bfr = new BufferedReader(isr);            String line ;            StringBuilder stringBuilder = new StringBuilder();            while ((line = bfr.readLine())!=null){                stringBuilder.append(line);            }//将JSON数据转化为字符串            JSONObject root = new JSONObject(stringBuilder.toString());            //根据键名获取键值信息            System.out.println("root:"+root.getString("cat"));            JSONArray array = root.getJSONArray("student");            for (int i = 0;i < array.length();i++)            {                JSONObject stud = array.getJSONObject(i);                System.out.println("------------------");                System.out.print("id="+stud.getInt("id")+ ","));                System.out.print("name="+stud.getString("name")+ ","));                System.out.print("sex="+stud.getString("sex")+ ","));                System.out.print("age="+stud.getInt("age")+ ","));                System.out.println("height="+stud.getInt("height")+ ","));                bfr.close();                    isr.close();                is.close();//依次关闭流            }        } catch (IOException e) {            e.printStackTrace();        } catch (JSONException e) {            e.printStackTrace();        }    }}

上面就说清了主流的一些解析，可以看到使用Gson之后解析是十分简单，这可以为我们的开发节约很多的时间。同时呢android本身为我们提供的也挺够用的，并且3.0后增加的JsonReader操作更加流畅，和其他如Pull解析xml的方式有些类似。

JsonReader的解析方式

JsonReader的使用其实和xml解析中的pull是有一点类似的，我们来看示例。
前面的JSONObject和JSONArray创建时传的是String，而JsonReader需要传入的时候是Reader，网络访问中，我们可以直接拿输入流传进来，转成Reader。我们这里假设我们上面的String已经转成InputStream了，分别为jsonIs1，jsonIs2,jsonIs3。
上面的json1解析：

JsonReader reader = new JsonReader(new InputStreamReader(jsonIs1));try {积分：49排名：第1495693名上传资源：1    reader.beginObject();    while (reader.hasNext()) {        String keyName = reader.nextName();        if (keyName.equals("name")) {             String name = reader.nextString();        } else if (keyName.equals("age")) {            int age = reader.nextInt();        } else if (keyName.equals("weight")) {            int weight = reader.nextInt();        }    }    reader.endObject();} finally {    reader.close();}

上面json2的解析:

JsonReader reader = new JsonReader(new InputStreamReader(jsonIs2));try {    List<Integer> ages = new ArrayList<Integer>();    reader.beginArray();    while (reader.hasNext()) {        ages.add(reader.nextInt());    }    reader.endArray();} finally {    reader.close();}