浅谈Android中的json解析

最新推荐文章于 2023-12-04 09:16:49 发布

粤语伶仃

最新推荐文章于 2023-12-04 09:16:49 发布

阅读量662

点赞数

CC 4.0 BY-SA版权

分类专栏： Android 文章标签： android json解析

本文链接：https://blog.youkuaiyun.com/monkey646812329/article/details/72179419

Android 专栏收录该内容

44 篇文章

订阅专栏

本文详细介绍JSON的基本语法及其在Android开发中的解析方法，包括原生解析、Gson库解析及JsonReader解析等，帮助开发者快速掌握JSON数据处理技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

引言

对于一个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，规则是：

JSON的大括号对应一个对象，对象里面有key和value(值)。在JavaBean里面的类属性要和key同名
JSON的方括号对应一个数组，所以在JavaBeanBean里面对应的也是数组，数据里面可以有值或者对象
如果数组里面只有值没有key，就说明它只是一个纯数组，如果里面有值有key，则说明是对象数组。纯数组对应JavaBean里面的数组类型，对象数组要在Bean里面建立一个内部类，类属性就是对应的对象里面的key，建立了之后要创建一个这个内部类的对象，名字对应数组名。
对象里面嵌套对象时候，也要建立一个内部类，和对象数组一样，这个内部类对象的名字就是父对象的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();
}