FastJson对于JSON格式字符串、JSON对象及JavaBean之间的相互转换

转自：https://blog.csdn.net/a18827547638/article/details/80777366

 收下：https://blog.csdn.net/xuforeverlove/article/details/80842148  

https://www.cnblogs.com/zhou-test/p/10007012.html

https://www.cnblogs.com/chancy/p/10179151.html

https://blog.csdn.net/qq_36306340/article/details/78976902

一、定义

fastJson对于json格式字符串的解析主要用到了一下三个类：

JSON：fastJson的解析器，用于JSON格式字符串与JSON对象及javaBean之间的转换。

JSONObject：fastJson提供的json对象。我们可以把JSONObject当成一个Map<String,Object>来看

JSONArray：fastJson提供json数组对象。我们可以把JSONArray当做一个List<Object>，可以把JSONArray看成JSONObject对象的一个集合

 

二、数据

首先定义三个json格式的字符串，作为我们的数据源。

 1 //1、json字符串-简单对象型
 2 private static final String  JSON_OBJ_STR = "{\"studentName\":\"lily\",\"studentAge\":12}";
 3 　　{
 4 
 5 　　　　"studentName":"lily",
 6 
 7 　　　　"studentAge":12
 8 
 9 　}
10 //2、json字符串-数组类型
11 private static final String  JSON_ARRAY_STR = "[{\"studentName\":\"lily\",\"studentAge\":12},{\"studentName\":\"lucy\",\"studentAge\":15}]";
12 [
13 　　　　{
14 
15 　　　　　　"studentName":"lily",
16 
17 　　　　　　"studentAge":12
18 
19 　　　　},
20 　　　　{
21 
22 　　　　　　"studentName":"lucy",
23 
24 　　　　　　"studentAge":15
25 
26 　　　　}
27 ]
28 //3、复杂格式json字符串
29 private static final String  COMPLEX_JSON_STR = "{\"teacherName\":\"crystall\",\"teacherAge\":27,\"course\":{\"courseName\":\"english\",\"code\":1270},\"students\":[{\"studentName\":\"lily\",\"studentAge\":12},{\"studentName\":\"lucy\",\"studentAge\":15}]}";
30 {
31 　　"teacherName":"crystall",
32 
33 　　"teacherAge":27,
34 
35 　　"course":{
36 
37 　　　　"courseName":"english",
38 
39 　　　　"code":1270
40 
41 　　　　},
42 
43 
44 　　"students":[
45 
46 　　　　{
47 
48 　　　　　　"studentName":"lily",
49 
50 　　　　　　"studentAge":12
51 
52 　　　　},
53 
54 　　　　{
55 
56 　　　　　　"studentName":"lucy",
57 
58 　　　　　　"studentAge":15
59 
60 　　　　}
61 
62 　　]
63 
64 　}

 

三、转化

 3.1 JSON格式字符串与JSON对象之间的转换。

　　3.1.1  json字符串-简单对象型与JSONObject之间的转换　　　　

 1 /**
 2      * json字符串-简单对象型与JSONObject之间的转换
 3      */
 4     public static void testJSONStrToJSONObject(){
 5  
 6         JSONObject jsonObject = JSON.parseObject(JSON_OBJ_STR);
 7         //JSONObject jsonObject1 = JSONObject.parseObject(JSON_OBJ_STR); //因为JSONObject继承了JSON，所以这样也是可以的
 8  
 9         System.out.println(jsonObject.getString("studentName")+":"+jsonObject.getInteger("studentAge"));
10  
11 　　　　}

　　3.1.2 json字符串-数组类型与JSONArray之间的转换

 1 　　　/**
 2      * json字符串-数组类型与JSONArray之间的转换
 3      */
 4     public static void testJSONStrToJSONArray(){
 5  
 6         JSONArray jsonArray = JSON.parseArray(JSON_ARRAY_STR);
 7         //JSONArray jsonArray1 = JSONArray.parseArray(JSON_ARRAY_STR);//因为JSONArray继承了JSON，所以这样也是可以的
 8  
 9         //遍历方式1
10         int size = jsonArray.size();
11         for (int i = 0; i < size; i++){
12             JSONObject jsonObject = jsonArray.getJSONObject(i);
13             System.out.println(jsonObject.getString("studentName")+":"+jsonObject.getInteger("studentAge"));
14         }
15         //遍历方式2
16         for (Object obj : jsonArray) {
17             JSONObject jsonObject = (JSONObject) obj;
18             System.out.println(jsonObject.getString("studentName")+":"+jsonObject.getInteger("studentAge"));
19         }
20 　　}

　　3.1.3 复杂json格式字符串与JSONObject之间的转换

 1 　　　/**
 2      * 复杂json格式字符串与JSONObject之间的转换
 3      */
 4     public static void testComplexJSONStrToJSONObject(){
 5  
 6         JSONObject jsonObject = JSON.parseObject(COMPLEX_JSON_STR);
 7         //JSONObject jsonObject1 = JSONObject.parseObject(COMPLEX_JSON_STR);//因为JSONObject继承了JSON，所以这样也是可以的
 8         
 9         String teacherName = jsonObject.getString("teacherName");
10         Integer teacherAge = jsonObject.getInteger("teacherAge");
11         JSONObject course = jsonObject.getJSONObject("course");
12         JSONArray students = jsonObject.getJSONArray("students");
13  
14 　　}

 3.2 JSON格式字符串与javaBean之间的转换。

　　3.2.1  javaBean定义，为三个JSON串转Bean做准备。

 1 1、定义一个学生类：
 2 public class Student {
 3  
 4     private String studentName;
 5     private Integer studentAge;
 6  
 7     public String getStudentName() {
 8         return studentName;
 9     }
10  
11     public void setStudentName(String studentName) {
12         this.studentName = studentName;
13     }
14  
15     public Integer getStudentAge() {
16         return studentAge;
17     }
18  
19     public void setStudentAge(Integer studentAge) {
20         this.studentAge = studentAge;
21     }
22 }
 1 2、定一个课程类：
 2 public class Course {
 3  
 4     private String courseName;
 5     private Integer code;
 6  
 7     public String getCourseName() {
 8         return courseName;
 9     }
10  
11     public void setCourseName(String courseName) {
12         this.courseName = courseName;
13     }
14  
15     public Integer getCode() {
16         return code;
17     }
18  
19     public void setCode(Integer code) {
20         this.code = code;
21     }
22 }
 1 3、定义一个老师类：
 2 public class Teacher {
 3  
 4     private String teacherName;
 5     private Integer teacherAge;
 6     private Course course;
 7     private List<Student> students;
 8  
 9     public String getTeacherName() {
10         return teacherName;
11     }
12  
13     public void setTeacherName(String teacherName) {
14         this.teacherName = teacherName;
15     }
16  
17     public Integer getTeacherAge() {
18         return teacherAge;
19     }
20  
21     public void setTeacherAge(Integer teacherAge) {
22         this.teacherAge = teacherAge;
23     }
24  
25     public Course getCourse() {
26         return course;
27     }
28  
29     public void setCourse(Course course) {
30         this.course = course;
31     }
32  
33     public List<Student> getStudents() {
34         return students;
35     }
36  
37     public void setStudents(List<Student> students) {
38         this.students = students;
39     }
40 }

　　json字符串与javaBean之间的转换推荐使用 TypeReference<T> 这个类，使用泛型可以更加清晰　　

　　3.2.2 json字符串-简单对象型与javaBean之间的转换

 1 　　　/**
 2      * json字符串-简单对象与JavaBean_obj之间的转换
 3      */
 4     public static void testJSONStrToJavaBeanObj(){
 5  
 6         Student student = JSON.parseObject(JSON_OBJ_STR, new TypeReference<Student>() {});
 7         //Student student1 = JSONObject.parseObject(JSON_OBJ_STR, new TypeReference<Student>() {});//因为JSONObject继承了JSON，所以这样也是可以的
 8  
 9         System.out.println(student.getStudentName()+":"+student.getStudentAge());
10  
11 　　}

　　3.2.3 json字符串-数组类型与javaBean之间的转换

 1     /**
 2      * json字符串-数组类型与JavaBean_List之间的转换
 3      */
 4     public static void testJSONStrToJavaBeanList(){
 5         
 6         ArrayList<Student> students = JSON.parseObject(JSON_ARRAY_STR, new TypeReference<ArrayList<Student>>() {});
 7         //ArrayList<Student> students1 = JSONArray.parseObject(JSON_ARRAY_STR, new TypeReference<ArrayList<Student>>() {});//因为JSONArray继承了JSON，所以这样也是可以的
 8         
 9         for (Student student : students) {
10             System.out.println(student.getStudentName()+":"+student.getStudentAge());
11         }
12     }

　　3.2.4 复杂json格式字符串与与javaBean之间的转换

 1     /**
 2      * 复杂json格式字符串与JavaBean_obj之间的转换
 3      */
 4     public static void testComplexJSONStrToJavaBean(){
 5  
 6         Teacher teacher = JSON.parseObject(COMPLEX_JSON_STR, new TypeReference<Teacher>() {});
 7         //Teacher teacher1 = JSON.parseObject(COMPLEX_JSON_STR, new TypeReference<Teacher>() {});//因为JSONObject继承了JSON，所以这样也是可以的
 8         String teacherName = teacher.getTeacherName();
 9         Integer teacherAge = teacher.getTeacherAge();
10         Course course = teacher.getCourse();
11         List<Student> students = teacher.getStudents();
12     }

此外的：

1，对于JSON对象与JSON格式字符串的转换可以直接用 toJSONString()这个方法。

2，javaBean与JSON格式字符串之间的转换要用到：JSON.toJSONString(obj);

3，javaBean与json对象间的转换使用：JSON.toJSON(obj)，然后使用强制类型转换，JSONObject或者JSONArray。

 

三、json串转MAP

转：https://www.cnblogs.com/jpfss/p/8625526.html

 1 package com.zkn.newlearn.json;  
 2   
 3 import com.alibaba.fastjson.JSON;  
 4 import com.alibaba.fastjson.JSONObject;  
 5 import java.util.Map;  
 6   
 7 /** 
 8  * JSON字符串自动转换 
 9  * Created by zkn on 2016/8/22. 
10  */  
11 public class JsonToMapTest01 {  
12   
13     public static void main(String[] args){  
14   
15         String str = "{\"0\":\"zhangsan\",\"1\":\"lisi\",\"2\":\"wangwu\",\"3\":\"maliu\"}";  
16         //第一种方式  
17         Map maps = (Map)JSON.parse(str);  
18         System.out.println("这个是用JSON类来解析JSON字符串!!!");  
19         for (Object map : maps.entrySet()){  
20             System.out.println(((Map.Entry)map).getKey()+"     " + ((Map.Entry)map).getValue());  
21         }  
22         //第二种方式  
23         Map mapTypes = JSON.parseObject(str);  
24         System.out.println("这个是用JSON类的parseObject来解析JSON字符串!!!");  
25         for (Object obj : mapTypes.keySet()){  
26             System.out.println("key为："+obj+"值为："+mapTypes.get(obj));  
27         }  
28         //第三种方式  
29         Map mapType = JSON.parseObject(str,Map.class);  
30         System.out.println("这个是用JSON类,指定解析类型，来解析JSON字符串!!!");  
31         for (Object obj : mapType.keySet()){  
32             System.out.println("key为："+obj+"值为："+mapType.get(obj));  
33         }  
34         //第四种方式  
35         /** 
36          * JSONObject是Map接口的一个实现类 
37          */  
38         Map json = (Map) JSONObject.parse(str);  
39         System.out.println("这个是用JSONObject类的parse方法来解析JSON字符串!!!");  
40         for (Object map : json.entrySet()){  
41             System.out.println(((Map.Entry)map).getKey()+"  "+((Map.Entry)map).getValue());  
42         }  
43         //第五种方式  
44         /** 
45          * JSONObject是Map接口的一个实现类 
46          */  
47         JSONObject jsonObject = JSONObject.parseObject(str);  
48         System.out.println("这个是用JSONObject的parseObject方法来解析JSON字符串!!!");  
49         for (Object map : json.entrySet()){  
50             System.out.println(((Map.Entry)map).getKey()+"  "+((Map.Entry)map).getValue());  
51         }  
52         //第六种方式  
53         /** 
54          * JSONObject是Map接口的一个实现类 
55          */  
56         Map mapObj = JSONObject.parseObject(str,Map.class);  
57         System.out.println("这个是用JSONObject的parseObject方法并执行返回类型来解析JSON字符串!!!");  
58         for (Object map: json.entrySet()){  
59             System.out.println(((Map.Entry)map).getKey()+"  "+((Map.Entry)map).getValue());  
60         }  
61         String strArr = "{{\"0\":\"zhangsan\",\"1\":\"lisi\",\"2\":\"wangwu\",\"3\":\"maliu\"}," +  
62                 "{\"00\":\"zhangsan\",\"11\":\"lisi\",\"22\":\"wangwu\",\"33\":\"maliu\"}}";  
63        // JSONArray.parse()  
64         System.out.println(json);  
65     }  
66 }

 

posted @ 2021-06-07 20:26  杨柳春色  阅读(429)  评论(0)  编辑  收藏  举报