json字符串转为有序map大全

原创 已于 2025-08-26 10:35:00 修改 · 752 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#json #python #开发语言 #java

于 2024-08-13 18:45:00 首次发布

Java中JSON字符串转有序Map

目录

  1. 概述
  2. 常用JSON库对比
  3. Jackson实现方式
  4. Gson实现方式
  5. FastJson实现方式
  6. 自定义工具类
  7. 性能对比
  8. 最佳实践

概述

在Java开发中，经常需要将JSON字符串转换为Map对象。默认情况下，大多数JSON库生成的Map是无序的（如HashMap），但在某些业务场景下，我们需要保持JSON的键值对顺序。本文将介绍几种实现方式并提供完整的工具类。

常用JSON库对比

特性JacksonGsonFastJsonJSON-B
性能高中很高中
功能完整性高中高中
社区活跃度高中高中
支持有序Map是是是是

Jackson实现方式

1. 基础实现

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.LinkedHashMap;
import java.util.Map;

public class JacksonJsonUtils {
  
    private static final ObjectMapper objectMapper = new ObjectMapper();
  
    /**
     * 将JSON字符串转换为有序Map
     * @param jsonString JSON字符串
     * @return 有序Map
     */
    public static Map<String, Object> jsonToOrderedMap(String jsonString) {
        try {
            TypeReference<LinkedHashMap<String, Object>> typeRef = 
                new TypeReference<LinkedHashMap<String, Object>>() {};
            return objectMapper.readValue(jsonString, typeRef);
        } catch (Exception e) {
            throw new RuntimeException("JSON转换失败: " + e.getMessage(), e);
        }
    }
  
    /**
     * 将JSON字符串转换为指定类型的Map
     * @param jsonString JSON字符串
     * @param valueType Map值类型
     * @return 有序Map
     */
    public static <T> Map<String, T> jsonToOrderedMap(String jsonString, Class<T> valueType) {
        try {
            TypeReference<LinkedHashMap<String, T>> typeRef = 
                new TypeReference<LinkedHashMap<String, T>>() {};
            return objectMapper.readValue(jsonString, typeRef);
        } catch (Exception e) {
            throw new RuntimeException("JSON转换失败: " + e.getMessage(), e);
        }
    }
}

2. 高级配置实现

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.DeserializationFeature;
import java.util.LinkedHashMap;
import java.util.Map;

public class JacksonAdvancedUtils {
  
    private static final ObjectMapper objectMapper;
  
    static {
        objectMapper = new ObjectMapper();
        // 配置序列化特性
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    
        // 配置反序列化特性
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        objectMapper.configure(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true);
    }
  
    /**
     * 将JSON字符串转换为有序Map（支持嵌套结构）
     * @param jsonString JSON字符串
     * @return 有序Map
     */
    public static Map<String, Object> jsonToNestedOrderedMap(String jsonString) {
        try {
            return objectMapper.readValue(jsonString, 
                new TypeReference<LinkedHashMap<String, Object>>() {});
        } catch (Exception e) {
            throw new RuntimeException("JSON转换失败: " + e.getMessage(), e);
        }
    }
}

Gson实现方式

1. 基础实现

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.LinkedHashMap;
import java.util.Map;

public class GsonJsonUtils {
  
    private static final Gson gson = new Gson();
  
    /**
     * 将JSON字符串转换为有序Map
     * @param jsonString JSON字符串
     * @return 有序Map
     */
    public static Map<String, Object> jsonToOrderedMap(String jsonString) {
        try {
            Type type = new TypeToken<LinkedHashMap<String, Object>>(){}.getType();
            return gson.fromJson(jsonString, type);
        } catch (Exception e) {
            throw new RuntimeException("JSON转换失败: " + e.getMessage(), e);
        }
    }
  
    /**
     * 将JSON字符串转换为指定类型的Map
     * @param jsonString JSON字符串
     * @param valueType Map值类型
     * @return 有序Map
     */
    public static <T> Map<String, T> jsonToOrderedMap(String jsonString, Class<T> valueType) {
        try {
            Type type = new TypeToken<LinkedHashMap<String, T>>(){}.getType();
            return gson.fromJson(jsonString, type);
        } catch (Exception e) {
            throw new RuntimeException("JSON转换失败: " + e.getMessage(), e);
        }
    }
}

2. 自定义Gson配置

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.LinkedHashMap;
import java.util.Map;

public class GsonCustomUtils {
  
    private static final Gson gson;
  
    static {
        gson = new GsonBuilder()
            .setDateFormat("yyyy-MM-dd HH:mm:ss")
            .serializeNulls()
            .create();
    }
  
    /**
     * 将JSON字符串转换为有序Map（支持日期格式化）
     * @param jsonString JSON字符串
     * @return 有序Map
     */
    public static Map<String, Object> jsonToOrderedMapWithDate(String jsonString) {
        try {
            Type type = new TypeToken<LinkedHashMap<String, Object>>(){}.getType();
            return gson.fromJson(jsonString, type);
        } catch (Exception e) {
            throw new RuntimeException("JSON转换失败: " + e.getMessage(), e);
        }
    }
}

FastJson实现方式

1. 基础实现

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import java.util.LinkedHashMap;
import java.util.Map;

public class FastJsonUtils {
  
    /**
     * 将JSON字符串转换为有序Map
     * @param jsonString JSON字符串
     * @return 有序Map
     */
    public static Map<String, Object> jsonToOrderedMap(String jsonString) {
        try {
            return JSON.parseObject(jsonString, 
                new TypeReference<LinkedHashMap<String, Object>>(){});
        } catch (Exception e) {
            throw new RuntimeException("JSON转换失败: " + e.getMessage(), e);
        }
    }
  
    /**
     * 将JSON字符串转换为指定类型的Map
     * @param jsonString JSON字符串
     * @param valueType Map值类型
     * @return 有序Map
     */
    public static <T> Map<String, T> jsonToOrderedMap(String jsonString, Class<T> valueType) {
        try {
            return JSON.parseObject(jsonString, 
                new TypeReference<LinkedHashMap<String, T>>(){});
        } catch (Exception e) {
            throw new RuntimeException("JSON转换失败: " + e.getMessage(), e);
        }
    }
}

2. FastJson配置版本

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.TypeReference;
import java.util.LinkedHashMap;
import java.util.Map;

public class FastJsonConfigUtils {
  
    /**
     * 将JSON字符串转换为有序Map（带配置）
     * @param jsonString JSON字符串
     * @return 有序Map
     */
    public static Map<String, Object> jsonToOrderedMap(String jsonString) {
        try {
            return JSON.parseObject(jsonString, 
                new TypeReference<LinkedHashMap<String, Object>>(){},
                Feature.OrderedField);
        } catch (Exception e) {
            throw new RuntimeException("JSON转换失败: " + e.getMessage(), e);
        }
    }
}

自定义工具类

1. 通用工具类

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * JSON工具类 - 支持多种JSON库和有序Map
 * @author Your Name
 * @version 1.0
 */
public class JsonOrderedMapUtils {
  
    // 支持的JSON库类型
    public enum JsonLibrary {
        JACKSON, GSON, FASTJSON, AUTO
    }
  
    // 缓存ObjectMapper实例
    private static final Map<JsonLibrary, Object> jsonParsers = new ConcurrentHashMap<>();
  
    // 默认使用Jackson
    private static JsonLibrary defaultLibrary = JsonLibrary.JACKSON;
  
    /**
     * 设置默认JSON库
     * @param library JSON库类型
     */
    public static void setDefaultLibrary(JsonLibrary library) {
        defaultLibrary = library;
    }
  
    /**
     * 将JSON字符串转换为有序Map（自动选择JSON库）
     * @param jsonString JSON字符串
     * @return 有序Map
     */
    public static Map<String, Object> jsonToOrderedMap(String jsonString) {
        return jsonToOrderedMap(jsonString, defaultLibrary);
    }
  
    /**
     * 将JSON字符串转换为有序Map（指定JSON库）
     * @param jsonString JSON字符串
     * @param library JSON库类型
     * @return 有序Map
     */
    public static Map<String, Object> jsonToOrderedMap(String jsonString, JsonLibrary library) {
        if (StringUtils.isEmpty(jsonString)) {
            return new LinkedHashMap<>();
        }
    
        try {
            switch (library) {
                case JACKSON:
                    return parseWithJackson(jsonString);
                case GSON:
                    return parseWithGson(jsonString);
                case FASTJSON:
                    return parseWithFastJson(jsonString);
                case AUTO:
                    return parseAuto(jsonString);
                default:
                    throw new IllegalArgumentException("不支持的JSON库类型: " + library);
            }
        } catch (Exception e) {
            throw new RuntimeException("JSON转换失败: " + e.getMessage(), e);
        }
    }
  
    /**
     * 将JSON字符串转换为指定类型的Map
     * @param jsonString JSON字符串
     * @param valueType Map值类型
     * @return 有序Map
     */
    public static <T> Map<String, T> jsonToOrderedMap(String jsonString, Class<T> valueType) {
        return jsonToOrderedMap(jsonString, valueType, defaultLibrary);
    }
  
    /**
     * 将JSON字符串转换为指定类型的Map（指定JSON库）
     * @param jsonString JSON字符串
     * @param valueType Map值类型
     * @param library JSON库类型
     * @return 有序Map
     */
    public static <T> Map<String, T> jsonToOrderedMap(String jsonString, Class<T> valueType, JsonLibrary library) {
        if (StringUtils.isEmpty(jsonString)) {
            return new LinkedHashMap<>();
        }
    
        try {
            switch (library) {
                case JACKSON:
                    return parseWithJackson(jsonString, valueType);
                case GSON:
                    return parseWithGson(jsonString, valueType);
                case FASTJSON:
                    return parseWithFastJson(jsonString, valueType);
                case AUTO:
                    return parseAuto(jsonString, valueType);
                default:
                    throw new IllegalArgumentException("不支持的JSON库类型: " + library);
            }
        } catch (Exception e) {
            throw new RuntimeException("JSON转换失败: " + e.getMessage(), e);
        }
    }
  
    // Jackson解析实现
    private static Map<String, Object> parseWithJackson(String jsonString) {
        try {
            ObjectMapper mapper = getJacksonMapper();
            TypeReference<LinkedHashMap<String, Object>> typeRef = 
                new TypeReference<LinkedHashMap<String, Object>>() {};
            return mapper.readValue(jsonString, typeRef);
        } catch (Exception e) {
            throw new RuntimeException("Jackson解析失败: " + e.getMessage(), e);
        }
    }
  
    private static <T> Map<String, T> parseWithJackson(String jsonString, Class<T> valueType) {
        try {
            ObjectMapper mapper = getJacksonMapper();
            TypeReference<LinkedHashMap<String, T>> typeRef = 
                new TypeReference<LinkedHashMap<String, T>>() {};
            return mapper.readValue(jsonString, typeRef);
        } catch (Exception e) {
            throw new RuntimeException("Jackson解析失败: " + e.getMessage(), e);
        }
    }
  
    // Gson解析实现
    private static Map<String, Object> parseWithGson(String jsonString) {
        try {
            Gson gson = getGsonParser();
            Type type = new TypeToken<LinkedHashMap<String, Object>>(){}.getType();
            return gson.fromJson(jsonString, type);
        } catch (Exception e) {
            throw new RuntimeException("Gson解析失败: " + e.getMessage(), e);
        }
    }
  
    private static <T> Map<String, T> parseWithGson(String jsonString, Class<T> valueType) {
        try {
            Gson gson = getGsonParser();
            Type type = new TypeToken<LinkedHashMap<String, T>>(){}.getType();
            return gson.fromJson(jsonString, type);
        } catch (Exception e) {
            throw new RuntimeException("Gson解析失败: " + e.getMessage(), e);
        }
    }
  
    // FastJson解析实现
    private static Map<String, Object> parseWithFastJson(String jsonString) {
        try {
            return JSON.parseObject(jsonString, 
                new TypeReference<LinkedHashMap<String, Object>>(){});
        } catch (Exception e) {
            throw new RuntimeException("FastJson解析失败: " + e.getMessage(), e);
        }
    }
  
    private static <T> Map<String, T> parseWithFastJson(String jsonString, Class<T> valueType) {
        try {
            return JSON.parseObject(jsonString, 
                new TypeReference<LinkedHashMap<String, T>>(){});
        } catch (Exception e) {
            throw new RuntimeException("FastJson解析失败: " + e.getMessage(), e);
        }
    }
  
    // 自动选择解析方式
    private static Map<String, Object> parseAuto(String jsonString) {
        // 按优先级尝试：Jackson -> Gson -> FastJson
        try {
            return parseWithJackson(jsonString);
        } catch (Exception e1) {
            try {
                return parseWithGson(jsonString);
            } catch (Exception e2) {
                try {
                    return parseWithFastJson(jsonString);
                } catch (Exception e3) {
                    throw new RuntimeException("所有JSON库都无法解析: " + e3.getMessage(), e3);
                }
            }
        }
    }
  
    private static <T> Map<String, T> parseAuto(String jsonString, Class<T> valueType) {
        try {
            return parseWithJackson(jsonString, valueType);
        } catch (Exception e1) {
            try {
                return parseWithGson(jsonString, valueType);
            } catch (Exception e2) {
                try {
                    return parseWithFastJson(jsonString, valueType);
                } catch (Exception e3) {
                    throw new RuntimeException("所有JSON库都无法解析: " + e3.getMessage(), e3);
                }
            }
        }
    }
  
    // 获取Jackson ObjectMapper
    private static ObjectMapper getJacksonMapper() {
        return (ObjectMapper) jsonParsers.computeIfAbsent(JsonLibrary.JACKSON, k -> {
            ObjectMapper mapper = new ObjectMapper();
            mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
            mapper.configure(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true);
            return mapper;
        });
    }
  
    // 获取Gson解析器
    private static Gson getGsonParser() {
        return (Gson) jsonParsers.computeIfAbsent(JsonLibrary.GSON, k -> 
            new GsonBuilder()
                .setDateFormat("yyyy-MM-dd HH:mm:ss")
                .serializeNulls()
                .create()
        );
    }
  
    /**
     * 将Map转换为JSON字符串
     * @param map Map对象
     * @return JSON字符串
     */
    public static String mapToJson(Map<String, ?> map) {
        return mapToJson(map, defaultLibrary);
    }
  
    /**
     * 将Map转换为JSON字符串（指定JSON库）
     * @param map Map对象
     * @param library JSON库类型
     * @return JSON字符串
     */
    public static String mapToJson(Map<String, ?> map, JsonLibrary library) {
        if (map == null || map.isEmpty()) {
            return "{}";
        }
    
        try {
            switch (library) {
                case JACKSON:
                    return getJacksonMapper().writeValueAsString(map);
                case GSON:
                    return getGsonParser().toJson(map);
                case FASTJSON:
                    return JSON.toJSONString(map);
                default:
                    throw new IllegalArgumentException("不支持的JSON库类型: " + library);
            }
        } catch (Exception e) {
            throw new RuntimeException("Map转JSON失败: " + e.getMessage(), e);
        }
    }
  
    /**
     * 验证JSON字符串是否有效
     * @param jsonString JSON字符串
     * @return 是否有效
     */
    public static boolean isValidJson(String jsonString) {
        if (StringUtils.isEmpty(jsonString)) {
            return false;
        }
    
        try {
            jsonToOrderedMap(jsonString);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
  
    /**
     * 获取JSON字符串的键集合（保持顺序）
     * @param jsonString JSON字符串
     * @return 键集合
     */
    public static Set<String> getJsonKeys(String jsonString) {
        Map<String, Object> map = jsonToOrderedMap(jsonString);
        return map.keySet();
    }
  
    /**
     * 获取JSON字符串的键值对数量
     * @param jsonString JSON字符串
     * @return 键值对数量
     */
    public static int getJsonSize(String jsonString) {
        Map<String, Object> map = jsonToOrderedMap(jsonString);
        return map.size();
    }
}

2. 字符串工具类

/**
 * 字符串工具类
 */
class StringUtils {
  
    /**
     * 判断字符串是否为空
     * @param str 字符串
     * @return 是否为空
     */
    public static boolean isEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }
  
    /**
     * 判断字符串是否不为空
     * @param str 字符串
     * @return 是否不为空
     */
    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }
}

使用示例

1. 基础使用

public class JsonExample {
  
    public static void main(String[] args) {
        // 示例JSON字符串
        String jsonString = "{\"name\":\"张三\",\"age\":25,\"city\":\"北京\"}";
    
        // 使用默认JSON库（Jackson）
        Map<String, Object> map1 = JsonOrderedMapUtils.jsonToOrderedMap(jsonString);
        System.out.println("默认解析结果: " + map1);
    
        // 指定使用Gson
        Map<String, Object> map2 = JsonOrderedMapUtils.jsonToOrderedMap(jsonString, JsonLibrary.GSON);
        System.out.println("Gson解析结果: " + map2);
    
        // 指定使用FastJson
        Map<String, Object> map3 = JsonOrderedMapUtils.jsonToOrderedMap(jsonString, JsonLibrary.FASTJSON);
        System.out.println("FastJson解析结果: " + map3);
    
        // 自动选择JSON库
        Map<String, Object> map4 = JsonOrderedMapUtils.jsonToOrderedMap(jsonString, JsonLibrary.AUTO);
        System.out.println("自动选择结果: " + map4);
    }
}

2. 复杂JSON处理

public class ComplexJsonExample {
  
    public static void main(String[] args) {
        // 复杂JSON字符串
        String complexJson = "{\"user\":{\"name\":\"李四\",\"age\":30},\"orders\":[{\"id\":1,\"product\":\"手机\"},{\"id\":2,\"product\":\"电脑\"}],\"total\":2999.99}";
    
        try {
            // 解析复杂JSON
            Map<String, Object> result = JsonOrderedMapUtils.jsonToOrderedMap(complexJson);
        
            // 访问嵌套数据
            @SuppressWarnings("unchecked")
            Map<String, Object> user = (Map<String, Object>) result.get("user");
            String userName = (String) user.get("name");
            Integer userAge = (Integer) user.get("age");
        
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> orders = (List<Map<String, Object>>) result.get("orders");
        
            Double total = (Double) result.get("total");
        
            System.out.println("用户名: " + userName);
            System.out.println("年龄: " + userAge);
            System.out.println("订单数量: " + orders.size());
            System.out.println("总金额: " + total);
        
            // 验证JSON有效性
            boolean isValid = JsonOrderedMapUtils.isValidJson(complexJson);
            System.out.println("JSON是否有效: " + isValid);
        
            // 获取所有键
            Set<String> keys = JsonOrderedMapUtils.getJsonKeys(complexJson);
            System.out.println("所有键: " + keys);
        
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3. 类型安全的使用

public class TypeSafeExample {
  
    public static void main(String[] args) {
        String jsonString = "{\"name\":\"王五\",\"score\":95.5,\"passed\":true}";
    
        try {
            // 指定值类型为Object（默认）
            Map<String, Object> map1 = JsonOrderedMapUtils.jsonToOrderedMap(jsonString);
        
            // 指定值类型为String
            Map<String, String> map2 = JsonOrderedMapUtils.jsonToOrderedMap(jsonString, String.class);
        
            // 指定值类型为Number
            Map<String, Number> map3 = JsonOrderedMapUtils.jsonToOrderedMap(jsonString, Number.class);
        
            System.out.println("Object类型: " + map1);
            System.out.println("String类型: " + map2);
            System.out.println("Number类型: " + map3);
        
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

性能对比

1. 解析性能测试

public class PerformanceTest {
  
    private static final String TEST_JSON = "{\"key1\":\"value1\",\"key2\":\"value2\",\"key3\":\"value3\",\"key4\":\"value4\",\"key5\":\"value5\"}";
    private static final int ITERATIONS = 100000;
  
    public static void main(String[] args) {
        System.out.println("性能测试开始...");
        System.out.println("测试JSON: " + TEST_JSON);
        System.out.println("迭代次数: " + ITERATIONS);
        System.out.println();
    
        // 测试Jackson
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < ITERATIONS; i++) {
            JsonOrderedMapUtils.jsonToOrderedMap(TEST_JSON, JsonLibrary.JACKSON);
        }
        long jacksonTime = System.currentTimeMillis() - startTime;
    
        // 测试Gson
        startTime = System.currentTimeMillis();
        for (int i = 0; i < ITERATIONS; i++) {
            JsonOrderedMapUtils.jsonToOrderedMap(TEST_JSON, JsonLibrary.GSON);
        }
        long gsonTime = System.currentTimeMillis() - startTime;
    
        // 测试FastJson
        startTime = System.currentTimeMillis();
        for (int i = 0; i < ITERATIONS; i++) {
            JsonOrderedMapUtils.jsonToOrderedMap(TEST_JSON, JsonLibrary.FASTJSON);
        }
        long fastJsonTime = System.currentTimeMillis() - startTime;
    
        // 输出结果
        System.out.println("性能测试结果:");
        System.out.println("Jackson: " + jacksonTime + "ms");
        System.out.println("Gson: " + gsonTime + "ms");
        System.out.println("FastJson: " + fastJsonTime + "ms");
        System.out.println();
    
        // 计算相对性能
        System.out.println("相对性能（以Jackson为基准）:");
        System.out.println("Jackson: 1.0x");
        System.out.println("Gson: " + String.format("%.2fx", (double) gsonTime / jacksonTime));
        System.out.println("FastJson: " + String.format("%.2fx", (double) fastJsonTime / jacksonTime));
    }
}

最佳实践

1. 选择JSON库的建议

  • 生产环境: 推荐使用Jackson，性能稳定，功能完整
  • 快速开发: 可以使用FastJson，性能最好
  • Android开发: 推荐使用Gson，体积小，兼容性好
  • 企业级应用: 推荐使用Jackson，社区支持好

2. 性能优化建议

  • 缓存ObjectMapper等解析器实例
  • 对于大量重复解析，考虑使用对象池
  • 避免在循环中重复创建解析器
  • 使用TypeReference缓存类型信息

3. 错误处理建议

  • 始终使用try-catch包装JSON操作
  • 提供有意义的错误信息
  • 考虑使用自定义异常类型
  • 记录详细的错误日志

4. 线程安全考虑

  • Jackson的ObjectMapper是线程安全的
  • Gson实例是线程安全的
  • FastJson实例是线程安全的
  • 建议使用单例模式管理解析器

依赖配置

在开始使用工具类之前，请确保在项目中添加相应的依赖。

Maven依赖

<!-- Jackson -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>
</dependency>

<!-- Gson -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

<!-- FastJson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.32</version>
</dependency>

Gradle依赖

// Jackson
implementation 'com.fasterxml.jackson.core:jackson-databind:2.15.2'

// Gson
implementation 'com.google.code.gson:gson:2.10.1'

// FastJson
implementation 'com.alibaba:fastjson:2.0.32'

总结

本文提供了Java中将JSON字符串转换为有序Map的完整解决方案，包括：

  1. 多种JSON库支持: Jackson、Gson、FastJson
  2. 完整的工具类: 支持自动选择、类型安全、错误处理
  3. 性能对比: 帮助选择最适合的JSON库
  4. 最佳实践: 生产环境的使用建议

通过这些工具类，您可以轻松地在Java项目中处理JSON数据，同时保持键值对的顺序，满足各种业务需求。

new_daimond
关注
将JSON字符串转换成Map对象的方法
11-29
页面向后台action传递一个json字符串，需要将json字符串转换成Map对象 public Map<String> toMap(Object object) { Map<String> data = new HashMap<String>(); // 将json字符串转换成jsonObject JSONObject jsonObject = JSONObject.fromObject(object); Iterator ite = jsonObject.keys(); // 遍历jsonObject数据,添加到Map
json字符串转成 Map/List
04-16
JSON字符串的结构主要包括对象（键值对的集合，用花括号{}包围）和数组（有序元素的集合，用方括号[]包围）。在Java中，我们可以使用各种库，如Gson、Jackson、org.json等，来完成这个转换。 1. Gson库： Gson是由...
json字符串转为map结构，复杂json字符串转为map结构
NRGAGA的专栏
01-10 1476
https://blog.youkuaiyun.com/weixin_39800144/article/details/77871115 import java.util.ArrayList; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; im...
json字符串转化为map
m0_54853420的博客
03-21 2323
第一种： JSON字符串转换为map遍历属性键和值 Map maps = (Map)JSON.parse(str); **for** (Object map : maps.entrySet()){ System.out.println(((Map.Entry)map).getKey()+" " + ((Map.Entry)map).getValue()); } 第二种 Map mapTypes =JSON.parseObject(str); for(Object obj
fastjson将json字符串转化成map的五种方法
agg7911的博客
08-08 6800
fastjson将json字符串转化成map的五种方法 复制代码 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...
java: 将json字符串转换为Map对象,如何保证其顺序不变.
小先生编程
07-12 868
大家都知道Map对象的LinkedHashMap是有序的,但它的顺序只能保证录入的顺序, 如果我们是将json字符串用JSONObject转换为json对象,并强转为LinkedHashMap,即便使用了有序map, 结果还是无序的.那是因为我们在从字符串转换为json对象时,已经是无序了. 解决无序问题,我们只能从转换为json对象入手, 当json对象时有序的,那么强转成LinkedHashMap也是有序的.
Golang JSON与Map转换：这些坑你一定要知道
最新发布
Golang编程笔记的博客
07-01 1025
在Golang开发中，JSON与Map的转换是非常常见的操作。我们的目的就是要搞清楚在Golang里，怎么把JSON数据和Map数据相互转换，以及转换过程中会碰到哪些问题。范围呢，就是围绕Golang语言，讲解JSON和Map转换的原理、步骤、坑点和应用。接下来的内容，我们会先介绍JSON和Map的核心概念，再讲讲它们之间转换的原理和具体操作步骤。然后通过一个实际项目案例，让大家更清楚怎么进行转换。之后会说说JSON与Map转换在实际场景中的应用，推荐一些相关的工具和资源。
深入解析json字符串转换为Map/List的过程
首先，我们来看看将JSON字符串转为Map的过程。 在Java中，Map是一个存储键值对的集合，其中每个键和值都是对象。而JSON对象在语法上可以看作是一个Map，其中键是字符串类型，值可以是任意JSON类型。 假设我们有...
是否可以用比较JSON字符串的方式实现？将DTO对象转化为JSON对象后，删除name字段，将JSON对象转为有序字符串，并根据字符串分组？
05-03
嗯，用户现在的问题是想通过JSON字符串比较来实现DTO对象的分组，而且不希望直接修改复杂的DTO属性。他们提到的方法是将DTO转为JSON，删除特定字段（比如name），然后转为有序字符串，再比较字符串来进行分组。我...
使用fastjson反Json时，如何保证含有多层Map的Json字符串反Json后，多层Map的数据顺序都不变？
hanxiaozhang的博客
03-02 1305
前言： 最近，我利用业余时间在整理一套“Excel导入导出+多线程处理导入数据+多线程事务回滚”的模板方法，遇到Json字符串反Json成Map后，Map顺序乱了的问题，这个问题影响到Excel导出错误数据表头顺序乱了，我一开始没有找到最合适方法，使用了一个笨方法，后来又搜索了好久才找到最简单解决方法。 先导知识： HashMap、LinkedHashMap和TreeMap的区别？ Has...
json字符串转Map、json数组
weixin_33717298的博客
08-15 180
json数组转map public static void main(String[] args){ String strArr = "[{\"0\":\"zhangsan\",\"1\":\"lisi\",\"2\":\"wangwu\",\"3\":\"maliu\"}," + "{\"00\":\"zhangsan\"...
JSON字符串转map、Object对象和List
qq_48718409的博客
01-08 1539
在平时的java开发中，我们可能会遇到调用第三方的接口，返回的是JSON字符串，下面是实现JSON字符串转换为Map<String, Object>在平时的java开发中，我们可能会遇到调用第三方的接口，返回的是JSON字符串，下面是实现JSON字符串转换为Object。在平时的java开发中，我们可能会遇到调用第三方的接口，返回的是JSON字符串，下面是实现JSON字符串转换为List。
JSON字符串转换为Map （转）
weixin_30546189的博客
05-12 293
本文是利用阿里巴巴封装的FastJSON来转换json字符串的。例子如下： package com.zkn.newlearn.json; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; import java.util.Map;...
Java json字符串转Map
专注于优雅与性能的未来架构师
06-18 4209
注意：这里引入的包为：import com.alibaba.fastjson.JSON; Map<Object, Object> map = (Map<Object, Object>) JSON.parse(str); 示例： public static void main(String[] args) { String str = "{" + "\"107551\":\"720336\"," + "\"121473\":\"523451\
JSON字符串与Map互转
我是“哈哈”
10-24 1862
//一、map转为json字符串 public static String map2jsonstr(Map<String,?> map){ return JSONObject.toJSONString(map); } //二、json字符串转Map对象 public static Map<String,?> jsonstr2map(Strin...
java json字符串转map 字段顺序错乱问题
conquer的博客
05-18 2529
<dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.73</version> </dependency> 默认可以使用JSON.parseObject将字符串转成Map，但是如果json中有多个key-value，则转换后的顺序可能颠倒。如下 p.
如何将JSON格式的字符串转换为Map？
a876106354的博客
04-26 2284
在 Java 中，将 JSON 格式的字符串转换为Map可以借助一些流行的 JSON 处理库来实现，下面为你介绍使用 Gson 和 Jackson 这两个常用库的方法。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值