JSONObject生成JSON，JSON解析，JSON学习

1、什么是JSON？

JSON是一种取代XML的数据结构,和xml相比,它更小巧但描述能力却不差,由于它的小巧所以网络传输数据将减少更多流量从而加快速度。

JSON就是一串字符串只不过元素会使用特定的符号标注。

{} 双括号表示对象

[] 中括号表示数组

"" 双引号内是属性或值

: 冒号表示后者是前者的值(这个值可以是字符串、数字、也可以是另一个数组或对象)

所以 {"name": "Michael"} 可以理解为是一个包含name为Michael的对象

而[{"name": "Michael"},{"name": "Jerry"}]就表示包含两个对象的数组

当然了,你也可以使用{"name":["Michael","Jerry"]}来简化上面一部,这是一个拥有一个name数组的对象

1. 2 json数据类型

类型	描述
Number	数字型
String	字符串型
Boolean	布尔型
Array	数组
Object	对象
null	空值

（1）json中不区分整数、小数等类型，而统一使用Number来存储数字。

（2）Array表示数组，以中括号"[]"括起来，元素之间以逗号分隔，元素可以为任意类型。

（3）Object表示对象，类似于C语言中的结构体，以花括号"{}"括起来，其元素要求为键值对，key必须为String类型的，而value则可为任意类型。key和value之间以":"表示映射关系，元素之间也是以逗号分隔。

2. 构建json

在eclipse中使用JSONObject需要引用org.json包，推荐通过maven引用，如果不会使用maven，搭建maven项目可参考这篇文章《使用Eclipse构建Maven项目 (step-by-step)》，引用json则参考这篇文章《maven引入json各种版本》。

温馨提示：我在构建maven项目的时候屡屡创建失败，在网上查了很久还是搞不定，后来科学上网就搞定了，如果你也创建失败，可以尝试一下。

如果是在Android Studio中，则可以直接使用。

2.1 直接构建

JSONObject obj = new JSONObject();
obj.put(key, value);

直接构建即直接实例化一个JSONObject对象，而后调用其put()方法，将数据写入。put()方法的第一个参数为key值，必须为String类型，第二个参数为value，可以为boolean、double、int、long、Object、Map以及Collection等。当然，double以及int等类型只是在Java中，写入到json中时，统一都会以Number类型存储。

范例：

import org.json.JSONObject;

public class JSONObjectSample {

    public static void main(String[] args) {
        createJson();
    }

    private static void createJson() {
        JSONObject obj = new JSONObject();
        obj.put("name", "John");
        obj.put("sex", "male");
        obj.put("age", 22);
        obj.put("is_student", true);
        obj.put("hobbies", new String[] {"hiking", "swimming"});
        //调用toString()方法可直接将其内容打印出来
        System.out.println(obj.toString());
    }

}

输出结果为：

{"hobbies":["hiking","swimming"],"sex":"male","name":"John","is_student":true,"age":22}

这里可以看到，为了压缩大小以便于更高效地传输，json把所有空格、换行符等空白符全部去掉了。如果想要直观点看其内容，可以用一些在线的json解析器看，例如：http://www.jsoneditoronline.org/

2.2 使用HashMap构建

使用HashMap构建json，实际上即先创建好一个HashMap对象并且将数据打包进去，而后在创建JSONObject时将其作为一个参数传进去。

范例：

 1 public class JSONObjectSample {
 2 
 3     public static void main(String[] args) {
 4         createJsonByMap();
 5     }
 6 
 7     private static void createJsonByMap() {
 8         Map<String, Object> data = new HashMap<String, Object>();
 9         data.put("name", "John");
10         data.put("sex", "male");
11         data.put("age", 22);
12         data.put("is_student", true);
13         data.put("hobbies", new String[] {"hiking", "swimming"});
14         
15         JSONObject obj = new JSONObject(data);
16         System.out.println(obj.toString());
17     }
18 
19 }

2.3 使用JavaBean构建

相较于前两种方法，实际开发中应用JavaBean构建json的情况更为常见，因为这样代码的重用率更高。

范例：

JavaBean：

 1 public class PersonInfo {
 2 
 3     private String name;
 4     private String sex;
 5     private int age;
 6     private boolean isStudent;
 7     private String[] hobbies;
 8     
 9     public void setName(String name) {
10         this.name = name;
11     }
12     public void setSex(String sex) {
13         this.sex = sex;
14     }
15     public void setAge(int age) {
16         this.age = age;
17     }
18     public void setStudent(boolean isStudent) {
19         this.isStudent = isStudent;
20     }
21     public void setHobbies(String[] hobbies) {
22         this.hobbies = hobbies;
23     }
24         //getter不能少
25     public String getName() {
26         return name;
27     }
28     public String getSex() {
29         return sex;
30     }
31     public int getAge() {
32         return age;
33     }
34     public boolean isStudent() {
35         return isStudent;
36     }
37     public String[] getHobbies() {
38         return hobbies;
39     }
40 }
41 main：
42 
43 import org.json.JSONObject;
44 
45 public class JSONObjectSample {
46 
47     public static void main(String[] args) {
48         createJsonByJavaBean();
49     }
50 
51     private static void createJsonByJavaBean() {
52         PersonInfo info = new PersonInfo();
53         info.setName("John");
54         info.setSex("male");
55         info.setAge(22);
56         info.setStudent(true);
57         info.setHobbies(new String[] {"hiking", "swimming"});
58         
59         JSONObject obj = new JSONObject(info);
60         System.out.println(obj);
61     }
62 
63 }

需要注意一点，JavaBean一定要有getter方法，否则会无法访问存储的数据。

3. 解析json

解析json主要是基本类型如Number、boolean等，与数组Array。

基本类型的解析直接调用JSONObject对象的getXxx(key)方法，如果获取字符串则getString(key)，布尔值则getBoolean(key)，以此类推。

数组的解析稍微麻烦一点，需要通过JSONObject对象的getJSONArray(key)方法获取到一个JSONArray对象，再调用JSONArray对象的get(i)方法获取数组元素，i为索引值。

分为以下三种情况，一个JavaBean，一个List数组，一个嵌套Map的List数组：

 1 import java.util.ArrayList;
 2 import java.util.HashMap;
 3 import java.util.Iterator;
 4 import java.util.List;
 5 import java.util.Map;
 6 
 7 import org.json.JSONArray;
 8 import org.json.JSONObject;
 9 
10 import com.android.myjson.domain.Person;
11 
12 /**
13  * 完成对json数据的解析
14  * 
15  */
16 public class JsonTools {
17 
18 
19     public static Person getPerson(String key, String jsonString) {
20         Person person = new Person();
21         try {
22             JSONObject jsonObject = new JSONObject(jsonString);
23             JSONObject personObject = jsonObject.getJSONObject("person");
24             person.setId(personObject.getInt("id"));
25             person.setName(personObject.getString("name"));
26             person.setAddress(personObject.getString("address"));
27         } catch (Exception e) {
28             // TODO: handle exception
29         }
30         return person;
31     }
32 
33     public static List getPersons(String key, String jsonString) {
34         List list = new ArrayList();
35         try {
36             JSONObject jsonObject = new JSONObject(jsonString);
37             // 返回json的数组
38             JSONArray jsonArray = jsonObject.getJSONArray(key);
39             for (int i = 0; i < jsonArray.length(); i++) {
40                 JSONObject jsonObject2 = jsonArray.getJSONObject(i);
41                 Person person = new Person();
42                 person.setId(jsonObject2.getInt("id"));
43                 person.setName(jsonObject2.getString("name"));
44                 person.setAddress(jsonObject2.getString("address"));
45                 list.add(person);
46             }
47         } catch (Exception e) {
48             // TODO: handle exception
49         }
50         return list;
51     }
52 
53     public static List getList(String key, String jsonString) {
54         List list = new ArrayList();
55         try {
56             JSONObject jsonObject = new JSONObject(jsonString);
57             JSONArray jsonArray = jsonObject.getJSONArray(key);
58             for (int i = 0; i < jsonArray.length(); i++) {
59                 String msg = jsonArray.getString(i);
60                 list.add(msg);
61             }
62         } catch (Exception e) {
63             // TODO: handle exception
64         }
65         return list;
66     }
67 
68     public static List> listKeyMaps(String key,
69             String jsonString) {
70         List> list = new ArrayList>();
71         try {
72             JSONObject jsonObject = new JSONObject(jsonString);
73             JSONArray jsonArray = jsonObject.getJSONArray(key);
74             for (int i = 0; i < jsonArray.length(); i++) {
75                 JSONObject jsonObject2 = jsonArray.getJSONObject(i);
76                 Map map = new HashMap();
77                 Iterator iterator = jsonObject2.keys();
78                 while (iterator.hasNext()) {
79                     String json_key = iterator.next();
80                     Object json_value = jsonObject2.get(json_key);
81                     if (json_value == null) {
82                         json_value = "";
83                     }
84                     map.put(json_key, json_value);
85                 }
86                 list.add(map);
87             }
88         } catch (Exception e) {
89             // TODO: handle exception
90         }
91         return list;
92     }
93 }

3.2 JSON解析之GSON

//1、生成JSON字符串
import com.google.gson.Gson;

public class JsonUtils {

    public static String createJsonObject(Object obj) {
        Gson gson = new Gson();
        String str = gson.toJson(obj);
        return str;

    }
}
//二、解析JSON

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

;
public class GsonTools {

    public GsonTools() {
        // TODO Auto-generated constructor stub
    }

    /**
     * @param 
     * @param jsonString
     * @param cls
     * @return
     */
    public static  T getPerson(String jsonString, Class cls) {
        T t = null;
        try {
            Gson gson = new Gson();
            t = gson.fromJson(jsonString, cls);
        } catch (Exception e) {
            // TODO: handle exception
        }
        return t;
    }

    /**
     * 使用Gson进行解析 List
     * 
     * @param 
     * @param jsonString
     * @param cls
     * @return
     */
    public static  List getPersons(String jsonString, Class cls) {
        List list = new ArrayList();
        try {
            Gson gson = new Gson();
            list = gson.fromJson(jsonString, new TypeToken>() {
            }.getType());
        } catch (Exception e) {
        }
        return list;
    }

    /**
     * @param jsonString
     * @return
     */
    public static List getList(String jsonString) {
        List list = new ArrayList();
        try {
            Gson gson = new Gson();
            list = gson.fromJson(jsonString, new TypeToken>() {
            }.getType());
        } catch (Exception e) {
            // TODO: handle exception
        }
        return list;
    }

    public static List> listKeyMaps(String jsonString) {
        List> list = new ArrayList>();
        try {
            Gson gson = new Gson();
            list = gson.fromJson(jsonString,
                    new TypeToken>>() {
                    }.getType());
        } catch (Exception e) {
            // TODO: handle exception
        }
        return list;
    }
}

3.3 JSON解析之FastJSON

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 import java.util.Map;
 4 
 5 import com.alibaba.fastjson.JSON;
 6 import com.alibaba.fastjson.TypeReference;
 7 
 8 public class JsonTool {
 9 
10     public static  T getPerson(String jsonstring, Class cls) {
11         T t = null;
12         try {
13             t = JSON.parseObject(jsonstring, cls);
14         } catch (Exception e) {
15             // TODO: handle exception
16         }
17         return t;
18     }
19 
20     public static  List getPersonList(String jsonstring, Class cls) {
21         List list = new ArrayList();
22         try {
23             list = JSON.parseArray(jsonstring, cls);
24         } catch (Exception e) {
25             // TODO: handle exception
26         }
27         return list;
28     }
29 
30     public static  List> getPersonListMap1(
31             String jsonstring) {
32         List> list = new ArrayList>();
33         try {
34             list = JSON.parseObject(jsonstring,
35                     new TypeReference>>() {
36                     }.getType());
37 
38         } catch (Exception e) {
39             // TODO: handle exception
40         }
41 
42         return list;
43     }
44 }

总结：

JSON对于移动设备来说，尤其对于网络环境较差和流量限制的情况下，相对于XML格式的数据传输会更节省流量，传输效率更高。在这三种解析方式中FastJson是效率最高的，推荐使用。