Java创建和解析Json数据⽅法——org.json包的使⽤（转）org.json包的使⽤
1.简介
⼯具包org.json.jar，是⼀个轻量级的，JAVA下的json构造和解析⼯具包，它还包含JSON与XML, HTTP headers, Cookies,  CDL的转换。
这篇学习笔记，主要介绍常⽤的⼀些类如：JSONObject、JSONArray、JSONStringer等的⼀些⽤法；介绍了如何将Map、Collection、Java Bean等对象转化为json数据；介绍了如何使⽤org.json包解析json数据等。
2.常⽤类
3.构造json的⽰例⽤法
3.1 JSONObject.java
官⽹给出的JSONObject的构造函数如下：
⽐较常⽤就是传⼊String、map或者bean来构造JSON对象，代码例⼦如下：
⾸先定义⼀个java bean类：
[java]
1. package orgjson;
2.
3. /**
4.  * 包含getter和setter的java bean类
5.  * @author Zen9
6.  */
7. public class Student {
8.    private String name;
9.    private String sex;
10.    private int age;
11.
12.    public String getName() {
13.        return name;
14.    }
15.    public void setName(String name) {
16.        this.name = name;
17.    }
18.    public String getSex() {
19.        return sex;
20.    }
21.    public void setSex(String sex) {
22.        this.sex = sex;
23.    }
24.    public int getAge() {
25.        return age;
26.    }
27.    public void setAge(int age) {
28.        this.age = age;
29.    }
30. }
然后测试构造⽅法；也可以⽤put⽅法来向JSON对象中添加key/value对，当⽤put⽅法时候，value值可以是int、double、String、、boolean、collection、Map等等，但不可以为bean类型，代码如下：
[java]
1. package orgjson;
4. import java.util.List;
5. import java.util.Map;
6. import org.json.*;
7. public class JsonTest {
8.    public static void constructorTest() {
9.
10.        String jsonStr = "{'name':'JTZen9','age':21}";
11.        JSONObject strJson = new JSONObject(jsonStr); // 传⼊字符串
12.        System.out.println("构造参数为String类：" + strJson);
13.
14.        Map<string object> map = new HashMap<string object>();
15.        map.put("age", 21);
16.        map.put("sex", "male");
17.        map.put("name", "JTZen9");
18.        JSONObject mapJson = new JSONObject(map); // 传⼊Map类型
19.        System.out.println("构造参数为Map类：" + mapJson);
20.
21.        Student student = new Student();
22.        student.setAge(21);
23.        student.setName("JTZen9");
24.        student.setSex("male");
25.        JSONObject beanJson = new JSONObject(student); // 传⼊Bean类型
26.        System.out.println("构造参数为Bean类：" + beanJson);
27.    }
28.
29.    public static void putMethodTest() {
30.
31.        JSONObject jsonObject1 = new JSONObject();
32.        jsonObject1.put("bookName", "JTZen9");
33.        jsonObject1.put("age", 21);
34.        System.out.println(jsonObject1);
35.
36.        JSONObject jsonObject2 = new JSONObject();
37.        List<object> list = new ArrayList</object><object>();
38.        for (int i = 1; i < 3; i++) {
39.            Map<string object=""> map = new HashMap<string object="">();
40.            map.put("title", "java程序设计第" + i + "版");
41.            map.put("price", i*20);
42.            list.add(map);
43.        }
44.        jsonObject2.put("book", list);
45.        System.out.println(jsonObject2);
46.
47.        Student student = new Student();
48.        student.setAge(21);
49.        student.setName("JTZen9");
50.        student.setSex("male");
51.        jsonObject2 = new JSONObject(student);
52.        JSONObject jsonObject3 = new JSONObject();
53.        jsonObject3.put("people", jsonObject2);  //不可以直接传bean类对象put("people",student)
54.        System.out.println(jsonObject3);
55.    }
56.
57.    public static void main(String[] args) throws Exception {
58.        constructorTest();
59.        System.out.println("---------------------------------------------------------");
60.        putMethodTest();
61.    }
62. }
输出结果：
3.2 JSONArray.java
1.构造函数
这⾥⽤Collection、String和Object型的array作为参数，给出例⼦如下：
[java]
1. package orgjson;
2. import java.util.ArrayList;
3. import java.util.HashMap;
4. import java.util.List;
5. import java.util.Map;
6. import org.json.*;
7. public class JsonArrayTest {
8.    public static void constructorTest() {
9.
10.        String jsonStr = "[{'name':'JTZen9','age':21}]";
11.        JSONArray strJson = new JSONArray(jsonStr);    // 传⼊字符串
12.        System.out.println("构造参数为String类：" + strJson);
13.
14.        List<Object> list = new ArrayList<Object>();
15.        for (int i = 1; i < 3; i++) {
16.            Map<string object=""> map = new HashMap<string object="">();
17.            map.put("title", "java程序设计第" + i + "版");
18.            map.put("price", i*20);
19.            list.add(map);
20.        }
21.        JSONArray mapJson = new JSONArray(list);        // 传⼊Collection类型
22.        System.out.println("构造参数为Collection类：" + mapJson);
23.
24.        int[] numlist = new int[10];
25.        for (int i = 0; i < numlist.length; i++) {
26.            numlist[i] = i;
27.        }
28.        JSONArray arrayJson = new JSONArray(numlist);  // 传⼊Array类型，实例1
29.        System.out.println(arrayJson);
30.
31.        Student[] student = {new Student(),new Student()};
32.        student[0].setAge(21);
33.        student[0].setName("JTZen9");
34.        student[0].setSex("male");
35.        student[1].setAge(21);
36.        student[1].setName("heiheihei");
37.        student[1].setSex("female");
38.        JSONArray beanJson = new JSONArray(student);    // 传⼊Array类型，实例2
39.        System.out.println("构造参数为Array类：" + beanJson);
40.    }
41.
42.    public static void main(String[] args) {
java arraylist用法43.        constructorTest();
44.    }
45. }
输出结果如下：
2.put⽅法创建
put⽅法中可以直接将int、double、Collection、Map等加进去，也可以添加下标来指定添加的位置：put(int index, java.util.Map value)，使⽤put⽅法构造的JSON数组，如果传⼊的是数组，都会⾃动加⼀对中括号[ ]，那么出来的结果就会有两层的中括号[ ]，代码例⼦如下：[java]
1. package orgjson;
2. import java.util.HashMap;
3. import java.util.Map;
4. import org.json.*;
5. public class JSONArrayTest {
6.    public static void putMethodTest() {
7.        JSONArray jsonArray1 = new JSONArray();
8.        jsonArray1.put("JTZen9");
11.        System.out.println(jsonArray1);
12.
13.        JSONArray jsonArray2 = new JSONArray();
14.        Map<string object=""> map = new HashMap<string object="">();
15.        map.put("title", "java程序设计第2版");
16.        map.put("price", 20);
17.        jsonArray2.put(map);        //传⼊⼀个map
18.        System.out.println("传⼊⼀个Map：" + jsonArray2);
19.        map.clear();
20.        map.put("title", "java程序设计第3版");
21.        map.put("price", 30);
22.        jsonArray2.put(map);        //没有下标的直接在结果后⾯添加
23.        System.out.println("没有指定下标：" + jsonArray2);
24.        map.clear();
25.        map.put("title", "java程序设计第1版");
26.        map.put("price", 10);
27.        jsonArray2.put(0,map);      //使⽤下标可以添加到⾃定义的位置
28.        System.out.println("添加到第⼀个位置：" + jsonArray2);
29.
30.        Student[] student = { new Student(), new Student() };
31.        student[0].setAge(21);
32.        student[0].setName("JTZen9");
33.        student[0].setSex("male");
34.        student[1].setAge(21);
35.        student[1].setName("heiheihei");
36.        student[1].setSex("female");
37.        JSONArray jsonArray3 = new JSONArray();
38.        jsonArray3.put(student);
39.        System.out.println("注意输出结果：" + jsonArray3);
40.
41.    }
42.
43.    public static void main(String[] args) {
44.        putMethodTest();
45.    }
46. }
输出的结果如下：
3.3 JSONStringer.java & JSONWriter.java
①JSONWriter可以⽤来构建⼀个JSON格式的⽂本，并转换成String，可以写⼊⽂件，便于传输和存储。只有⼀个构造函数：JSONWriter(java.io.Writer w)
②常⽤⼏个函数和说明：
③JSONStringer是JSONWriter的⼦类；⽤法跟JSONWriter⼏乎⼀样，区别是可以直接new JSONStringer()创建对象，不⽤传⼊构造参数。JSONStringer也可以通过object().key().value().key().val
ue().endObject()进⾏构造;
下⾯是简单的写⼊代码例⼦：（可以尝试写⼊更复杂数据）
[java]
1. package orgjson;
2. import java.io.PrintWriter;
3. import java.util.HashMap;
4. import java.util.Map;
5. import org.json.*;
6. public class JSONWriterStringerTest {
7.    public static void JSONStringerTest() throws Exception {
8.
9.        PrintWriter writer = new PrintWriter("");
10.        JSONWriter jsonWriter = new JSONWriter(writer);
11.        jsonWriter.object().key("name").value("JTZen9").key("age").value(21).key("sex").value("male").endObject();
12.        writer.flush();
13.        writer.close();
14.
15.        Map<string object=""> map1 = new HashMap<string object="">();
18.        map1.put("name", "jtzen9");
19.        Map<string object=""> map2 = new HashMap<string object="">();
20.        map2.put("age", 21);
21.        map2.put("sex", "female");
22.        map2.put("name", "heiheihei");
23.        JSONStringer jsonStringer = new JSONStringer();
24.        jsonStringer.array().value(map1).value(map2).endArray();
25.        System.out.println(jsonStringer);
26.    }
27.
28.    public static void main(String[] args) throws Exception {
29.        JSONStringerTest();
30.    }
31. }
输出结果，上⾯为⽂件，下⾯为控制台：
3.4 JSONTokener.java
JSONTokener读取包含json格式数据的⽂件，然后可以将JSONTokener对象作为参数来构造JSONObject或JSONArray，然后再进⾏相应的解析。
以上⾯的为例，简单代码⽰例如下：
[java]
1. package orgjson;
2. import java.io.File;
3. import java.io.FileReader;
4. import org.json.*;
5. public class JSONTokenerTest {
6.
7.    public static void readJsonFile() throws Exception{
8.        JSONTokener jsonTokener = new JSONTokener(new FileReader(new File("")));
9.        JSONObject jsonObject = new JSONObject(jsonTokener);
10.        System.out.println(jsonObject);
11.        System.out.println("姓名：" + String("name"));
12.        System.out.println("年龄：" + Int("age"));
13.    }
14.
15.    public static void main(String[] args) throws Exception {
16.        readJsonFile();
17.    }
18. }
输出结果如下：
4.解析例⼦
这⾥给出⼀个相对复杂的json数据：
<
[java]
1. [
2.    {
3.        "institute":{
4.            "name":"Software Institute",
5.            "grade":[
6.                {
7.                    "name":"freshman",
8.                    "class":[
9.                        {
10.                            "no.":1,
11.                            "students":61

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。