java中 json和bean list map之间的互相转换总结

JSON 与 对象 、集合 之间的转换

JSON字符串和java对象的互转【json-lib】

 

在开发过程中，经常需要和别的系统交换数据，数据交换的格式有XML、JSON等，JSON作为一个轻量级的数据格式比xml效率要高，XML需要很多的标签，这无疑占据了网络流量，JSON在这方面则做的很好，下面先看下JSON的格式，

JSON可以有两种格式，一种是对象格式的，另一种是数组对象，

{"name":"JSON","address":"北京市西城区","age":25}//JSON的对象格式的字符串

[{"name":"JSON","address":"北京市西城区","age":25}]//数据对象格式

从上面的两种格式可以看出对象格式和数组对象格式唯一的不同则是在对象格式的基础上加上了[]，再来看具体的结构，可以看出都是以键值对的形式出现的，中间以英文状态下的逗号（,）分隔。

在前端和后端进行数据传输的时候这种格式也是很受欢迎的，后端返回json格式的字符串，前台使用js中的JSON.parse()方法把JSON字符串解析为json对象，然后进行遍历，供前端使用。

下面进入正题，介绍在JAVA中JSON和java对象之间的互转。

要想实现JSON和java对象之间的互转，需要借助第三方jar包，这里使用json-lib这个jar包，下载地址为：https://sourceforge.net/projects/json-lib/，json-lib需要commons-beanutils-1.8.0.jar、commons-collections-3.2.1.jar、commons-lang-2.5.jar、commons-logging-1.1.1.jar、ezmorph-1.0.6.jar五个包的支持，可以自行从网上下载，这里不再贴出下载地址。

json-lib提供了几个类可以完成此功能，例，JSONObject、JSONArray。从类的名字上可以看出JSONObject转化的应该是对象格式的，而JSONArray转化的则应该是数组对象（即，带[]形式）的。

一、java普通对象和json字符串的互转

  java对象--》》字符串

java普通对象指的是java中的一个java bean，即一个实体类，如，

package com.cn.study.day3;

public class Student {
    //姓名
    private String name;
    //年龄
    private String age;
    //住址
    private String address;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", address="
                + address + "]";
    }

}

上面是我的一个普通的java实体类，看json-lib如何把它转化为字符串形式，

public static void convertObject() {

        Student stu=new Student();
        stu.setName("JSON");
        stu.setAge("23");
        stu.setAddress("北京市西城区");

        //1、使用JSONObject
        JSONObject json = JSONObject.fromObject(stu);
        //2、使用JSONArray
        JSONArray array=JSONArray.fromObject(stu);

        String strJson=json.toString();
        String strArray=array.toString();

        System.out.println("strJson:"+strJson);
        System.out.println("strArray:"+strArray);
    }

我定义了一个Student的实体类，然后分别使用了JSONObject和JSONArray两种方式转化为JSON字符串，下面看打印的结果，

strJson:{"address":"北京市西城区","age":"23","name":"JSON"}
strArray:[{"address":"北京市西城区","age":"23","name":"JSON"}]

从结果中可以看出两种方法都可以把java对象转化为JSON字符串，只是转化后的结构不同。

JSON字符串--》》java对象

上面说明了如何把java对象转化为JSON字符串，下面看如何把JSON字符串格式转化为java对象，

首先需要定义两种不同格式的字符串，需要使用\对双引号进行转义，

public static void jsonStrToJava(){
        //定义两种不同格式的字符串
        String objectStr="{\"name\":\"JSON\",\"age\":\"24\",\"address\":\"北京市西城区\"}";
        String arrayStr="[{\"name\":\"JSON\",\"age\":\"24\",\"address\":\"北京市西城区\"}]";

        //1、使用JSONObject
        JSONObject jsonObject=JSONObject.fromObject(objectStr);
        Student stu=(Student)JSONObject.toBean(jsonObject, Student.class);

        //2、使用JSONArray
        JSONArray jsonArray=JSONArray.fromObject(arrayStr);
        //获得jsonArray的第一个元素
        Object o=jsonArray.get(0);
        JSONObject jsonObject2=JSONObject.fromObject(o);
        Student stu2=(Student)JSONObject.toBean(jsonObject2, Student.class);
        System.out.println("stu:"+stu);
        System.out.println("stu2:"+stu2);

    }

打印结果为：

stu:Student [name=JSON, age=24, address=北京市西城区]
stu2:Student [name=JSON, age=24, address=北京市西城区]

从上面的代码中可以看出，使用JSONObject可以轻松的把JSON格式的字符串转化为java对象，但是使用JSONArray就没那么容易了，因为它有“[]”符号，所以我们这里在获得了JSONArray的对象之后，取其第一个元素即我们需要的一个student的变形，然后使用JSONObject轻松获得。

二、list和json字符串的互转

list--》》json字符串

public static void listToJSON(){
        Student stu=new Student();
        stu.setName("JSON");
        stu.setAge("23");
        stu.setAddress("北京市海淀区");
        List<Student> lists=new ArrayList<Student>();
        lists.add(stu);
        //1、使用JSONObject
        //JSONObject listObject=JSONObject.fromObject(lists);
        //2、使用JSONArray
        JSONArray listArray=JSONArray.fromObject(lists);

        //System.out.println("listObject:"+listObject.toString());
        System.out.println("listArray:"+listArray.toString());

    }

我把使用JSONObject的方式给注掉了，我们先看注释之前的结果，

Exception in thread "main" net.sf.json.JSONException: 'object' is an array. Use JSONArray instead

告诉我说有一个异常，通过查看源码发现，在使用fromObject方法的时候会先进行参数类型的判断，这里就告诉我们，传入的参数是一个array类型，因为使用的ArrayList，再来看，注释之后的结果，

listArray:[{"address":"北京市海淀区","age":"23","name":"JSON"}]

这样结果是正常的。
json字符串--》》list

从上面的例子可以看出list的对象只能转化为数组对象的格式，那么我们看下面的字符串到list的转化，

public static void jsonToList(){
        String arrayStr="[{\"name\":\"JSON\",\"age\":\"24\",\"address\":\"北京市西城区\"}]";
        //转化为list
                List<Student> list2=(List<Student>)JSONArray.toList(JSONArray.fromObject(arrayStr), Student.class);

                for (Student stu : list2) {
                    System.out.println(stu);
                }
                //转化为数组
                Student[] ss =(Student[])JSONArray.toArray(JSONArray.fromObject(arrayStr),Student.class);
                for (Student student : ss) {
                    System.out.println(student);
                }

    }

打印结果，

Student [name=JSON, age=24, address=北京市西城区]
Student [name=JSON, age=24, address=北京市西城区]

由于字符串的格式为带有“[]”的格式，所以这里选择JSONArray这个对象，它有toArray、toList方法可供使用，前者转化为java中的数组，或者转化为java中的list，由于这里有实体类进行对应，所以在使用时指定了泛型的类型（Student.class），这样就可以得到转化后的对象。

三、map和json字符串的互转

map--》》json字符串

public static void mapToJSON(){
        Student stu=new Student();
        stu.setName("JSON");
        stu.setAge("23");
        stu.setAddress("中国上海");
        Map<String,Student> map=new HashMap<String,Student>();
        map.put("first", stu);

        //1、JSONObject
        JSONObject mapObject=JSONObject.fromObject(map);
        System.out.println("mapObject"+mapObject.toString());

        //2、JSONArray
        JSONArray mapArray=JSONArray.fromObject(map);
        System.out.println("mapArray:"+mapArray.toString());
    }

打印结果，

mapObject{"first":{"address":"中国上海","age":"23","name":"JSON"}}
mapArray:[{"first":{"address":"中国上海","age":"23","name":"JSON"}}]

上面打印了两种形式。

json字符串--》》map

JSON字符串不能直接转化为map对象，要想取得map中的键对应的值需要别的方式，

public static void jsonToMap(){
        String strObject="{\"first\":{\"address\":\"中国上海\",\"age\":\"23\",\"name\":\"JSON\"}}";

        //JSONObject
        JSONObject jsonObject=JSONObject.fromObject(strObject);
        Map map=new HashMap();
        map.put("first", Student.class);

        //使用了toBean方法，需要三个参数 
        MyBean my=(MyBean)JSONObject.toBean(jsonObject, MyBean.class, map);
        System.out.println(my.getFirst());

    }

打印结果，

Student [name=JSON, age=23, address=中国上海]

下面是MyBean的代码，

package com.cn.study.day4;

import java.util.Map;

import com.cn.study.day3.Student;

public class MyBean {

    private Student first;

    public Student getFirst() {
        return first;
    }

    public void setFirst(Student first) {
        this.first = first;
    }

}

使用toBean()方法是传入了三个参数，第一个是JSONObject对象，第二个是MyBean.class，第三个是一个Map对象。通过MyBean可以知道此类中要有一个first的属性，且其类型为Student，要和map中的键和值类型对应，即，first对应键 first类型对应值的类型。

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

使用spring框架中 jackson jar包中的 ObjectMapper()类json和bean list map之间的互相转换总结

（1）把对象集合转换成json格式

自己做了一java对象转换为json对象的小示例：JacksonTest.java

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

import org.codehaus.jackson.map.ObjectMapper;

public class JacksonTest {
    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        List<Person> persons = new ArrayList<Person>();
        Integer[] arrays = new Integer[2];
        Person person = null;
        for (int i = 0; i < 2; i++) {
            person = new Person("test" + i, "pwd" + i, "phone" + i,
                    "tencent@QQ.com" + i, "男", "23");
            persons.add(person);
            arrays[i] = i;
        }
        Map<String, String> tipMap = new HashMap<String, String>();
        tipMap.put("valueName", "10");
        tipMap.put("valueName2", "3");
        tipMap.put("valueName3", "5");
        tipMap.put("valueName4", "8");
        Map<String, Object> map2Json = new HashMap<String, Object>();
        // 加入list对象
        map2Json.put("personKey", persons);
        // 加入map对象
        map2Json.put("mapKey", tipMap);
        // 加入数组对象
        map2Json.put("idKey", arrays);
        //转化为json字符串
        String json = objectMapper.writeValueAsString(map2Json);
        System.out.println(json);
    }
}

Person.java

import java.io.Serializable;

public class Person implements Serializable{
    private String userName;
    private String password;
    private String phone;
    private String email;
    private String sex;
    private String age;

    public Person(){}

    public Person(String userName, String password, String phone, String email,
            String sex, String age) {
        super();
        this.userName = userName;
        this.password = password;
        this.phone = phone;
        this.email = email;
        this.sex = sex;
        this.age = age;
    }
    。。。省略get()和set()方法
}

运行结果：

{
    "personKey": [{
        "userName": "test0",
        "password": "pwd0",
        "phone": "phone0",
        "email": "tencent@QQ.com0",
        "sex": "男",
        "age": "23"
    },
    {
        "userName": "test1",
        "password": "pwd1",
        "phone": "phone1",
        "email": "tencent@QQ.com1",
        "sex": "男",
        "age": "23"
    }],
    "mapKey": {
        "valueName": "10",
        "valueName2": "3",
        "valueName3": "5",
        "valueName4": "8"
    },
    "idKey": [0,1]
}

Jackson jar包的下载地址http://jackson.codehaus.org/1.7.6/jackson-all-1.7.6.jar

如果是首次使用该jar包还可以阅读官方的示例：http://wiki.fasterxml.com/JacksonInFiveMinutes

github:https://github.com/FasterXML/jackson-core 
当然该jar包还有许多其他的很多强大的api，大家可以自行学习

（2）

把json转换成list maop等对象

1. public class JacksonTest {
2. private static JsonGenerator jsonGenerator = null;
3. private static ObjectMapper objectMapper = null;
4. private static User user = null;
5. public static void writeEntity2Json() throws IOException {
6. System.out.println("使用JsonGenerator转化实体为json串-------------");
7. // writeObject可以转换java对象，eg:JavaBean/Map/List/Array等
8. jsonGenerator.writeObject(user);
9. System.out.println();
10. System.out.println("使用ObjectMapper-----------");
11. // writeValue具有和writeObject相同的功能
12. objectMapper.writeValue(System.out, user);
13. }
14. public static void writeList2Json() throws IOException {
15. List<User> userList = new ArrayList<User>();
16. userList.add(user);
17. User u = new User();
18. u.setUid(10);
19. u.setUname("archie");
20. u.setUpwd("123");
21. userList.add(u);
22. objectMapper.writeValue(System.out, userList);
23. }
24. public static void writeMap2Json() {
25. try {
26. Map<String, Object> map = new HashMap<String, Object>();
27. User u = new User();
28. u.setUid(10);
29. u.setUname("archie");
30. u.setUpwd("123");
31. map.put("uid", u.getUid());
32. map.put("uname", u.getUname());
33. map.put("upwd", u.getUpwd());
34. System.out.println("jsonGenerator");
35. jsonGenerator.writeObject(map);
36. objectMapper.writeValue(System.out, map);
37. } catch (IOException e) {
38. e.printStackTrace();
39. }
40. }
41. public static void writeOthersJSON() {
42. try {
43. String[] arr = { "a", "b", "c" };
44. System.out.println("jsonGenerator");
45. String str = "hello world jackson!";
46. // byte
47. jsonGenerator.writeBinary(str.getBytes());
48. // boolean
49. jsonGenerator.writeBoolean(true);
50. // null
51. jsonGenerator.writeNull();
52. // float
53. jsonGenerator.writeNumber(2.2f);
54. // char
55. jsonGenerator.writeRaw("c");
56. // String
57. jsonGenerator.writeRaw(str, 5, 10);
58. // String
59. jsonGenerator.writeRawValue(str, 5, 5);
60. // String
61. jsonGenerator.writeString(str);
62. jsonGenerator.writeTree(JsonNodeFactory.instance.POJONode(str));
63. System.out.println();
64. // Object
65. jsonGenerator.writeStartObject();// {
66. jsonGenerator.writeObjectFieldStart("user");// user:
67. jsonGenerator.writeStringField("name", "jackson");// name:jackson
68. jsonGenerator.writeBooleanField("sex", true);// sex:true
69. jsonGenerator.writeNumberField("age", 22);// age:22
70. jsonGenerator.writeEndObject();
71. jsonGenerator.writeArrayFieldStart("infos");// infos:[
72. jsonGenerator.writeNumber(22);// 22
73. jsonGenerator.writeString("this is array");// this is array
74. jsonGenerator.writeEndArray();// ]
75. jsonGenerator.writeEndObject();// }
76. User u = new User();
77. user.setUid(5);
78. user.setUname("tom");
79. user.setUpwd("123");
80. user.setNumber(3.44);
81. // complex Object
82. jsonGenerator.writeStartObject();// {
83. jsonGenerator.writeObjectField("uid", u);// user:{bean}
84. jsonGenerator.writeObjectField("infos", arr);// infos:[array]
85. jsonGenerator.writeEndObject();// }
86. } catch (Exception e) {
87. e.printStackTrace();
88. }
89. }
90. /**
91. * JSON字符串转换为对象
92. */
93. public static void readJson2Entity() {
94. String json = "{\"uid\":5,\"uname\":\"tom\",\"number\":3.44,\"upwd\":\"123\"}";
95. try {
96. User acc = objectMapper.readValue(json, User.class);
97. System.out.println(acc.getUid());
98. System.out.println(acc);
99. } catch (JsonParseException e) {
100. e.printStackTrace();
101. } catch (JsonMappingException e) {
102. e.printStackTrace();
103. } catch (IOException e) {
104. e.printStackTrace();
105. }
106. }
107. /**
108. * JSON转换为List对象
109. */
110. public static void readJson2List() {
111. String json = "[{\"uid\":1,\"uname\":\"www\",\"number\":234,\"upwd\":\"456\"},"
112. + "{\"uid\":5,\"uname\":\"tom\",\"number\":3.44,\"upwd\":\"123\"}]";
113. try {
114. List<LinkedHashMap<String, Object>> list = objectMapper.readValue(
115. json, List.class);
116. System.out.println(list.size());
117. for (int i = 0; i < list.size(); i++) {
118. Map<String, Object> map = list.get(i);
119. Set<String> set = map.keySet();
120. for (Iterator<String> it = set.iterator(); it.hasNext();) {
121. String key = it.next();
122. System.out.println(key + ":" + map.get(key));
123. }
124. }
125. } catch (JsonParseException e) {
126. e.printStackTrace();
127. } catch (JsonMappingException e) {
128. e.printStackTrace();
129. } catch (IOException e) {
130. e.printStackTrace();
131. }
132. }
133. /**
134. * JSON转换为数组对象
135. */
136. public static void readJson2Array() {
137. String json = "[{\"uid\":1,\"uname\":\"www\",\"number\":234,\"upwd\":\"456\"},"
138. + "{\"uid\":2,\"uname\":\"sdfsdf\",\"number\":4745,\"upwd\":\"23456\"}]";
139. try {
140. User[] arr = objectMapper.readValue(json, User[].class);
141. System.out.println(arr.length);
142. for (int i = 0; i < arr.length; i++) {
143. System.out.println(arr[i]);
144. }
145. } catch (JsonParseException e) {
146. e.printStackTrace();
147. } catch (JsonMappingException e) {
148. e.printStackTrace();
149. } catch (IOException e) {
150. e.printStackTrace();
151. }
152. }
153. /**
154. * JSON转换为Map对象
155. */
156. public static void readJson2Map() {
157. String json = "{\"success\":true,\"A\":{\"address\": \"address2\",\"name\":\"haha2\",\"id\":2,\"email\":\"email2\"},"+
158. "\"B\":{\"address\":\"address\",\"name\":\"haha\",\"id\":1,\"email\":\"email\"}}";
159. try {
160. Map<String, Map<String, Object>> maps = objectMapper.readValue(json, Map.class);
161. System.out.println(maps.size());
162. Set<String> key = maps.keySet();
163. Iterator<String> iter = key.iterator();
164. while (iter.hasNext()) {
165. String field = iter.next();
166. System.out.println(field + ":" + maps.get(field));
167. }
168. } catch (JsonParseException e) {
169. e.printStackTrace();
170. } catch (JsonMappingException e) {
171. e.printStackTrace();
172. } catch (IOException e) {
173. e.printStackTrace();
174. }
175. }
176. public static void main(String[] args) {
177. user = new User();
178. user.setUid(5);
179. user.setUname("tom");
180. user.setUpwd("123");
181. user.setNumber(3.44);
182. objectMapper = new ObjectMapper();
183. try {
184. //jsonGenerator = objectMapper.getJsonFactory().createJsonGenerator(System.out, JsonEncoding.UTF8);
185. // writeEntity2Json();
186. // writeMap2Json();
187. // writeList2Json();
188. // writeOthersJSON();
189. // readJson2Entity();
190. // readJson2List();
191. //   readJson2Array();
192. readJson2Map();
193. } catch (Exception e) {
194. e.printStackTrace();
195. }
196. }
197. }