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类：

1. package orgjson;
2. /**
3. * 包含getter和setter的java bean类
4. * @author Zen9
5. */
6. public class Student {
7. private String name;
8. private String sex;
9. private int age;
10. public String getName() {
11. return name;
12. }
13. public void setName(String name) {
14. this.name = name;
15. }
16. public String getSex() {
17. return sex;
18. }
19. public void setSex(String sex) {
20. this.sex = sex;
21. }
22. public int getAge() {
23. return age;
24. }
25. public void setAge(int age) {
26. this.age = age;
27. }
28. }

然后测试构造方法；也可以用put方法来向JSON对象中添加key/value对，当用put方法时候，value值可以是int、double、String、、boolean、collection、Map等等，但不可以为bean类型，代码如下：

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 JsonTest {
8. public static void constructorTest() {
9. String jsonStr = "{'name':'JTZen9','age':21}";
10. JSONObject strJson = new JSONObject(jsonStr); // 传入字符串
11. System.out.println("构造参数为String类：" + strJson);
12. Map<string object> map = new HashMap<string object>();
13. map.put("age", 21);
14. map.put("sex", "male");
15. map.put("name", "JTZen9");
16. JSONObject mapJson = new JSONObject(map); // 传入Map类型
17. System.out.println("构造参数为Map类：" + mapJson);
18. Student student = new Student();
19. student.setAge(21);
20. student.setName("JTZen9");
21. student.setSex("male");
22. JSONObject beanJson = new JSONObject(student); // 传入Bean类型
23. System.out.println("构造参数为Bean类：" + beanJson);
24. }
25. public static void putMethodTest() {
26. JSONObject jsonObject1 = new JSONObject();
27. jsonObject1.put("bookName", "JTZen9");
28. jsonObject1.put("age", 21);
29. System.out.println(jsonObject1);
30. JSONObject jsonObject2 = new JSONObject();
31. List<object> list = new ArrayList</object><object>();
32. for (int i = 1; i < 3; i++) {
33. Map<string object=""> map = new HashMap<string object="">();
34. map.put("title", "java程序设计 第" + i + "版");
35. map.put("price", i*20);
36. list.add(map);
37. }
38. jsonObject2.put("book", list);
39. System.out.println(jsonObject2);
40. Student student = new Student();
41. student.setAge(21);
42. student.setName("JTZen9");
43. student.setSex("male");
44. jsonObject2 = new JSONObject(student);
45. JSONObject jsonObject3 = new JSONObject();
46. jsonObject3.put("people", jsonObject2);   //不可以直接传bean类对象put("people",student)
47. System.out.println(jsonObject3);
48. }
49. public static void main(String[] args) throws Exception {
50. constructorTest();
51. System.out.println("---------------------------------------------------------");
52. putMethodTest();
53. }
54. }

输出结果：

 

3.2 JSONArray.java

1.构造函数

官网上的JSONObject的构造函数如下：

        这里用Collection、String和Object型的array作为参数，给出例子如下：

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. String jsonStr = "[{'name':'JTZen9','age':21}]";
10. JSONArray strJson = new JSONArray(jsonStr);     // 传入字符串
11. System.out.println("构造参数为String类：" + strJson);
12. List<Object> list = new ArrayList<Object>();
13. for (int i = 1; i < 3; i++) {
14. Map<string object=""> map = new HashMap<string object="">();
15. map.put("title", "java程序设计 第" + i + "版");
16. map.put("price", i*20);
17. list.add(map);
18. }
19. JSONArray mapJson = new JSONArray(list);        // 传入Collection类型
20. System.out.println("构造参数为Collection类：" + mapJson);
21. int[] numlist = new int[10];
22. for (int i = 0; i < numlist.length; i++) {
23. numlist[i] = i;
24. }
25. JSONArray arrayJson = new JSONArray(numlist);   // 传入Array类型，实例1
26. System.out.println(arrayJson);
27. Student[] student = {new Student(),new Student()};
28. student[0].setAge(21);
29. student[0].setName("JTZen9");
30. student[0].setSex("male");
31. student[1].setAge(21);
32. student[1].setName("heiheihei");
33. student[1].setSex("female");
34. JSONArray beanJson = new JSONArray(student);    // 传入Array类型，实例2
35. System.out.println("构造参数为Array类：" + beanJson);
36. }
37. public static void main(String[] args) {
38. constructorTest();
39. }
40. }

        输出结果如下：

2.put方法创建

put方法中可以直接将int、double、Collection、Map等加进去，也可以添加下标来指定添加的位置：put(int index, java.util.Map value) ，使用put方法构造的JSON数组，如果传入的是数组，都会自动加一对中括号[ ]，那么出来的结果就会有两层的中括号[ ]，代码例子如下：

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");
9. jsonArray1.put(21);
10. jsonArray1.put("male");
11. System.out.println(jsonArray1);
12. JSONArray jsonArray2 = new JSONArray();
13. Map<string object=""> map = new HashMap<string object="">();
14. map.put("title", "java程序设计 第2版");
15. map.put("price", 20);
16. jsonArray2.put(map);        //传入一个map
17. System.out.println("传入一个Map：" + jsonArray2);
18. map.clear();
19. map.put("title", "java程序设计 第3版");
20. map.put("price", 30);
21. jsonArray2.put(map);        //没有下标的直接在结果后面添加
22. System.out.println("没有指定下标：" + jsonArray2);
23. map.clear();
24. map.put("title", "java程序设计 第1版");
25. map.put("price", 10);
26. jsonArray2.put(0,map);      //使用下标可以添加到自定义的位置
27. System.out.println("添加到第一个位置：" + jsonArray2);
28. Student[] student = { new Student(), new Student() };
29. student[0].setAge(21);
30. student[0].setName("JTZen9");
31. student[0].setSex("male");
32. student[1].setAge(21);
33. student[1].setName("heiheihei");
34. student[1].setSex("female");
35. JSONArray jsonArray3 = new JSONArray();
36. jsonArray3.put(student);
37. System.out.println("注意输出结果：" + jsonArray3);
38. }
39. public static void main(String[] args) {
40. putMethodTest();
41. }
42. }

输出的结果如下：

 

3.3 JSONStringer.java & JSONWriter.java

        ①JSONWriter可以用来构建一个JSON格式的文本，并转换成String，可以写入文件，便于传输和存储。只有一个构造函数：JSONWriter(java.io.Writer w) 
        ②常用几个函数和说明：

        ③JSONStringer是JSONWriter的子类；用法跟JSONWriter几乎一样，区别是可以直接new JSONStringer()创建对象，不用传入构造参数。JSONStringer也可以通过object().key().value().key().value().endObject()进行构造;

        下面是简单的写入代码例子：（可以尝试写入更复杂数据）

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. PrintWriter writer = new PrintWriter("test.txt");
9. JSONWriter jsonWriter = new JSONWriter(writer);
10. jsonWriter.object().key("name").value("JTZen9").key("age").value(21).key("sex").value("male").endObject();
11. writer.flush();
12. writer.close();
13. Map<string object=""> map1 = new HashMap<string object="">();
14. map1.put("age", 21);
15. map1.put("sex", "male");
16. map1.put("name", "jtzen9");
17. Map<string object=""> map2 = new HashMap<string object="">();
18. map2.put("age", 21);
19. map2.put("sex", "female");
20. map2.put("name", "heiheihei");
21. JSONStringer jsonStringer = new JSONStringer();
22. jsonStringer.array().value(map1).value(map2).endArray();
23. System.out.println(jsonStringer);
24. }
25. public static void main(String[] args) throws Exception {
26. JSONStringerTest();
27. }
28. }

输出结果，上面为test.txt文件，下面为控制台：

 

3.4 JSONTokener.java

        JSONTokener读取包含json格式数据的文件，然后可以将JSONTokener对象作为参数来构造JSONObject或JSONArray，然后再进行相应的解析。

以上面的test.txt为例，简单代码示例如下：

1. package orgjson;
2. import java.io.File;
3. import java.io.FileReader;
4. import org.json.*;
5. public class JSONTokenerTest {
6. public static void readJsonFile() throws Exception{
7. JSONTokener jsonTokener = new JSONTokener(new FileReader(new File("test.txt")));
8. JSONObject jsonObject = new JSONObject(jsonTokener);
9. System.out.println(jsonObject);
10. System.out.println("姓名：" + jsonObject.getString("name"));
11. System.out.println("年龄：" + jsonObject.getInt("age"));
12. }
13. public static void main(String[] args) throws Exception {
14. readJsonFile();
15. }
16. }

输出结果如下：

 

4.解析例子

        这里给出一个相对复杂的json数据：

json.txt

1. [
2. {
3. "institute":{
4. "name":"Software Institute",
5. "grade":[
6. {
7. "name":"freshman",
8. "class":[
9. {
10. "no.":1,
11. "students":61
12. },
13. {
14. "no.":2,
15. "students":62
16. },
17. {
18. "no.":3,
19. "students":63
20. }
21. ]
22. },
23. {
24. "name":"sophomore",
25. "class":[
26. {
27. "no.":1,
28. "students":51
29. },
30. {
31. "no.":2,
32. "students":52
33. },
34. {
35. "no.":3,
36. "students":53
37. }
38. ]
39. },
40. {
41. "name":"junior",
42. "class":[
43. {
44. "no.":1,
45. "students":41
46. },
47. {
48. "no.":2,
49. "students":42
50. },
51. {
52. "no.":3,
53. "students":43
54. }
55. ]
56. }
57. ]
58. }
59. }
60. ]

然后，如果我要获取grade为sophomore的no.等于3的students数量，那么代码如下：

1. package orgjson;
2. import java.io.File;
3. import java.io.FileReader;
4. import org.json.JSONArray;
5. import org.json.JSONObject;
6. import org.json.JSONTokener;
7. public class JSONTest {
8. public static void main(String[] args) throws Exception {
9. JSONTokener jsonTokener = new JSONTokener(new FileReader(new File("json.txt")));
10. JSONArray jsonArray = new JSONArray(jsonTokener);//获取整个json文件的内容，因为最外层是数组，所以用JSONArray来构造
11. System.out.println(jsonArray);
12. //这个JSONArray数组只包含一个JSONObject对象，标为jsonObject1
13. JSONObject jsonObject1 = jsonArray.getJSONObject(0);
14. System.out.println(jsonObject1);
15. //jsonObject1只包含一个institute字段，这里获取这个字段内容赋给jsonObject2
16. JSONObject jsonObject2 = jsonObject1.getJSONObject("institute");
17. System.out.println(jsonObject2);
18. //jsonObject2包含name字段和grade字段，grade字段对应的是一个JSONArray数组
19. String valueOfname = jsonObject2.getString("name");
20. System.out.println(valueOfname);
21. JSONArray jsonArray2 = jsonObject2.getJSONArray("grade");
22. System.out.println(jsonArray2);
23. //jsonArray2数组包含3个对象，每个对象里面有name字段和class字段，这里获取第二个对象
24. JSONObject jsonObject3 = jsonArray2.getJSONObject(1);
25. System.out.println(jsonObject3);
26. //然后从jsonObject3对象里获取class字段对应的JSONArray数组
27. JSONArray jsonArray3 = jsonObject3.getJSONArray("class");
28. System.out.println(jsonArray3);
29. //下面直接获取no.等于3的students数量，过程都一样
30. int num = jsonArray3.getJSONObject(2).getInt("students");
31. System.out.println("最后获取的结果为：" + num);
32. }
33. }

输出的结果如下，这里只截取控制台输出的前半部分结果：

 

5.结束语

之前解析json数据都是一直百度百度，别人怎么用就怎么用，做大作业时有时候会org.json包也导入，Gson包也导入，然后各用一点功能。现在想想其实只用一个org.json包就可以完全解决我的需求，只是之前一直没有总结各种用法，所以这两天看了下官网源码，总结了下学习笔记，还是收获蛮大的。

        其实看官网api文档，然后自己动手实践各种方法才是最好的学习方式。百度别人的教程，有时候只能得到小部分的说明。

        org.json包还有很多的api方法并没有用过，所以就不做笔记了。以后用到再继续完善。