fastjson的使用-＞JSON字符串、JSON对象、Java对象的互转

一、fastjson简介

fastjson是阿里出品的处理JSON字符串的Java类库，可以对JSON字符串、JSON对象、Java对象进行互相转换
源码地址：
https://github.com/alibaba/fastjson

二、依赖引用

如果使用的是maven，需要在pom.xml文件中加入依赖：

<dependency>
<groupId>com.alibabagroupId>
<artifactId>fastjsonartifactId>
<version>1.2.78version>
dependency>

如果使用的是gradle，需要在gradle.build文件中加入依赖：
implementation(“com.alibaba:fastjson:1.2.78”)

三、常用API

字符串转成JSON对象/数组
字符串转成JSON对象
JSON.parseObject(String text)
JSON.parse(String text)

字符串转成JSON数组
JSON.parseArray(String text)
JSON.parse(String text)

字符串转成Java对象/列表
字符串转成Java对象
JSON.parseObject(String text, Class clazz)

字符串转成Java对象列表
JSON.parseArray(String text, Class clazz)

Java对象/列表转成JSON对象/数组
Java对象转成JSON对象
JSONObject.toJSON(Object javaObject)
JSON.toJSON(Object javaObject)

Java对象列表转成JSON数组
JSONArray.toJSON(Object javaObject)
JSON.toJSON(Object javaObject)

JSON对象/数组转成Java对象/列表
JSON对象转成Java对象
JSON.toJavaObject(JSON json, Class clazz)
jsonObject.toJavaObject(JSON json) (非静态方法)

JSON数组转成Java对象列表
jsonArray.toJavaList(Class clazz) (非静态方法)

用两张图可以看的更清楚：

思维导图：

转换图：

四、代码实例

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import java.util.List;
 
public class FastJSONLearning {
  public static void main(String[] args) {
    String jsonObjectStr = "{\"prop\":\"code\",\"label\":\"代码\",\"required\":true,\"key\":true}";
    String jsonArrayStr = "[{\"prop\":\"code\",\"label\":\"代码\",\"required\":true,\"key\":true},{\"prop\":\"explain\",\"label\":\"中文释义\",\"required\":true}]";
 
    // 字符串转成JSON对象/数组
    // 字符串转成JSON对象
    // 方法1
    JSONObject jsonObject1 = JSON.parseObject(jsonObjectStr);
    System.out.println("字符串转成JSON对象: " + jsonObject1);
 
    // 方法2
    JSONObject jsonObject2 = (JSONObject) JSON.parse(jsonObjectStr);
    System.out.println("字符串转成JSON对象: " + jsonObject2);
 
    // 字符串转成JSON数组
    // 方法1
    JSONArray jsonArray1 = JSON.parseArray(jsonArrayStr);
    System.out.println("字符串转成JSON数组: " + jsonArray1);
 
    // 方法2
    JSONArray jsonArray2 = (JSONArray) JSON.parse(jsonArrayStr);
    System.out.println("字符串转成JSON数组: " + jsonArray2);
 
    // 字符串转成Java对象/列表
    // 字符串转成Java对象
    Dict dict = JSON.parseObject(jsonObjectStr, Dict.class);
    System.out.println("字符串转成Java对象: " + dict.toString());
 
    // 字符串转成Java对象列表
    List<Dict> dictList = JSON.parseArray(jsonArrayStr, Dict.class);
    System.out.println("字符串转成Java对象列表: " + dictList.toString());
 
    // Java对象/列表转成JSON对象/数组
    // Java对象转成JSON对象
    // 方法1
    JSONObject jsonObject3 = (JSONObject) JSONObject.toJSON(dict);
    System.out.println("Java对象转成JSON对象: " + jsonObject3.toJSONString());
 
    // 方法2
    JSONObject jsonObject4 = (JSONObject) JSON.toJSON(dict);
    System.out.println("Java对象转成JSON对象: " + jsonObject4.toJSONString());
 
    // Java对象列表转成JSON数组
    // 方法1
    JSONArray jsonArray3 = (JSONArray) JSONArray.toJSON(dictList);
    System.out.println("Java对象列表转成JSON数组: " + jsonArray3.toJSONString());
 
    // 方法2
    JSONArray jsonArray4 = (JSONArray) JSON.toJSON(dictList);
    System.out.println("Java对象列表转成JSON数组: " + jsonArray4.toJSONString());
 
    // JSON对象/数组转成Java对象/列表
    // JSON对象转成Java对象
    // 方法1
    Dict dict1 = JSON.toJavaObject(jsonObject1, Dict.class);
    System.out.println("JSON对象转成Java对象: " + dict1);
 
    // JSON对象转成Java对象
    // 方法2
    Dict dict2 = jsonObject1.toJavaObject(Dict.class);
    System.out.println("JSON对象转成Java对象: " + dict2);
 
    // JSON数组转成Java对象列表
    List<Dict> dictList1 = jsonArray1.toJavaList(Dict.class);
    System.out.println("JSON数组转成Java对象列表: " + dictList1);
  }
}

按照JSONArray中的对象的某个字段进行排序(采用fastJson)

/**
     * 按照JSONArray中的对象的某个字段进行排序(采用fastJson)
     * 
     * @param jsonArrStr -->需要排序的json数组字符串
     * 
     */
    public static String jsonArraySort(String jsonArrStr) {
        JSONArray jsonArr = JSON.parseArray(jsonArrStr);
        JSONArray sortedJsonArray = new JSONArray();
        List<JSONObject> jsonValues = new ArrayList<JSONObject>();
        for (int i = 0; i < jsonArr.size(); i++) {
            jsonValues.add(jsonArr.getJSONObject(i));
        }
        Collections.sort(jsonValues, new Comparator<JSONObject>() {
            // 根据time这个字段排序
            private static final String KEY_NAME = "time";

            @Override
            public int compare(JSONObject a, JSONObject b) {
                String valA = new String();
                String valB = new String();
                try {
                    // 这里是a、b需要处理的业务，需要根据你的规则进行修改。
                    String aStr = a.getString(KEY_NAME);
                    valA = aStr.replaceAll("-", "");
                    String bStr = b.getString(KEY_NAME);
                    valB = bStr.replaceAll("-", "");
                } catch (JSONException e) {
                    // do something
                }
                return -valA.compareTo(valB);
            }
        });
        for (int i = 0; i < jsonArr.size(); i++) {
            sortedJsonArray.add(jsonValues.get(i));
        }
        return sortedJsonArray.toString();
    }

封装好的代码函数

/**Description: is_desc-false升序列  is_desc-true降序 (排序字段为字符串)
*/
public static String jsonArraySort(JSONArray jsonArr,String sortKey,boolean is_desc) {
        JSONArray sortedJsonArray = new JSONArray();
        List<JSONObject> jsonValues = new ArrayList<JSONObject>();
        for (int i = 0; i < jsonArr.size(); i++) {
            jsonValues.add(jsonArr.getJSONObject(i));
        }
        Collections.sort(jsonValues, new Comparator<JSONObject>() {
            private  final String KEY_NAME = sortKey;

            @Override
            public int compare(JSONObject a, JSONObject b) {
                String valA = new String();
                String valB = new String();
                try {
                    valA = a.getString(KEY_NAME);
                    valB = b.getString(KEY_NAME);
                } catch (JSONException e) {
                    e.printStackTrace();
                }
                if (is_desc){
                    return -valA.compareTo(valB);
                } else {
                    return -valB.compareTo(valA);
                }

            }
        });
        for (int i = 0; i < jsonArr.size(); i++) {
            sortedJsonArray.add(jsonValues.get(i));
        }
        return sortedJsonArray.toString();
    }


/**Description: is_desc-false升序列  is_desc-true降序 (排序字段为数字类型)
*/

public static String jsonArraySort(JSONArray jsonArr,String sortKey,boolean is_desc) {
    JSONArray sortedJsonArray = new JSONArray();
    List<JSONObject> jsonValues = new ArrayList<JSONObject>();
    for (int i = 0; i < jsonArr.size(); i++) {
        jsonValues.add(jsonArr.getJSONObject(i));
    }
    Collections.sort(jsonValues, new Comparator<JSONObject>() {
        private  final String KEY_NAME = sortKey;

        @Override
        public int compare(JSONObject a, JSONObject b) {
            int valA = 0;
            int valB = 0;
            try {
                valA = a.getIntValue(KEY_NAME);
                valB = b.getIntValue(KEY_NAME);
            } catch (JSONException e) {
                e.printStackTrace();
            }

            if (is_desc){
                if(valA < valB){
                    return 1;
                }
                if(valA == valB){
                    return 0;
                }
                return -1;
            } else {
                if(valA > valB){
                    return 1;
                }
                if(valA == valB){
                    return 0;
                }
                return -1;
            }

        }
    });
    for (int i = 0; i < jsonArr.size(); i++) {
        sortedJsonArray.add(jsonValues.get(i));
    }
    return sortedJsonArray.toString();
}