Java-JSON-6ren

Java-JSON

转载作者：知者更新时间：2024-03-12 23:37:07

JSON介绍

SON：JavaScript 对象表示法（JavaScript Object Notation）
JSON是存储和交换文本信息的语法。
JSON的特点：
1、JSON是轻量级的文本数据交换格式
2、JSON独立于语言和平台
3、JSON具有自我描述性，更易理解

JSON与XML
类似XML，比XML更小、更快，更易解析。
1、没有结束标签
2、更短
3、读写的速度更快
4、使用数组
5、不使用保留字

JSON的语法:
JSON语法是JavaScript对象表示法的子集。
1、数据在名称/值对中（键值对）
2、数据由逗号分隔
3、花括号保存对象
4、方括号保存数组

JSON值可以是：
1、数字（整数或浮点数）
2、字符串（在双引号中）
3、逻辑值（true或false）
4、数组（在方括号中）
5、对象（在花括号中）
6、null

JSON对象(JSON对象在花括号中书写，对象可以包含多个名称/值对)

{"firstName":"Jphn","lasrName":"Doe"}

JSON数组(JSON数组在方括号中书写，数组可包含多个对象,当然对象也可以包含数组)

{
    "employees": [
        {
            "firstName": "John",
            "lastName": "Doe",
            "hobby":["游泳","打游戏","跳舞"]
        },
        {
            "firstName": "Anna",
            "lastName": "Smith",
            "hobby":["游泳","打游戏","跳舞"]
        },
        {
            "firstName": "Peter",
            "lastName": "Jones",
            "hobby":["游泳","打游戏","跳舞"]
        },
    ]
}

常用的JSON工具

Gson
FastJSON
Jackson(推荐)

Jackson基本教学

Jackson通过将JSON字段的名称与Java对象中的getter和setter方法进行匹配，将JSON对象的字段映射到Java对象中的属性。 Jackson删除了getter和setter方法名称的“ get”和“ set”部分，并将其余名称的第一个字符转换为小写。
如果需要以其他方式将JSON对象字段与Java对象字段匹配，则需要使用自定义序列化器和反序列化器，或者使用一些Jackson注解

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

JSON字符串–>Java对象

ObjectMapper objectMapper = new ObjectMapper();

String carJson =
    "{ \"brand\" : \"Mercedes\", \"doors\" : 5 }";

Car car = objectMapper.readValue(carJson, Car.class);

JSON数组字符串–>Java对象数组

String jsonArray = "[{\"brand\":\"ford\"}, {\"brand\":\"Fiat\"}]";

ObjectMapper objectMapper = new ObjectMapper();

Car[] cars2 = objectMapper.readValue(jsonArray, Car[].class);

JSON文件–>Java对象

ObjectMapper objectMapper = new ObjectMapper();

File file = new File("data/car.json");

Car car = objectMapper.readValue(file, Car.class);

JSON字节输入流–>Java对象

ObjectMapper objectMapper = new ObjectMapper();

InputStream input = new FileInputStream("data/car.json");

Car car = objectMapper.readValue(input, Car.class);

Jackson工具类

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.*;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// 注意如果转换对象有内部类 那么这个对象的内部类必须设置static
// 不然报错can only instantiate non-static inner class by using default, no-argument constructor
@Slf4j
public class JsonJacksonUtil {

    private static ObjectMapper objectMapper = new ObjectMapper();
    // 日起格式化
    private static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";
    static {
        //对象的所有字段全部列入
        objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
        //取消默认转换timestamps形式
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        //忽略空Bean转json的错误
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS,false);
        //所有的日期格式都统一为以下的样式，即yyyy-MM-dd HH:mm:ss
        objectMapper.setDateFormat(new SimpleDateFormat(STANDARD_FORMAT));
        //忽略 在json字符串中存在，但是在java对象中不存在对应属性的情况。防止错误
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);
        // 允许出现单引号
        objectMapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
    }

    /**
     * javaBean、列表(list,map),数组  转换为json字符串
     */
    @SneakyThrows
    public static String toJson(Object obj)  {
        return objectMapper.writeValueAsString(obj);
    }

    /**
     * javaBean、列表(list,map),数组,转换为json字符串,忽略空值
     */
    @SneakyThrows
    public static String toJsonNotNull(Object obj)  {
        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        return mapper.writeValueAsString(obj);
    }



    /**
     * json 转JavaBean
     */
    @SneakyThrows
    public static <T> T jsonToBean(String jsonString, Class<T> clazz)  {
        objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
        return objectMapper.readValue(jsonString, clazz);
    }



    /**
     *  json字符串转换为列表
     */
    @SneakyThrows
    public static <T> List<T> jsonToList(String jsonArrayStr, Class<T> clazz)  {

        JavaType javaType = getCollectionType(ArrayList.class, clazz);
        List<T> lst = (List<T>) objectMapper.readValue(jsonArrayStr, javaType);
        return lst;
    }

    /**
     *  json字符串转换为列表
     */
    @SneakyThrows
    public static <T> T[] jsonToArray(String jsonArrayStr, Class<T> clazz)  {
        JavaType javaType = getCollectionType(ArrayList.class, clazz);
        List<T> lst = (List<T>) objectMapper.readValue(jsonArrayStr, javaType);
        return (T[]) lst.toArray();
    }

    /**
     * json字符串  转换为map
     */
    @SneakyThrows
    public static  Map<String, Object> jsonToMap(String jsonString)  {
        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        return mapper.readValue(jsonString, Map.class);
    }

    /**
     * json字符串 转换为map  指定转换类型
     */
    @SneakyThrows
    public static <T> Map<String, T> jsonToMap(String jsonString, Class<T> clazz)  {
        Map<String, Map<String, Object>> map = objectMapper.readValue(jsonString, new TypeReference<Map<String, Map<String, Object>>>() {
        });
        Map<String, T> result = new HashMap<String, T>();
        for (Map.Entry<String, Map<String, Object>> entry : map.entrySet()) {
            result.put(entry.getKey(), map2pojo(entry.getValue(), clazz));
        }
        return result;
    }

    /**
     * 深度转换json成map
     *
     * @param json
     * @return
     */
    @SneakyThrows
    public static Map<String, Object> jsonToMapDepth(String json)  {
        return json2MapRecursion(json, objectMapper);
    }

    /**
     * map 转 json字符串
     *
     * @param map
     * @return
     */
    @SneakyThrows
    public static String mapToJson(Map map) {
        return objectMapper.writeValueAsString(map);
    }

    /**
     * map类型  转 指定JavaBean     原理就是key对应属性名称   value对应属性值
     */
    @SneakyThrows
    public static <T> T mapToBean(Object obj, Class<T> clazz) {
        return objectMapper.convertValue(obj, clazz);
    }

    // 将Bean转成Map     原理就是属性名称对应key   属性值对应value
    @SneakyThrows
    public static Map beanToMap(Object obj) {
        return objectMapper.readValue(toJson(obj), Map.class);
    }

    //将JSON写入文件中
    @SneakyThrows
    public  static  void writeFileJson(File file,String data){
        OutputStream outputStream= new FileOutputStream(file);
        objectMapper.writeValue(outputStream, data);
    }
    //读取文件的JSON
    @SneakyThrows
    public  static  String readFileJson(File file){
       ObjectMapper mapper= new ObjectMapper();
       JsonNode rootNode = mapper.readValue(file, JsonNode.class);
       return toJson(rootNode);
    }

    // ----------------------------------------------------底层方法----------------------------------------------------------



    /**
     * 把json解析成list，如果list内部的元素存在jsonString，继续解析
     *
     * @param json
     * @param mapper 解析工具
     * @return
     * @throws Exception
     */
    private static List<Object> json2ListRecursion(String json, ObjectMapper mapper) throws Exception {
        if (json == null) {
            return null;
        }

        List<Object> list = mapper.readValue(json, List.class);

        for (Object obj : list) {
            if (obj != null && obj instanceof String) {
                String str = (String) obj;
                if (str.startsWith("[")) {
                    obj = json2ListRecursion(str, mapper);
                } else if (obj.toString().startsWith("{")) {
                    obj = json2MapRecursion(str, mapper);
                }
            }
        }

        return list;
    }




    /**
     * 把json解析成map，如果map内部的value存在jsonString，继续解析
     *
     * @param json
     * @param mapper
     * @return
     * @throws Exception
     */
    private static Map<String, Object> json2MapRecursion(String json, ObjectMapper mapper) throws Exception {
        if (json == null) {
            return null;
        }

        Map<String, Object> map = mapper.readValue(json, Map.class);

        for (Map.Entry<String, Object> entry : map.entrySet()) {
            Object obj = entry.getValue();
            if (obj != null && obj instanceof String) {
                String str = ((String) obj);

                if (str.startsWith("[")) {
                    List<?> list = json2ListRecursion(str, mapper);
                    map.put(entry.getKey(), list);
                } else if (str.startsWith("{")) {
                    Map<String, Object> mapRecursion = json2MapRecursion(str, mapper);
                    map.put(entry.getKey(), mapRecursion);
                }
            }
        }

        return map;
    }

    /**
     * 获取泛型的Collection Type
     *
     * @param collectionClass 泛型的Collection
     * @param elementClasses  元素类
     * @return JavaType Java类型
     * @since 1.0
     */
    public static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {
        return objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
    }

    /**
     * map  转JavaBean
     */
    public static <T> T map2pojo(Map map, Class<T> clazz) {
        return objectMapper.convertValue(map, clazz);
    }

}

FastJSON

<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.51</version>
        </dependency>

JSON字符串–>Java对象

public static <T> T parseObject(String text, Class<T> clazz)

JSON数组字符串–>Java对象数组

public static <T> List<T> parseArray(String text, Class<T> clazz)

JSON对象转字符串

//JSONObject  和JSONArray
 public static String toJSONString(Object object)

FastJSON工具类

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializeConfig;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.serializer.SimpleDateFormatSerializer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Date;
import java.util.List;
import java.util.Map;

public class JsonFastJsonUtil {
    private final static Logger logger = LoggerFactory.getLogger(JsonFastJsonUtil.class);
    private static SerializeConfig config;

    static {
        config = new SerializeConfig();
        config.put(Date.class, new SimpleDateFormatSerializer("yyyy-MM-dd HH:mm:ss"));
    }

    private static final SerializerFeature[] features = {
            // 输出空置字段
            SerializerFeature.WriteMapNullValue,
            // list字段如果为null，输出为[]，而不是null
            SerializerFeature.WriteNullListAsEmpty,
            // 数值字段如果为null，输出为0，而不是null
            SerializerFeature.WriteNullNumberAsZero,
            // Boolean字段如果为null，输出为false，而不是null
            SerializerFeature.WriteNullBooleanAsFalse,
            // 字符类型字段如果为null，输出为""，而不是null
            SerializerFeature.WriteNullStringAsEmpty
    };

    /**
     * 将对象转为json字符串
     *
     * @param object
     * @return
     */
    public static String toFeaturesJson(Object object) {
        return JSON.toJSONString(object, config, features);
    }

    /**
     * 将对象转为json字符串
     *
     * @param object
     * @return
     */
    public static String toJson(Object object) {
        return JSON.toJSONString(object, config);
    }

    /**
     * 将json字符串转为Object实例
     *
     * @param json
     * @return
     */
    public static Object parse(String json) {
        return JSON.parse(json);
    }

    /**
     * 将json字符串转为指定类型的实例
     *
     * @param json
     * @param cls
     * @param <T>
     * @return
     */
    public static <T> T parse(String json, Class<T> cls) {
        return JSON.parseObject(json, cls);
    }

    /**
     * 将json转为Map
     *
     * @param json
     * @param <T>
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> Map<String, T> toMap(String json) {
        return (Map<String, T>) JSONObject.parseObject(json);
    }

    /**
     * 将json转为指定类型的List
     *
     * @param json
     * @param cls
     * @param <T>
     * @return
     */
    public static <T> List<T> toList(String json, Class<T> cls) {
        return JSON.parseArray(json, cls);
    }

    /**
     *
     * @param json  必须是 JSONArray 或者JSONObject 才会进行样式转换
     * @return
     */
    public static String   pretty(JSON json){
        String pretty = JSON.toJSONString(json, SerializerFeature.PrettyFormat, SerializerFeature.WriteMapNullValue,
                SerializerFeature.WriteDateUseDateFormat);
        return  pretty;
    }

}

Gson

<dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.6</version>
        </dependency>

工具类

public class JsonGsonUtils<T> {

   private  static Gson gson ;

   static {
       GsonBuilder gsonBuilder = new GsonBuilder() ;
       // 设置成漂亮的输出
//       gsonBuilder.setPrettyPrinting();
       //设定日期解析格式
       gsonBuilder.setDateFormat("yyyy-MM-dd HH:mm:ss");
       gson=gsonBuilder.create();
   }

    //把json 字符串 转换为 Map
    public static Map<String, Object> jsonTurnMap(String json){
        Map<String, Object> res = null;
        try {
            res = gson.fromJson(json, new TypeToken<Map<String, Object>>() {
            }.getType());

        } catch (JsonSyntaxException e) {
            e.printStackTrace();
        }
        return res;
    }


    // 把JSOn 字符串 转实体类 泛型版
    public static <T>T jsonTurnJavaBena(String json, Class clazz){
       T res = null;
        try {
            res =  (T)gson.fromJson(json,clazz);
        } catch (JsonSyntaxException e) {
            e.printStackTrace();
        }
        return res;
    }

//    //把json 字符串 转换为 LIst
    public static  <T>  List<T>  jsonTurnList(String json,Class<T> clazz){
        List<T> newres = new ArrayList<>();
        List<T> res = null;
        try {
            res = gson.fromJson(json, new TypeToken<ArrayList<T>>() {}.getType());

        } catch (JsonSyntaxException e) {
            e.printStackTrace();
        }
        for (T re : res) {
            newres.add(JsonGsonUtils.jsonTurnJavaBena(JsonGsonUtils.objTurnJson(re),clazz));
        }

        return newres;
    }


    //把  实体类对象 , List , Map  转 json 字符串
    public static String objTurnJson(Object object){
        return  gson.toJson(object);
    }

}

美化输出的JSON(免依赖)

因为在有些场景下Json格式是需要给用户看的,如果不格式化那么就是一坨谁知道这是啥?

纯手写的美化json,无需任何依赖

package com.c4.utils;

public class JsonFormatTool
{
    /**
     * 单位缩进字符串。
     */
    private static String SPACE = "   ";

    /**
     * 返回格式化JSON字符串。
     *
     * @param json 未格式化的JSON字符串。
     * @return 格式化的JSON字符串。
     */
    public static String formatJson(String json)
    {
        StringBuffer result = new StringBuffer();

        int length = json.length();
        int number = 0;
        char key = 0;
        //遍历输入字符串。
        for (int i = 0; i < length; i++)
        {
            //1、获取当前字符。
            key = json.charAt(i);

            //2、如果当前字符是前方括号、前花括号做如下处理：
            if((key == '[') || (key == '{') )
            {
                //（1）如果前面还有字符，并且字符为“：”，打印：换行和缩进字符字符串。
                if((i - 1 > 0) && (json.charAt(i - 1) == ':'))
                {
                    result.append('\n');
                    result.append(indent(number));
                }

                //（2）打印：当前字符。
                result.append(key);

                //（3）前方括号、前花括号，的后面必须换行。打印：换行。
                result.append('\n');

                //（4）每出现一次前方括号、前花括号；缩进次数增加一次。打印：新行缩进。
                number++;
                result.append(indent(number));

                //（5）进行下一次循环。
                continue;
            }

            //3、如果当前字符是后方括号、后花括号做如下处理：
            if((key == ']') || (key == '}') )
            {
                //（1）后方括号、后花括号，的前面必须换行。打印：换行。
                result.append('\n');

                //（2）每出现一次后方括号、后花括号；缩进次数减少一次。打印：缩进。
                number--;
                result.append(indent(number));

                //（3）打印：当前字符。
                result.append(key);

                //（4）如果当前字符后面还有字符，并且字符不为“，”，打印：换行。
                if(((i + 1) < length) && (json.charAt(i + 1) != ','))
                {
                    result.append('\n');
                }

                //（5）继续下一次循环。
                continue;
            }

            //4、如果当前字符是逗号。逗号后面换行，并缩进，不改变缩进次数。
            if((key == ','))
            {
                result.append(key);
                result.append('\n');
                result.append(indent(number));
                continue;
            }

            //5、打印：当前字符。
            result.append(key);
        }

        return result.toString();
    }

    /**
     * 返回指定次数的缩进字符串。每一次缩进三个空格，即SPACE。
     *
     * @param number 缩进次数。
     * @return 指定缩进次数的字符串。
     */
    private static String indent(int number)
    {
        StringBuffer result = new StringBuffer();
        for(int i = 0; i < number; i++)
        {
            result.append(SPACE);
        }
        return result.toString();
    }

    public static void main(String[] args) {
        JsonFormatTool json = new JsonFormatTool();
        String str = "{'age':23,'aihao':['pashan','movies'],'name':{'firstName':'zhang','lastName':'san','aihao':['pashan','movies','name':{'firstName':'zhang','lastName':'san','aihao':['pashan','movies']}]}}";
        String result = formatJson(str);

        System.out.println(result);

    }
}

点赞 -收藏-关注-便于以后复习和收到最新内容有其他问题在评论区讨论-或者私信我-收到会在第一时间回复如有侵权，请私信联系我感谢,配合,希望我的努力对你有帮助^_^

文章推荐： Redis原理篇之通信协议和内存回收

文章推荐：使用 Netty 实现基于 CS 架构的 WebSocket 功能

文章推荐：编程，不止有代码，还有艺术

json - mongoexport - JSON 查询问题(扩展 JSON - JSON 输入无效)
最近开始学习MongoDB。今天老师教了我们 mongoexport 命令。在练习时，我遇到了一个典型的问题，包括教练在内的其他同学都没有遇到过。我在我的 Windows 10 机器上使用 Mongo
json - 如何将 JSON Schema 链接到我的 JSON 以验证 JSON？
我是 JSON Schema 的新手，读过什么是 JSON Schema 等等。但我不知道如何将 JSON Schema 链接到 JSON 以针对该 JSON Schema 进行验证。谁能解释一下？
json - 仅使用 json 在另一个 json 文件中包含一个 json 文件
在 xml 中，我可以在另一个 xml 文件中包含一个文件并使用它。如果您的软件从 xml 获取配置文件但没有任何方法来分离配置，如 apache/ngnix(nginx.conf - site-av
json - 如何反序列化包含具有更多 JSON 的字符串的 JSON？
我有一个 JSON 对象，其中包含一个本身是 JSON 对象的字符串。我如何反序列化它？我希望能够做类似的事情: #[derive(Deserialize)] struct B { c: S
json - Play Json 读取嵌套泛型序列化 Json
考虑以下 JSON { "a": "{\"b\": 12, \"c\": \"test\"}" } 我想定义一个泛型读取 Reads[Outer[T]]对于这种序列化的 Json import
json - 从 JSON 模式生成示例 JSON
关闭。这个问题不满足Stack Overflow guidelines .它目前不接受答案。想改善这个问题吗？更新问题，使其成为 on-topic对于堆栈溢出。 11 个月前关闭。 Improve
json - DynamoDB JSON 还是标准 JSON？
我的旧项目在 MySQL 中有 Standard JSON 格式的数据。对于我在 JS (Node.js) 和 DynamoDB 中的全新项目，关于 Standard JSON格式: 是否建议将其转
json - JSON 值是有效的 JSON 吗？
JSON 值字符串、数字、true、false、null 是否是有效的 JSON？即，是 true 一个有效的 JSON 文档？还是必须是数组/对象？一些验证器接受这个(例如 http://jso
json - 如何编码嵌入在 JSON 中的 JSON
我有一个 JSON 字符串，其中一个字段是文本字段。这个文本字段可以包含用户在 UI 中输入的文本，如果他们输入的文本是 JSON 文本，也许是为了说明一些编码，我需要对他们的文本进行编码，以便它不会
json - 使用加号序列化 JSON 会导致无效的 JSON
我正在通过 IBM MQ 调用处理数据，当由 ColdFusion 10 (10,0,11,285437) 序列化时，0 将作为 +0.0 返回，它会导致无效的 JSON并且无法反序列化。 stPol
json - 在 json 中没有嵌套数组的情况下哈希到 json
我正在从三个数组中生成一个散列，然后尝试构建一个 json。我通过 json object has array 成功了。 require 'json' A = [['A1', 'A2', 'A3'],
json - 根据 JSON 中的字段有条件地解码 JSON
我从 API 接收 JSON，响应可以是 30 种类型之一。每种类型都有一组唯一的字段，但所有响应都有一个字段 type 说明它是哪种类型。我的方法是使用serde .我为每种响应类型创建一个结构并
json - 为什么我下载的 JSON 文件不再是 JSON？
我正在下载一个 JSON 文件，我已将其检查为带有“https://jsonlint.com”的有效 JSON 到文档目录。然后我打开文件并再次检查，结果显示为无效的 JSON。这怎么可能？？？？这是
json - 尝试解析 JSON 并创建提取的 JSON
我正在尝试根据从 API 接收到的数据动态创建一个 JSON 对象。收到的示例数据:将数据解码到下面给出的 CiItems 结构中 { "class_name": "test", "
json - 从 JSON 字符串值解析 JSON
我想从字符串转换为对象。来自 {"key1": "{\n \"key2\": \"value2\",\n \"key3\": {\n \"key4\": \"value4\"\n }\n
json - 将扁平化的 json 转换为嵌套的 json
目前我正在使用以下代码将嵌套的 json 转换为扁平化的 json: import ( "fmt" "github.com/nytlabs/gojsonexplode" ) func
json - Go:用一组 json 标签解码 json，并编码为另一组不同的 json 标签
我有一个使用来自第三方 API 的数据的应用程序。我需要将 json 解码为一个结构，这需要该结构具有“传入”json 字段的 json 标签。传出的 json 字段具有不同的命名约定，因此我需要不同
json - 将 JSON 值限制为其他 JSON 对象的名称
我想使用 JSON 架构来验证某些值。我有两个对象，称它们为 trackedItems 和 trackedItemGroups。 trackedItemGroups 是组名称和 trackedItem
json - Spark JSON 将 JSON 中完整的字段读取到案例类中
考虑以下案例类模式， case class Y (a: String, b: String) case class X (dummy: String, b: Y) 字段b是可选的，我的一些数据集没有字
json - 如何从 json 对象中获取格式化的 json 字符串？
我正在存储 cat ~/path/to/file/blah | 的输出jq tojson 在一个变量中，稍后在带有 JSON 内容的 curl POST 中使用。它运作良好，但它删除了所有换行符。我知

知者

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

Java-JSON

JSON介绍

常用的JSON工具

Jackson基本教学

JSON字符串–>Java对象

JSON数组字符串–>Java对象数组

JSON文件–>Java对象

JSON字节输入流–>Java对象

Jackson工具类

FastJSON

JSON字符串–>Java对象

JSON数组字符串–>Java对象数组

JSON对象转字符串

FastJSON工具类

Gson

美化输出的JSON(免依赖)