转换字符串示例：

String array2 = "{'i':'2','b':'3'}";
        JSONObject parseObject = JSON.parseObject(array2);

结果：

{"b":"3","i":"2"}
我们会发现顺序与原来的字符串顺序不一致。

通过DEBUG去com.alibaba.fastjson.parser.DefaultJSONParser的下述方法

public Object parse(Object fieldName) {
    final JSONLexer lexer = this.lexer;
    switch (lexer.token()) {
        case SET:
            lexer.nextToken();
            HashSet<Object> set = new HashSet<Object>();
            parseArray(set, fieldName);
            return set;
        case TREE_SET:
            lexer.nextToken();
            TreeSet<Object> treeSet = new TreeSet<Object>();
            parseArray(treeSet, fieldName);
            return treeSet;
        case LBRACKET:
            JSONArray array = new JSONArray();
            parseArray(array, fieldName);
            if (lexer.isEnabled(Feature.UseObjectArray)) {
                return array.toArray();
            }
            return array;
        case LBRACE:

//重点就是此行的lexer.isEnabled(Feature.OrderedField)=false

            JSONObject object = new JSONObject(lexer.isEnabled(Feature.OrderedField));
            return parseObject(object, fieldName);

// case LBRACE: {
// Map<String, Object> map = lexer.isEnabled(Feature.OrderedField)
// ? new LinkedHashMap<String, Object>()
// : new HashMap<String, Object>();
// Object obj = parseObject(map, fieldName);
// if (obj != map) {
// return obj;
// }
// return new JSONObject(map);
// }

        case LITERAL_INT:
            Number intValue = lexer.integerValue();
            lexer.nextToken();
            return intValue;
        case LITERAL_FLOAT:
            Object value = lexer.decimalValue(lexer.isEnabled(Feature.UseBigDecimal));
            lexer.nextToken();
            return value;

重点就是此行的lexer.isEnabled(Feature.OrderedField)=false，打开JSONObject的源码构造方法可以发现当ordered参数值为false时使用的是HashMap存放数据。

public JSONObject(int initialCapacity, boolean ordered){
    if (ordered) {
        map = new LinkedHashMap<String, Object>(initialCapacity);
    } else {
        map = new HashMap<String, Object>(initialCapacity);
    }
}

hashmap是数组加链表结构，根据key的hash算法确定在数组中的位置，当发生hash冲突的时候，根据二叉树或者红黑树构成链表。所以是有序的，key确定，位置也就确定了。

如果要实现转换前的数据顺序与转换后的数据顺序一致，可以使用如下方式：

    String array2 = "{'i':'2','b':'3'}";
    JSONObject parseObject = JSON.parseObject(array2, Feature.OrderedField);

此时会使用LinkedHashMap，LinkedHashMap的内部维持了一个双向链表，保存了数据的插入顺序，遍历时，先得到的数据便是先插入的。
开发过程中遇到一个问题，服务器经过排序返回后的字符串数据使用fastjson解析后，数据顺序发生变化，引起业务异常。

解决办法：

1、解析时增加参数不调整顺序

JSONObject respondeBodyJson = JSONObject.parseObject(jsonStr, Feature.OrderedField);
2、初始化json对象为有序对象：

JSONObject retObj = new JSONObject(true);
这样生成的json对象就与放入数据时一致。

3、使用Gson解析

JsonObject returnData = new JsonParser().parse(replyString).getAsJsonObject();

json字符串序列化后如何保持顺序不变

使用阿里巴巴的fastjson对json字符串进行序列化，序列化之后发现顺序发生了改变，导致之后业务出现问题。
解决方法：
LinkedHashMap<String, Object> json = JSON.parseObject(message,LinkedHashMap.class, Feature.OrderedField);
JSONObject jsonObject=new JSONObject(true);
jsonObject.putAll(json);
先将字符串转化为LinkedHashMap，然后定义有序的json对象，将map对象复制到json对象中即可。

// 转为LinkedHashMap
LinkedHashMap<String, Object> jsonMap = JSON.parseObject(result,LinkedHashMap.class, Feature.OrderedField);
// 取其子对象，此时子对象的属性也变为有序，直接强转为JSONObject然后遍历即可
Object dataObj = jsonMap.get("result");
StringBuffer code_result = new StringBuffer();
// 强转
JSONObject code_obj = (JSONObject) dataObj;
for (Map.Entry<String,Object> entry: code_obj.entrySet()) {

code_result.append(entry.getKey());
code_result.append(":");
code_result.append(entry.getValue() == null ? "" : entry.getValue().toString());
code_result.append("\n");

}
LinkedHashMap<String, Object> jsonMap = JSON.parseObject(result,LinkedHashMap.class, Feature.OrderedField);

LinkedHashMap<String, Object> jsonMap = JSON.parseObject(result,LinkedHashMap.class, Feature.OrderedField);

原文链接：https://blog.csdn.net/ydk888888/article/details/102680904
原文链接：https://blog.csdn.net/qq_41995919/article/details/110549319
原文链接：https://blog.csdn.net/h363659487/article/details/103880710