Marshall趙

fastJson

2021/05/02 Json 共 30310 字，约 87 分钟
闷骚的程序员

1. fastJson简介

1.1 什么是fastJson？

fastJson是alibaba的一个针对json的开源类库。
其中提供了json字符串和java对象之间的各种转换方式。
fastJson效率极高。

1.2 所需的jar

如要使用fastJson，则需要导入fastjson.jar，选择最新版本即可。

2. 回顾json

2.1 回顾json的数据类型

  1. Number：数字型。
  2. String：字符串型。
  3. Boolean：布尔型。
  4. Array：数组。
  5. Object：对象。
  6. null：空值。

2.2 回顾json格式串

json对象格式：

{"age":12,"books":[{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}],"name":"zhangsan"}

json数组格式：

[{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}]

3. json和java

3.1 json和Java的关系如何？

  1. json格式中的值不区分整型还是浮点型、小数等，统一使用Number类型表示数组。
  2. json中的array表示数组，以中括号”[]”括起来，元素之间以逗号分隔，元素可以为任意类型。
  3. json中的object表示对象，以大括号”{}”括起来，类似C语言中的结构体。其元素要求为键值对，key必须是String类型（有双引号），value可以为上述几种值类型。key和value之间以冒号:表示映射关系，元组之间也是以逗号分隔。
  4. json中的object表示对象，类似于java中的通用对象map；json中的array表示数组，类似java中的list。
    延展：实际上json的对象形式和数组形式，在java中都有对应的表示方式。
    那为啥还需要第三方类库的支持呢？
    fastJson搞出了JSONObject对象和JSONArray数组对象来分表映射json中的object和array，这俩对象能够方便的将java数组、java对象、java集合等和对应的json串进行转换。
    而java本身的api并没有提供这种直接转换的能力。

3.2 进入fastJson的世界

fastJson的核心类有两个：
JSONObject类：

public class JSONObject extends JSON implements Ma<String, Object>, JSONAware, Cloneable, Serializable, InvocationHandler

JSONArray类：

public class JSONArray extends JSON implements List<Object>, JSONAware, Cloneable, RandomAccess, Serializable

3.3 fastJson主要干了些啥事情？

fastJson依靠核心的两个对象JSONObject和JSONArray，主要作为中间桥梁，在java对象和json格式串之间进行转换：

  1. JSONObject对象可以和json串之间互相转换。
  2. JSONObject对象可以和java对象之间互相转换。
  3. JSONArray对象可以和json数组串之间互相转换。
  4. JSONArray对象可以和java数组或者List之间互相转换。
tips:
json的开源包很多，而且里面的api很丰富，容易让人绕晕。
我们在使用时，只需要把握一个原则，那就是这些api是作为中间桥梁，来为json原生串和java对象之间做转换的。
也就是这个桥梁向左可以和javabean之间互相转换，向右可以和json传之间互相转换。

4. fastJson常见api探究

4.1 JSONObject对象和json对象串互相转换，JSONArray对象和json数组串互相转换

JSONObject对象和json对象串互相转换，JSONArray对象和json数组串互相转换

/**
 * 功能描述
 * JSONObject对象和json串之间互相转换
 * JSONArray对象和json数组串之间互相转换
 *
 * @author zWX5331241
 * @since 2021-04-19
 */
public class FastJsonTest {
    public static void main(String[] args) {
        jsonObjectAndArray2jsonStr();
        System.out.println("----------------------------------");
        jsonStr2jsonObjectAndArray();
    }
    // 案例1：JSONObject对象转换为json对象串；JSONArray对象转换为json数组串
    public static void jsonObjectAndArray2jsonStr() {
        // 直接构造一个Json对象，将json对象转换为json串
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name", "zhangsan");
        jsonObject.put("age", 12);
        // 构造多个内部json对象，组成数组
        JSONObject innerJsonObject1 = new JSONObject();
        innerJsonObject1.put("bookName", "平凡的世界");
        innerJsonObject1.put("bookPrice", 109.0d);
        JSONObject innerJsonObject2 = new JSONObject();
        innerJsonObject2.put("bookName", "凡尔赛装逼大全");
        innerJsonObject2.put("bookPrice", 17.0d);
        JSONObject innerJsonObject3 = new JSONObject();
        innerJsonObject3.put("bookName", "第121个老婆");
        innerJsonObject3.put("bookPrice", 90.0d);
        // 构造一个json数组对象，封装上面多个json对象
        JSONArray jsonArray = new JSONArray();
        jsonArray.add(innerJsonObject1);
        jsonArray.add(innerJsonObject2);
        jsonArray.add(innerJsonObject3);
        // 将这个json数组对象封装到最上面的json对象中去
        jsonObject.put("books", jsonArray);
        // 将json对象转换为json串，注意，toString和toJsonString的实现完全一样。
        System.out.println(jsonObject.toJSONString());
        System.out.println(jsonObject.toString());
        // 将json数组对象转换为json数组串，注意，toString和toJsonString的实现完全一样。
        System.out.println(jsonArray.toJSONString());
        System.out.println(jsonArray.toString());
    }
    //  案例2：json对象串转换为JSONObject对象；json数组串转换为JSONArray对象
    public static void jsonStr2jsonObjectAndArray() {
        String jsonStr = "{\"age\":12,\"books\":[{\"bookName\":\"平凡的世界\",\"bookPrice\":109},{\"bookName\":\"凡尔赛装逼大全\",\"bookPrice\":17},{\"bookName\":\"第121个老婆\",\"bookPrice\":90}],\"name\":\"zhangsan\"}";
        String jsonArrayStr = "[{\"bookName\":\"平凡的世界\",\"bookPrice\":109},{\"bookName\":\"凡尔赛装逼大全\",\"bookPrice\":17},{\"bookName\":\"第121个老婆\",\"bookPrice\":90}]";
        // 将json对象串转换为JSONObject对象，使用JSONObject的静态方法parseObject进行。
        JSONObject jsonObject = JSONObject.parseObject(jsonStr);
        // 将json数组串转换为JSONArray对象，使用JSONArray的静态方法parseArray进行。
        JSONArray jsonArray = JSONArray.parseArray(jsonArrayStr);
        System.out.println(jsonObject);
        System.out.println(jsonArray);
    }
}

测试结果:

{"age":12,"books":[{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}],"name":"zhangsan"}
{"age":12,"books":[{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}],"name":"zhangsan"}
[{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}]
[{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}]
----------------------------------
{"age":12,"books":[{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}],"name":"zhangsan"}
[{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}]

4.2 JSONObject对象和map对象互相转换，JSONArray对象和list对象互相转换

我们从JSONObject类的定义和JSONArray类的定义就可以知道，JSONObject类实际上是Map接口的一个实现类，JSONArray类实际上是List接口的一个实现类，因此这两者之间可以转换。
但实际上一般没有人直接跟map或者list进行转换，而是直接和javabean之间进行转换。
我们先来看和map与list的转换。

JSONObject对象和map对象互相转换，JSONArray对象和list对象互相转换:

package zeh.test.demo.com.json.test;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * 功能描述
 * JSONObject对象和map对象互相转换
 * JSONArray对象和list对象互相转换
 *
 * @author zWX5331241
 * @since 2021-04-19
 */
public class FastJsonTest {
    public static void main(String[] args) {
        jsonObjectAndArray2javaBean();
        System.out.println("----------------------------------");
        mapAndList2jsonObjectAndArray();
    }
    // 案例1：JSONObject对象转换为map对象；JSONArray对象转换为list对象
    public static void jsonObjectAndArray2javaBean() {
        // 直接构造一个Json对象，将json对象转换为json串
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name", "zhangsan");
        jsonObject.put("age", 12);
        // 构造多个内部json对象，组成数组
        JSONObject innerJsonObject1 = new JSONObject();
        innerJsonObject1.put("bookName", "平凡的世界");
        innerJsonObject1.put("bookPrice", 109.0d);
        JSONObject innerJsonObject2 = new JSONObject();
        innerJsonObject2.put("bookName", "凡尔赛装逼大全");
        innerJsonObject2.put("bookPrice", 17.0d);
        JSONObject innerJsonObject3 = new JSONObject();
        innerJsonObject3.put("bookName", "第121个老婆");
        innerJsonObject3.put("bookPrice", 90.0d);
        // 构造一个json数组对象，封装上面多个json对象
        JSONArray jsonArray = new JSONArray();
        jsonArray.add(innerJsonObject1);
        jsonArray.add(innerJsonObject2);
        jsonArray.add(innerJsonObject3);
        // 将这个json数组对象封装到最上面的json对象中去
        jsonObject.put("books", jsonArray);
        // 将jsonObject对象转换为map对象
        Map&lt;String, Object&gt; map = (Map) jsonObject;
        // 将jsonArray对象转换为list对象
        List&lt;Object> list = (List) jsonArray;
        System.out.println(map);
        System.out.println(list);
    }
    //  案例2：map对象转换为JSONObject对象；list对象转换为JSONArray对象
    public static void mapAndList2jsonObjectAndArray() {
        Map&lt;String, Object&gt; map = new HashMap<>();
        map.put("name", "lisi");
        map.put("age", 25);
        // 构造多个内部map对象，组成数组
        Map&lt;String, Object&gt; innerMap1 = new HashMap<>();
        innerMap1.put("bookName", "玛瑙河边的少女");
        innerMap1.put("bookPrice", 20.0d);
        Map&lt;String, Object&gt; innerMap2 = new HashMap<>();
        innerMap2.put("bookName", "一千零一夜");
        innerMap2.put("bookPrice", 12.5d);
        Map&lt;String, Object&gt; innerMap3 = new HashMap<>();
        innerMap3.put("bookName", "再见，若兰");
        innerMap3.put("bookPrice", 100.5d);
        // 构造一个List数组对象，封装上面多个json对象
        List&lt;Object&gt; list = new ArrayList<>();
        list.add(innerMap1);
        list.add(innerMap2);
        list.add(innerMap3);
        // 将这个json数组对象封装到最上面的json对象中去
        map.put("books", list);
        // 将map对象转换为JSONObject对象
        JSONObject jsonObject = (JSONObject) JSONObject.toJSON(map);
        System.out.println(jsonObject);
        // 还可以直接通过构造进行转换
        jsonObject = new JSONObject(map);
        System.out.println(jsonObject);
        // 将list对象转换为JSONArray对象
        JSONArray jsonArray = (JSONArray) JSONArray.toJSON(list);
        System.out.println(jsonArray);
        // 还可以直接通过构造进行转换
        jsonArray = new JSONArray(list);
        System.out.println(jsonArray);
    }
}

测试结果:

{"age":12,"books":[{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}],"name":"zhangsan"}
[{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}]
----------------------------------
{"age":25,"books":[{"bookName":"玛瑙河边的少女","bookPrice":20},{"bookName":"一千零一夜","bookPrice":12.5},{"bookName":"再见，若兰","bookPrice":100.5}],"name":"lisi"}
{"age":25,"books":[{"bookName":"玛瑙河边的少女","bookPrice":20},{"bookName":"一千零一夜","bookPrice":12.5},{"bookName":"再见，若兰","bookPrice":100.5}],"name":"lisi"}
[{"bookName":"玛瑙河边的少女","bookPrice":20},{"bookName":"一千零一夜","bookPrice":12.5},{"bookName":"再见，若兰","bookPrice":100.5}]
[{"bookName":"玛瑙河边的少女","bookPrice":20},{"bookName":"一千零一夜","bookPrice":12.5},{"bookName":"再见，若兰","bookPrice":100.5}]

4.3 —

   layout:     post
   title:      fastJson
   subtitle:   fastJson是java的json框架之一
   date:       2021-05-02
   author:     zhaoeh
   header-img: img/post-bg-myself9.jpg
   catalog: true
   tags:
       - Json
   ---
       
   # 1. fastJson简介
   ## 1.1 什么是fastJson？
   fastJson是alibaba的一个针对json的开源类库。  
   其中提供了json字符串和java对象之间的各种转换方式。  
   fastJson效率极高。  
   
   ## 1.2 所需的jar
   如要使用fastJson，则需要导入fastjson.jar，选择最新版本即可。  
   
   # 2. 回顾json
   ## 2.1 回顾json的数据类型
   1.  Number：数字型。  
   2.  String：字符串型。  
   3.  Boolean：布尔型。  
   4.  Array：数组。  
   5.  Object：对象。  
   6.  null：空值。  
   
   ## 2.2 回顾json格式串
   json对象格式：  
   ```json
   {"age":12,"books":[{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}],"name":"zhangsan"}
   ```
   
   json数组格式：  
   ```json
   [{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}]
   ```
   
   # 3. json和java
   ## 3.1 json和Java的关系如何？
   1.  json格式中的值不区分整型还是浮点型、小数等，统一使用Number类型表示数组。  
   2.  json中的array表示数组，以中括号"[]"括起来，元素之间以逗号分隔，元素可以为任意类型。  
   3.  json中的object表示对象，以大括号"{}"括起来，类似C语言中的结构体。其元素要求为键值对，key必须是String类型（有双引号），value可以为上述几种值类型。key和value之间以冒号:表示映射关系，元组之间也是以逗号分隔。  
   4.  json中的object表示对象，类似于java中的通用对象map；json中的array表示数组，类似java中的list。  
   延展：实际上json的对象形式和数组形式，在java中都有对应的表示方式。  
   那为啥还需要第三方类库的支持呢？  
   fastJson搞出了JSONObject对象和JSONArray数组对象来分表映射json中的object和array，这俩对象能够方便的将java数组、java对象、java集合等和对应的json串进行转换。  
   而java本身的api并没有提供这种直接转换的能力。  
   
   ## 3.2 进入fastJson的世界
   fastJson的核心类有两个：  
   JSONObject类：
   ```java
   public class JSONObject extends JSON implements Ma<String, Object>, JSONAware, Cloneable, Serializable, InvocationHandler
   ```
   JSONArray类：  
   ```java
   public class JSONArray extends JSON implements List<Object>, JSONAware, Cloneable, RandomAccess, Serializable
   ```
   
   ## 3.3  fastJson主要干了些啥事情？
   fastJson依靠核心的两个对象JSONObject和JSONArray，主要作为中间桥梁，在java对象和json格式串之间进行转换：  
   1.  JSONObject对象可以和json串之间互相转换。  
   2.  JSONObject对象可以和java对象之间互相转换。  
   3.  JSONArray对象可以和json数组串之间互相转换。  
   4.  JSONArray对象可以和java数组或者List之间互相转换。  
   
   ```
   tips:
   json的开源包很多，而且里面的api很丰富，容易让人绕晕。
   我们在使用时，只需要把握一个原则，那就是这些api是作为中间桥梁，来为json原生串和java对象之间做转换的。
   也就是这个桥梁向左可以和javabean之间互相转换，向右可以和json传之间互相转换。
   ```
   
   # 4. fastJson常见api探究
   ## 4.1 JSONObject对象和json对象串互相转换，JSONArray对象和json数组串互相转换
   JSONObject对象和json对象串互相转换，JSONArray对象和json数组串互相转换  
   ```java
   /**
    * 功能描述
    * JSONObject对象和json串之间互相转换
    * JSONArray对象和json数组串之间互相转换
    *
    * @author zWX5331241
    * @since 2021-04-19
    */
   public class FastJsonTest {
       public static void main(String[] args) {
           jsonObjectAndArray2jsonStr();
           System.out.println("----------------------------------");
           jsonStr2jsonObjectAndArray();
       }
       // 案例1：JSONObject对象转换为json对象串；JSONArray对象转换为json数组串
       public static void jsonObjectAndArray2jsonStr() {
           // 直接构造一个Json对象，将json对象转换为json串
           JSONObject jsonObject = new JSONObject();
           jsonObject.put("name", "zhangsan");
           jsonObject.put("age", 12);
           // 构造多个内部json对象，组成数组
           JSONObject innerJsonObject1 = new JSONObject();
           innerJsonObject1.put("bookName", "平凡的世界");
           innerJsonObject1.put("bookPrice", 109.0d);
           JSONObject innerJsonObject2 = new JSONObject();
           innerJsonObject2.put("bookName", "凡尔赛装逼大全");
           innerJsonObject2.put("bookPrice", 17.0d);
           JSONObject innerJsonObject3 = new JSONObject();
           innerJsonObject3.put("bookName", "第121个老婆");
           innerJsonObject3.put("bookPrice", 90.0d);
           // 构造一个json数组对象，封装上面多个json对象
           JSONArray jsonArray = new JSONArray();
           jsonArray.add(innerJsonObject1);
           jsonArray.add(innerJsonObject2);
           jsonArray.add(innerJsonObject3);
           // 将这个json数组对象封装到最上面的json对象中去
           jsonObject.put("books", jsonArray);
           // 将json对象转换为json串，注意，toString和toJsonString的实现完全一样。
           System.out.println(jsonObject.toJSONString());
           System.out.println(jsonObject.toString());
           // 将json数组对象转换为json数组串，注意，toString和toJsonString的实现完全一样。
           System.out.println(jsonArray.toJSONString());
           System.out.println(jsonArray.toString());
       }
       //  案例2：json对象串转换为JSONObject对象；json数组串转换为JSONArray对象
       public static void jsonStr2jsonObjectAndArray() {
           String jsonStr = "{\"age\":12,\"books\":[{\"bookName\":\"平凡的世界\",\"bookPrice\":109},{\"bookName\":\"凡尔赛装逼大全\",\"bookPrice\":17},{\"bookName\":\"第121个老婆\",\"bookPrice\":90}],\"name\":\"zhangsan\"}";
           String jsonArrayStr = "[{\"bookName\":\"平凡的世界\",\"bookPrice\":109},{\"bookName\":\"凡尔赛装逼大全\",\"bookPrice\":17},{\"bookName\":\"第121个老婆\",\"bookPrice\":90}]";
           // 将json对象串转换为JSONObject对象，使用JSONObject的静态方法parseObject进行。
           JSONObject jsonObject = JSONObject.parseObject(jsonStr);
           // 将json数组串转换为JSONArray对象，使用JSONArray的静态方法parseArray进行。
           JSONArray jsonArray = JSONArray.parseArray(jsonArrayStr);
           System.out.println(jsonObject);
           System.out.println(jsonArray);
       }
   }
   ```
   测试结果:  
   ```
   {"age":12,"books":[{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}],"name":"zhangsan"}
   {"age":12,"books":[{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}],"name":"zhangsan"}
   [{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}]
   [{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}]
   ----------------------------------
   {"age":12,"books":[{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}],"name":"zhangsan"}
   [{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}]
   ```
   
   ## 4.2 JSONObject对象和map对象互相转换，JSONArray对象和list对象互相转换  
   我们从JSONObject类的定义和JSONArray类的定义就可以知道，JSONObject类实际上是Map接口的一个实现类，JSONArray类实际上是List接口的一个实现类，因此这两者之间可以转换。  
   但实际上一般没有人直接跟map或者list进行转换，而是直接和javabean之间进行转换。  
   我们先来看和map与list的转换。  
   
   JSONObject对象和map对象互相转换，JSONArray对象和list对象互相转换:  
   ```java
   package zeh.test.demo.com.json.test;
   import com.alibaba.fastjson.JSONArray;
   import com.alibaba.fastjson.JSONObject;
   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   /**
    * 功能描述
    * JSONObject对象和map对象互相转换
    * JSONArray对象和list对象互相转换
    *
    * @author zWX5331241
    * @since 2021-04-19
    */
   public class FastJsonTest {
       public static void main(String[] args) {
           jsonObjectAndArray2javaBean();
           System.out.println("----------------------------------");
           mapAndList2jsonObjectAndArray();
       }
       // 案例1：JSONObject对象转换为map对象；JSONArray对象转换为list对象
       public static void jsonObjectAndArray2javaBean() {
           // 直接构造一个Json对象，将json对象转换为json串
           JSONObject jsonObject = new JSONObject();
           jsonObject.put("name", "zhangsan");
           jsonObject.put("age", 12);
           // 构造多个内部json对象，组成数组
           JSONObject innerJsonObject1 = new JSONObject();
           innerJsonObject1.put("bookName", "平凡的世界");
           innerJsonObject1.put("bookPrice", 109.0d);
           JSONObject innerJsonObject2 = new JSONObject();
           innerJsonObject2.put("bookName", "凡尔赛装逼大全");
           innerJsonObject2.put("bookPrice", 17.0d);
           JSONObject innerJsonObject3 = new JSONObject();
           innerJsonObject3.put("bookName", "第121个老婆");
           innerJsonObject3.put("bookPrice", 90.0d);
           // 构造一个json数组对象，封装上面多个json对象
           JSONArray jsonArray = new JSONArray();
           jsonArray.add(innerJsonObject1);
           jsonArray.add(innerJsonObject2);
           jsonArray.add(innerJsonObject3);
           // 将这个json数组对象封装到最上面的json对象中去
           jsonObject.put("books", jsonArray);
           // 将jsonObject对象转换为map对象
           Map&lt;String, Object&gt; map = (Map) jsonObject;
           // 将jsonArray对象转换为list对象
           List&lt;Object> list = (List) jsonArray;
           System.out.println(map);
           System.out.println(list);
       }
       //  案例2：map对象转换为JSONObject对象；list对象转换为JSONArray对象
       public static void mapAndList2jsonObjectAndArray() {
           Map&lt;String, Object&gt; map = new HashMap<>();
           map.put("name", "lisi");
           map.put("age", 25);
           // 构造多个内部map对象，组成数组
           Map&lt;String, Object&gt; innerMap1 = new HashMap<>();
           innerMap1.put("bookName", "玛瑙河边的少女");
           innerMap1.put("bookPrice", 20.0d);
           Map&lt;String, Object&gt; innerMap2 = new HashMap<>();
           innerMap2.put("bookName", "一千零一夜");
           innerMap2.put("bookPrice", 12.5d);
           Map&lt;String, Object&gt; innerMap3 = new HashMap<>();
           innerMap3.put("bookName", "再见，若兰");
           innerMap3.put("bookPrice", 100.5d);
           // 构造一个List数组对象，封装上面多个json对象
           List&lt;Object&gt; list = new ArrayList<>();
           list.add(innerMap1);
           list.add(innerMap2);
           list.add(innerMap3);
           // 将这个json数组对象封装到最上面的json对象中去
           map.put("books", list);
           // 将map对象转换为JSONObject对象
           JSONObject jsonObject = (JSONObject) JSONObject.toJSON(map);
           System.out.println(jsonObject);
           // 还可以直接通过构造进行转换
           jsonObject = new JSONObject(map);
           System.out.println(jsonObject);
           // 将list对象转换为JSONArray对象
           JSONArray jsonArray = (JSONArray) JSONArray.toJSON(list);
           System.out.println(jsonArray);
           // 还可以直接通过构造进行转换
           jsonArray = new JSONArray(list);
           System.out.println(jsonArray);
       }
   }
   ```
   测试结果:  
   ```
   {"age":12,"books":[{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}],"name":"zhangsan"}
   [{"bookName":"平凡的世界","bookPrice":109},{"bookName":"凡尔赛装逼大全","bookPrice":17},{"bookName":"第121个老婆","bookPrice":90}]
   ----------------------------------
   {"age":25,"books":[{"bookName":"玛瑙河边的少女","bookPrice":20},{"bookName":"一千零一夜","bookPrice":12.5},{"bookName":"再见，若兰","bookPrice":100.5}],"name":"lisi"}
   {"age":25,"books":[{"bookName":"玛瑙河边的少女","bookPrice":20},{"bookName":"一千零一夜","bookPrice":12.5},{"bookName":"再见，若兰","bookPrice":100.5}],"name":"lisi"}
   [{"bookName":"玛瑙河边的少女","bookPrice":20},{"bookName":"一千零一夜","bookPrice":12.5},{"bookName":"再见，若兰","bookPrice":100.5}]
   [{"bookName":"玛瑙河边的少女","bookPrice":20},{"bookName":"一千零一夜","bookPrice":12.5},{"bookName":"再见，若兰","bookPrice":100.5}]
   ```  ## 4.3 JSONArray对象和java数组对象互相转换  既然jsonArray对象都能和list进行转换，而java中的list能直接和数组进行转换，因此，jsonArray对象能和java数组对象之间互相转换。

JSONArray对象和java数组对象互相转换:

package zeh.test.demo.com.json.test;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
/**
 * 功能描述
 * JSONArray对象和java数组互相转换
 *
 * @author zWX5331241
 * @since 2021-04-19
 */
public class FastJsonTest {
    public static void main(String[] args) {
        jsonArray2javaArray();
        System.out.println("----------------------------------");
        javaArray2jsonArray();
    }
    // 案例1：JSONArray对象转换为java数组对象
    public static void jsonArray2javaArray() {
        JSONObject innerJsonObject1 = new JSONObject();
        innerJsonObject1.put("bookName", "平凡的世界");
        innerJsonObject1.put("bookPrice", 109.0d);
        JSONObject innerJsonObject2 = new JSONObject();
        innerJsonObject2.put("bookName", "凡尔赛装逼大全");
        innerJsonObject2.put("bookPrice", 17.0d);
        JSONObject innerJsonObject3 = new JSONObject();
        innerJsonObject3.put("bookName", "第121个老婆");
        innerJsonObject3.put("bookPrice", 90.0d);
        JSONArray jsonArray = new JSONArray();
        jsonArray.add(innerJsonObject1);
        jsonArray.add(innerJsonObject2);
        jsonArray.add(innerJsonObject3);
        // jsonArray对象转换为java数组对象
        Object[] javaArrays = jsonArray.toArray();
        System.out.println(Arrays.toString(javaArrays));
    }
    //  案例2：java数组对象转换为JSONArray对象
    public static void javaArray2jsonArray() {
        Map&lt;String, Object&gt; innerMap1 = new HashMap<>();
        innerMap1.put("bookName", "玛瑙河边的少女");
        innerMap1.put("bookPrice", 20.0d);
        Map&lt;String, Object&gt; innerMap2 = new HashMap<>();
        innerMap2.put("bookName", "一千零一夜");
        innerMap2.put("bookPrice", 12.5d);
        Map&lt;String, Object&gt; innerMap3 = new HashMap<>();
        innerMap3.put("bookName", "再见，若兰");
        innerMap3.put("bookPrice", 100.5d);
        // 构造一个java数组对象，封装上面多个json对象
        Object[] objects = new Object[]{innerMap1,innerMap2,innerMap3};
        // java数组对象转换为jsonArray对象
        JSONArray jsonArray = (JSONArray) JSONArray.toJSON(objects);
        System.out.println(jsonArray);
    }
}

测试结果:

[{"bookName":"平凡的世界","bookPrice":109}, {"bookName":"凡尔赛装逼大全","bookPrice":17}, {"bookName":"第121个老婆","bookPrice":90}]
----------------------------------
[{"bookName":"玛瑙河边的少女","bookPrice":20},{"bookName":"一千零一夜","bookPrice":12.5},{"bookName":"再见，若兰","bookPrice":100.5}]

4.4 JSONObject对象和javabean对象互相转换，JSONArray对象和对象数组互相转换

既然jsonArray对象都能和list进行转换，而java中的list能直接和数组进行转换，因此，jsonArray对象能和java数组对象之间互相转换。

JSONArray对象和java数组对象互相转换:

5. fastJson指定某个字段不参与序列化和反序列化

在使用fastJson将json字符串反序列化为java对象，或者将java对象序列化为json字符串时，有时候我们需要指定某个字段或者某些字段不参与fastJson的序列化和反序列化，这个时候可以通过fastJson提供的注解来进行指定。
在 fastJson 中，如果你想指定某个实体类的字段不参与序列化，你可以使用 @JSONField 注解来实现。该注解可以应用于类的字段，并通过设置 serialize 属性为 false 来跳过该字段的序列化。

例如：

import com.alibaba.fastjson.annotation.JSONField;

public class User {
    private String name;

    @JSONField(serialize = false)
    private String password;

    public User(String name, String password) {
        this.name = name;
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

在这个例子中，password 字段不会被序列化。

测试代码：

import com.alibaba.fastjson.JSONObject;

public class Main {
    public static void main(String[] args) {
        User user = new User("John", "secret123");
        String jsonString = JSONObject.toJSONString(user);
        System.out.println(jsonString);  // 输出 {"name":"John"}
    }
}

这里，password 字段将不会出现在生成的 JSON 字符串中。

6. JSONObject在序列化时会默认忽略null值吗？

如果你使用的是 JSONObject.toJSONString 方法，通常你指的是 fastjson 提供的 JSONObject 类。fastjson 中的 toJSONString 方法在将 Map 转换为 JSON 字符串时，不会自动删除 null 值的键，默认情况下会保留它们并将其值序列化为 null。

示例

import com.alibaba.fastjson.JSONObject;
import java.util.HashMap;
import java.util.Map;

public class FastjsonExample {
    public static void main(String[] args) {
        Map<String, Object> map = new HashMap<>();
        map.put("key1", "value1");
        map.put("key2", null);  // 值为null

        // 将Map转换为JSON字符串
        String jsonString = JSONObject.toJSONString(map);
        System.out.println(jsonString);  // 输出 {"key1":"value1","key2":null}
    }
}

输出：

{"key1":"value1","key2":null}

可以看到，fastjson 的 JSONObject.toJSONString() 方法会保留 null 值的键，并将它们的值序列化为 null。

如果你希望删除 null 值的键

fastjson 提供了一些配置项，允许你自定义序列化行为。如果你希望在序列化时忽略 null 值的键，可以使用 SerializerFeature 进行配置。例如，可以通过 SerializerFeature.SkipTransientField 或者 SerializerFeature.WriteMapNullValue 来控制是否输出 null 值。

要删除 null 值的键，可以禁用 SerializerFeature.WriteMapNullValue：

示例：忽略 null 值的键

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import java.util.HashMap;
import java.util.Map;

public class FastjsonIgnoreNullExample {
    public static void main(String[] args) {
        Map<String, Object> map = new HashMap<>();
        map.put("key1", "value1");
        map.put("key2", null);  // 值为null

        // 使用 SerializerFeature 进行配置，忽略 null 值的键
        String jsonString = JSONObject.toJSONString(map, SerializerFeature.SkipTransientField);
        System.out.println(jsonString);  // 输出 {"key1":"value1"}
    }
}

输出：

{"key1":"value1"}

总结

  • 默认情况下，fastjson 的 JSONObject.toJSONString() 方法会保留 null 值的键，并将它们序列化为 null。
  • 如果你希望在序列化时忽略 null 值的键，可以通过 SerializerFeature 禁用 WriteMapNullValue 特性，使用例如 SerializerFeature.SkipTransientField 来过滤掉 null 值。

但是我现在使用JSONObject.toJSONString它自动去除了value为null的键值对

如果你在使用 fastjson 的 JSONObject.toJSONString() 方法时，发现它自动去除了 value 为 null 的键值对，这是因为 fastjson 的默认行为是忽略 null 值的键值对，即默认情况下 SerializerFeature.WriteMapNullValue 不是启用的。

fastjson 的 toJSONString() 方法默认会跳过那些 null 值的键。如果你想保留 null 值的键值对，需要显式地启用 SerializerFeature.WriteMapNullValue。

保留 null 值键的解决方案

你可以通过指定 SerializerFeature.WriteMapNullValue 选项来让 fastjson 保留 null 值的键值对。

示例

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import java.util.HashMap;
import java.util.Map;

public class FastjsonWriteMapNullValueExample {
    public static void main(String[] args) {
        Map<String, Object> map = new HashMap<>();
        map.put("key1", "value1");
        map.put("key2", null);  // 值为null

        // 使用 SerializerFeature.WriteMapNullValue 保留 null 值的键
        String jsonString = JSONObject.toJSONString(map, SerializerFeature.WriteMapNullValue);
        System.out.println(jsonString);  // 输出 {"key1":"value1","key2":null}
    }
}

输出：

{"key1":"value1","key2":null}

原因解释

  • 默认行为: fastjson 默认会去除值为 null 的键。这是为了在序列化时简化输出，减少不必要的 null 值。
  • 启用 WriteMapNullValue: 通过显式设置 SerializerFeature.WriteMapNullValue，可以让 fastjson 序列化时保留 null 值的键。

总结

  • 默认情况下，JSONObject.toJSONString() 会自动去除 value 为 null 的键值对。
  • 要保留这些键值对，可以在 toJSONString() 方法中指定 SerializerFeature.WriteMapNullValue。

7. 那有没有其他方式，将map转换为字符串时保留null值的？

除了使用 fastjson 的 SerializerFeature.WriteMapNullValue 来保留 null 值以外，还可以通过其他方式将 Map 转换为字符串并保留 null 值。例如，使用 Java 的 Jackson 库也可以达到这个目的。

1. 使用 fastjson 保留 null 值

我们已经讨论过，使用 fastjson 需要显式地指定 SerializerFeature.WriteMapNullValue。

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import java.util.HashMap;
import java.util.Map;

public class FastjsonExample {
    public static void main(String[] args) {
        Map<String, Object> map = new HashMap<>();
        map.put("key1", "value1");
        map.put("key2", null);  // 值为null

        // 使用 fastjson 的 WriteMapNullValue 选项保留 null 值
        String jsonString = JSONObject.toJSONString(map, SerializerFeature.WriteMapNullValue);
        System.out.println(jsonString);  // 输出 {"key1":"value1","key2":null}
    }
}

2. 使用 Jackson 保留 null 值

如果你更倾向于使用 Jackson 库，也可以轻松实现保留 null 值的功能，Jackson 的默认行为是保留 null 值，所以无需额外配置。

添加 Jackson 依赖（Maven）

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.0</version>
</dependency>

示例

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;

public class JacksonExample {
    public static void main(String[] args) throws Exception {
        Map<String, Object> map = new HashMap<>();
        map.put("key1", "value1");
        map.put("key2", null);  // 值为null

        // 使用 Jackson 将 Map 转换为 JSON 字符串
        ObjectMapper objectMapper = new ObjectMapper();
        String jsonString = objectMapper.writeValueAsString(map);
        System.out.println(jsonString);  // 输出 {"key1":"value1","key2":null}
    }
}

在这个例子中，Jackson 会保留 null 值，并且默认行为不会删除键值对。

3. 手动实现

如果你不想依赖外部库，也可以通过手动遍历 Map 来构建一个带有 null 值的 JSON 字符串。尽管这种方式更冗长，但可以控制所有细节。

import java.util.HashMap;
import java.util.Map;

public class ManualJsonExample {
    public static void main(String[] args) {
        Map<String, Object> map = new HashMap<>();
        map.put("key1", "value1");
        map.put("key2", null);  // 值为null

        StringBuilder jsonBuilder = new StringBuilder("{");
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            jsonBuilder.append("\"").append(entry.getKey()).append("\":");
            if (entry.getValue() == null) {
                jsonBuilder.append("null");
            } else {
                jsonBuilder.append("\"").append(entry.getValue()).append("\"");
            }
            jsonBuilder.append(",");
        }
        // 删除最后一个逗号，并关闭 JSON 对象
        if (jsonBuilder.length() > 1) {
            jsonBuilder.setLength(jsonBuilder.length() - 1);
        }
        jsonBuilder.append("}");

        String jsonString = jsonBuilder.toString();
        System.out.println(jsonString);  // 输出 {"key1":"value1","key2":null}
    }
}

总结

  • fastjson：可以通过 SerializerFeature.WriteMapNullValue 保留 null 值。
  • Jackson：默认保留 null 值，简单易用。
  • 手动实现：如果不想依赖第三方库，可以通过遍历 Map 手动构建 JSON 字符串，保留 null 值。

你可以根据你的项目需求选择适合的方式。

8. FastJson在将java对象序列化为字符串时如何忽略某些字段的打印呢？

你可以使用 FastJson 的 @JSONField 注解来控制序列化时是否忽略某些字段的打印。具体步骤如下：

  1. 在需要忽略的字段上添加 @JSONField(serialize = false) 注解，这样 FastJson 在序列化时会忽略该字段。
  2. 如果需要在特定条件下忽略某些字段，可以使用 @JSONField(serialize = false) 注解配合条件判断逻辑，动态控制是否序列化该字段。

例如，假设有一个 Java 类 User，其中有一个字段 password 需要在序列化时忽略打印：

import com.alibaba.fastjson.annotation.JSONField;

public class User {
    private String username;
    @JSONField(serialize = false)
    private String password;

    // 省略其他代码和构造函数

    // getter 和 setter 方法
}

这样，在使用 FastJson 序列化 User 对象时，password 字段将被忽略打印。

9. 不好意思，我收到的就是JSONObject对象

对于使用 FastJson 的 JSONObject 对象，你可以使用 JSONObject 的 fluentPut 方法来构建 JSONObject，并在其中添加需要打印的字段，忽略不需要打印的字段。具体步骤如下：

  1. 使用 fluentPut 方法添加需要打印的字段。
  2. 使用 fluentPut 方法添加需要忽略的字段，并设置其值为 null 或者直接不添加该字段。

例如，假设有一个 JSONObject 对象 userJson，需要忽略打印 password 字段：

import com.alibaba.fastjson.JSONObject;

public class Main {
    public static void main(String[] args) {
        JSONObject userJson = new JSONObject()
            .fluentPut("username", "user123")
            .fluentPut("email", "user123@example.com")
            // 忽略打印密码字段
            .fluentPut("password", null);

        System.out.println(userJson.toJSONString());
    }
}

在这个例子中，password 字段被设置为 null，在打印 userJson 对象时将被忽略。

10. 但我仅仅知道这个对象里面的password是固定的，其他字段不是固定的

如果你只知道要忽略的字段名（如password）是固定的，而其他字段不确定，可以使用JSONObject的remove方法来移除需要忽略的字段。例如：

import com.alibaba.fastjson.JSONObject;

public class Main {
    public static void main(String[] args) {
        JSONObject userJson = new JSONObject()
            .fluentPut("username", "user123")
            .fluentPut("email", "user123@example.com")
            .fluentPut("password", "password123");

        // 移除需要忽略的字段
        userJson.remove("password");

        System.out.println(userJson.toJSONString());
    }
}

在这个例子中，通过remove方法移除了名为password的字段，这样在打印userJson对象时，password字段将被忽略。

11. 我只是想在打印日志的时候忽略password，但是在其他使用这个消息的地方还需要正常使用

在打印日志时忽略 password 字段，但在其他使用该消息的地方保留 password 字段，你可以使用以下方法：

  1. 在打印日志之前，将 password 字段从 JSONObject 对象中移除。
  2. 在其他需要使用完整消息的地方，使用原始的 JSONObject 对象。

示例代码如下：

import com.alibaba.fastjson.JSONObject;

public class Main {
    public static void main(String[] args) {
        JSONObject userJson = new JSONObject()
            .fluentPut("username", "user123")
            .fluentPut("email", "user123@example.com")
            .fluentPut("password", "password123");

        // 备份原始的JSONObject对象
        JSONObject logJson = new JSONObject(userJson);

        // 移除需要忽略的字段
        userJson.remove("password");

        // 打印日志，使用移除了密码字段的JSONObject对象
        System.out.println("Logging: " + userJson.toJSONString());

        // 在其他使用消息的地方，使用原始的JSONObject对象
        System.out.println("Other usage: " + logJson.toJSONString());
    }
}

这样，在打印日志时会忽略 password 字段，而在其他地方使用时则包含完整的消息，包括 password 字段。

12. userJson中remove掉password，会影响logJson吗？

在示例代码中，logJson 是通过 new JSONObject(userJson) 创建的，这意味着它是一个新的 JSONObject 对象，与 userJson 相互独立。因此，对 userJson 中的 remove 操作不会影响 logJson，logJson 中仍然会保留 password 字段。

这种方式确保了在打印日志时忽略 password 字段，同时在其他地方仍然可以使用完整的消息，包括 password 字段。

13. 如果这个password字段不存在，直接remove会发生错误吗？

如果 password 字段在 JSONObject 中不存在，调用 remove 方法不会导致错误。实际上，remove 方法会检查要移除的字段是否存在，如果不存在，则不会执行任何操作，也不会抛出异常。因此，即使 password 字段不存在，调用 remove 方法也是安全的。

14. 还有其他方式吗？

另一种处理这种情况的方法是先检查 JSONObject 中是否包含 password 字段，如果存在则移除，否则不进行任何操作。这样可以避免因为字段不存在而导致的问题。示例代码如下：

import com.alibaba.fastjson.JSONObject;

public class Main {
    public static void main(String[] args) {
        JSONObject userJson = new JSONObject()
            .fluentPut("username", "user123")
            .fluentPut("email", "user123@example.com");

        // 备份原始的JSONObject对象
        JSONObject logJson = new JSONObject(userJson);

        // 检查是否存在密码字段，存在则移除
        if (userJson.containsKey("password")) {
            userJson.remove("password");
        }

        // 打印日志，使用移除了密码字段的JSONObject对象
        System.out.println("Logging: " + userJson.toJSONString());

        // 在其他使用消息的地方，使用原始的JSONObject对象
        System.out.println("Other usage: " + logJson.toJSONString());
    }
}

这种方法先检查字段是否存在，然后再进行移除操作，避免了因为字段不存在而导致的问题。

15. JSONObject对象的toJSONString方法如何忽略某些字段呢？

JSONObject 的 toJSONString 方法本身没有直接提供忽略某些字段的功能。但你可以通过其他方式实现这个需求，比如使用自定义的过滤器或者构建新的 JSONObject 对象来实现。

  1. 使用自定义过滤器：你可以实现一个自定义的过滤器，在序列化时根据条件决定是否包含某些字段。这可以通过实现 FastJson 的 ValueFilter 接口来实现。
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.ValueFilter;

public class Main {
    public static void main(String[] args) {
        JSONObject userJson = new JSONObject();
        userJson.put("username", "user123");
        userJson.put("email", "user123@example.com");
        userJson.put("password", "password123");

        // 使用自定义过滤器忽略指定字段
        String jsonString = userJson.toJSONString(new ValueFilter() {
            @Override
            public Object process(Object object, String name, Object value) {
                if ("password".equals(name)) {
                    return null; // 忽略密码字段
                }
                return value;
            }
        });

        System.out.println(jsonString);
    }
}
  1. 构建新的 JSONObject 对象：根据需要，你可以创建一个新的 JSONObject 对象，只包含需要的字段，然后对这个新对象进行序列化。
import com.alibaba.fastjson.JSONObject;

public class Main {
    public static void main(String[] args) {
        JSONObject userJson = new JSONObject();
        userJson.put("username", "user123");
        userJson.put("email", "user123@example.com");
        userJson.put("password", "password123");

        // 创建新的JSONObject对象，只包含需要的字段
        JSONObject filteredJson = new JSONObject();
        filteredJson.put("username", userJson.get("username"));
        filteredJson.put("email", userJson.get("email"));

        // 序列化新的JSONObject对象
        String jsonString = filteredJson.toJSONString();

        System.out.println(jsonString);
    }
}

这些方法都可以达到忽略某些字段的效果，你可以根据具体情况选择合适的方式。

文档信息

Search

    Table of Contents