主流JSON库的Javabean与JSON的互转，以及String类的JSON串解析为JSON对象

最新推荐文章于 2021-11-26 18:13:50 发布
最新推荐文章于 2021-11-26 18:13:50 发布
阅读量553 收藏 3
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42465125/article/details/101774686
版权

参考：https://blog.youkuaiyun.com/suyimin2010/article/details/81406813

https://blog.youkuaiyun.com/DevolperFront/article/details/99515755

Maven依赖：

		<dependency>
			<groupId>net.sf.json-lib</groupId>
			<artifactId>json-lib</artifactId>
			<version>2.4</version>
			<classifier>jdk15</classifier>
		</dependency>

		<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
		<dependency>
			<groupId>com.google.guava</groupId>
			<artifactId>guava</artifactId>
			<version>20.0</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/com.google.collections/google-collections -->
		<dependency>
			<groupId>com.google.collections</groupId>
			<artifactId>google-collections</artifactId>
			<version>1.0</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.16.22</version>
			<scope>provided</scope>
		</dependency>

		<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
		<dependency>
			<groupId>com.google.code.gson</groupId>
			<artifactId>gson</artifactId>
			<version>2.8.5</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.50</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/net.minidev/json-smart -->
		<dependency>
			<groupId>net.minidev</groupId>
			<artifactId>json-smart</artifactId>
			<version>2.3</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.json/json -->
		<dependency>
			<groupId>org.json</groupId>
			<artifactId>json</artifactId>
			<version>20190722</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/com.googlecode.json-simple/json-simple -->
		<dependency>
			<groupId>com.googlecode.json-simple</groupId>
			<artifactId>json-simple</artifactId>
			<version>1.1.1</version>
		</dependency>

		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>2.9.8</version>
		</dependency>
		
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-annotations</artifactId>
			<version>2.9.0</version>
		</dependency>

准备工作：

package cn.cuit.testa0;


import lombok.Data;


@Data
public class FullName
{
    private String firstName;

    private String middleName;

    private String lastName;

    public FullName()
    {}

    public FullName(String firstName, String middleName, String lastName)
    {
        this.firstName = firstName;
        this.middleName = middleName;
        this.lastName = lastName;
    }

    @Override
    public String toString()
    {
        return "[firstName=" + firstName + ", middleName=" + middleName + ", lastName=" + lastName + "]";
    }
}
package cn.cuit.testa0;


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

import lombok.Data;


@Data
public class Person
{
    private String name;

    private FullName fullName;

    private int age;

    private Date birthday;

    private List<String> hobbies;

    private Map<String, String> clothes;

    private List<Person> friends;

    @Override
    public String toString()
    {
        StringBuilder str = new StringBuilder(
            "Person [name=" + name + ", fullName=" + fullName + ", age=" + age + ", birthday=" + birthday + ", hobbies=" + hobbies + ", clothes=" + clothes + "]\n");
        if (friends != null)
        {
            str.append("Friends:\n");
            for (Person f : friends)
            {
                str.append("\t").append(f);
            }
        }
        return str.toString();
    }
}
package cn.cuit.testa0;


import com.alibaba.fastjson.JSON;


public class FastJsonUtil
{
    public static String bean2Json(Object obj)
    {
        return JSON.toJSONString(obj);
    }

    public static <T> T json2Bean(String jsonStr, Class<T> objClass)
    {
        return JSON.parseObject(jsonStr, objClass);
    }
}
package cn.cuit.testa0;


import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;


public class GsonUtil
{
    // Gson gson = new Gson(); 两种创建方式
    private static Gson gson = new GsonBuilder().create();

    public static String bean2Json(Object obj)
    {
        return gson.toJson(obj);
    }

    public static <T> T json2Bean(String jsonStr, Class<T> objClass)
    {
        return gson.fromJson(jsonStr, objClass);
    }

    public static String jsonFormatter(String uglyJsonStr)
    {
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        JsonParser jp = new JsonParser();
        JsonElement je = jp.parse(uglyJsonStr);
        return gson.toJson(je);
    }
}
package cn.cuit.testa0;


import java.io.IOException;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;


public class JacksonUtil
{
    private static ObjectMapper mapper = new ObjectMapper();

    public static String bean2Json(Object obj)
    {
        try
        {
            return mapper.writeValueAsString(obj);
        }
        catch (JsonProcessingException e)
        {
            e.printStackTrace();
            return null;
        }
    }

    public static <T> T json2Bean(String jsonStr, Class<T> objClass)
    {
        try
        {
            return mapper.readValue(jsonStr, objClass);
        }
        catch (IOException e)
        {
            e.printStackTrace();
            return null;
        }
    }
}
package cn.cuit.testa0;


import net.sf.json.JSONObject;


public class JsonLibUtil
{

    public static String bean2Json(Object obj)
    {
        JSONObject jsonObject = JSONObject.fromObject(obj);
        return jsonObject.toString();
    }

    @SuppressWarnings("unchecked")
    public static <T> T json2Bean(String jsonStr, Class<T> objClass)
    {
        return (T)JSONObject.toBean(JSONObject.fromObject(jsonStr), objClass);
    }
}
package cn.cuit.testa0;


import net.minidev.json.JSONValue;


public class JsonSmartUtil
{
    public static String bean2Json(Object obj)
    {
        return JSONValue.toJSONString(obj);
    }

    public static <T> T json2Bean(String jsonStr, Class<T> objClass)
    {
        return JSONValue.parse(jsonStr, objClass);
    }
}

测试代码：

package cn.cuit.testa0;


import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import org.junit.Before;
import org.junit.Test;

import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.collect.Maps;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

import net.minidev.json.JSONValue;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;


/**
  * @ClassName: TestJson
  * @Description: 所有主流JSON库的对象转JSON和JSON转对象，以及String类的JSON串解析为JSON对象
  * @lib: 
  *     json-lib-2.4-jdk15【性能较差，用法还可以】
  *     fastjson
  *     json-smart
  *     org.json【对JavaBean与JSON之前的互转支持差】
  *     json-simple【不太好用,与其他库用法有所差异，主要用于Map的支持，对JavaBean几乎不支持】
  *     Gson
  *     Jackson
  * @author CUITLLB
  * @date Sep 24, 2019 12:06:39 PM
  * @Copyright: Copyright (c) 2018 
  * @Company:IBM
  * 
  * @JSON 库性能参考：https://blog.youkuaiyun.com/DevolperFront/article/details/99515755
  */

public class TestJson
{
    
    // 用的时候注意判断获取到的是否为null，否则易产生空指针异常，这里没有做校验
    
    // 需要解析的字符串
    String jsonString = "{\n" + 
        "    \"status\": 0,\n" + 
        "    \"message\": \"Everything is ok.\",\n" + 
        "    \"result\": {\n" + 
        "        \"total_count\": 1,\n" + 
        "        \"users\": [\n" + 
        "            {\n" + 
        "                \"user_id\": \"a017c149c08e35acd968598944\",\n" + 
        "                \"domain_id\": \"hcxm\",\n" + 
        "                \"status\": \"ACTIVATED\",\n" + 
        "                \"state\": \"NORMAL\",\n" + 
        "                \"username\": \"uf085268\",\n" + 
        "                \"name\": \"Li Linbo, BBF-421(IBM Simba)\",\n" + 
        "                \"pinyin\": \"Li Linbo, BBF-421(IBM Simba)\",\n" + 
        "                \"initial\": \"Li Linbo, BBF-421(IBM Simba)\",\n" + 
        "                \"nickname\": \"Li Linbo, BBF-421(IBM Simba)\",\n" + 
        "                \"phone\": \"\",\n" + 
        "                \"email\": \"\",\n" + 
        "                \"gender\": \"UNKNOWN\",\n" + 
        "                \"disabled\": false,\n" + 
        "                \"initial_password\": true,\n" + 
        "                \"agreement_confirmed\": false,\n" + 
        "                \"biological_auth_enabled\": false,\n" + 
        "                \"source_type\": \"LDAP\"\n" + 
        "            }\n" + 
        "        ]\n" + 
        "    }\n" + 
        "}";
    
    private Person person;
    
    @Before
    public void prepare() {
        List<Person> friends = new ArrayList<Person>();
        friends.add(this.createAPerson("Judiy", null));
        friends.add(this.createAPerson("Tony", null));
        friends.add(this.createAPerson("Mark", null));
        person = createAPerson("Li Linbo", friends);
    }
    
    private Person createAPerson(String name, List<Person> friends) {
        Person newPerson=new Person();
        newPerson.setName(name);
        newPerson.setFullName(new FullName("Li_first", "Lin_middle", "bo_last"));
        newPerson.setAge(24);
        List<String> hobbies=new ArrayList<String>();
        hobbies.add("music");
        hobbies.add("swing");
        hobbies.add("coding");
        newPerson.setHobbies(hobbies);
        Map<String,String> clothes=new HashMap<String, String>();
        clothes.put("coat", "Nike");
        clothes.put("trousers", "Onitsuka Tiger");
        clothes.put("shoes", "AJ");
        newPerson.setClothes(clothes);
        newPerson.setFriends(friends);
        return newPerson;
    }
    
    public static void main(String[] args)
    {
    }
    
    // Json-lib 4 String
    @Test
    public void testJsonLib4String() {
        JSONObject fromObject = JSONObject.fromObject(jsonString);
        System.out.println(fromObject);

        JSONObject object = (JSONObject)fromObject.get("result");
        System.out.println(object);

        JSONArray jsonArray = object.getJSONArray("users");
        System.out.println(jsonArray);

        object = (JSONObject)jsonArray.get(0);
        System.out.println(object);
        
        System.out.println(object.get("username"));
    }
    
    // Json-lib 4 Object
    @Test
    public void testJsonLib4Object() {
        // Object -> String
        String bean2Json = JsonLibUtil.bean2Json(person);
        System.out.println(bean2Json);
        
        // String -> Object
        Person json2Bean = JsonLibUtil.json2Bean(bean2Json, Person.class);
        // 直接输出对象会报异常, 解析出来后，里面的friends属性是一个MorphDynaBean包装Bean，
        // Person中直接遍历的时候直接转为Person就报类型转换异常，参考：https://www.cnblogs.com/longshiyVip/p/4608098.html
        System.out.println(json2Bean.getFriends().get(0));
        //System.out.println(json2Bean.getFriends().get(0).getAge()); // 报错
        System.out.println(json2Bean.getAge());
        
        // 上述问题的解决方法
        Map<String, Class<?>> classMap = Maps.newHashMap();
        classMap.put("friends", Person.class);
        // 需要注意的一点是，这里第一个参数不是String而是一个JsonObject
        Person bean = (Person)JSONObject.toBean(JSONObject.fromObject(bean2Json), Person.class, classMap);
        System.out.println(bean);
        System.out.println(bean.getFriends().get(0).getAge());
    }
    
    // fastjson 4 String
    @Test
    public void testFastJson4String() {
        com.alibaba.fastjson.JSONObject parseObject = JSON.parseObject(jsonString);
        System.out.println(parseObject);
        
        com.alibaba.fastjson.JSONObject jsonObject = parseObject.getJSONObject("result");
        System.out.println(jsonObject);
        
        com.alibaba.fastjson.JSONArray jsonArray = jsonObject.getJSONArray("users");
        com.alibaba.fastjson.JSONObject object = (com.alibaba.fastjson.JSONObject)jsonArray.get(0);
        System.out.println(object);
        
        System.out.println(object.get("username"));
    }
    
    // fastjson 4 Object
    @Test
    public void testFastJson4Object() {
        // Object -> String
        String bean2Json = FastJsonUtil.bean2Json(person);
        System.out.println(bean2Json);
        
        // String -> Object
        Person json2Bean = FastJsonUtil.json2Bean(bean2Json, Person.class);
        System.out.println(json2Bean);
    }
    
    // json-smart 4 String
    @Test
    public void testJsonSmart4String() {
        net.minidev.json.JSONObject jsonObject = (net.minidev.json.JSONObject)JSONValue.parse(jsonString);
        System.out.println(jsonObject);
        
        net.minidev.json.JSONObject object = (net.minidev.json.JSONObject)jsonObject.get("result");
        System.out.println(object);
        
        net.minidev.json.JSONArray jsonArray = (net.minidev.json.JSONArray)object.get("users");
        System.out.println(jsonArray);
        
        object =  (net.minidev.json.JSONObject)jsonArray.get(0);
        System.out.println(object);
        
        System.out.println(object.get("username"));
    }
    
    // json-smart 4 Object
    @Test
    public void testJsonSmart4Object() {
        // Object -> String
        String bean2Json = JsonSmartUtil.bean2Json(person);
        System.out.println(bean2Json);
        
        // String -> Object
        Person json2Bean = JsonSmartUtil.json2Bean(bean2Json, Person.class);
        System.out.println(json2Bean);
    }
    
    // org.json 4 String
    @Test
    public void testOrgJson4String() {
        org.json.JSONObject jsonObject = new org.json.JSONObject(jsonString);
        System.out.println(jsonObject);
        
        org.json.JSONObject  object = (org.json.JSONObject)jsonObject.get("result");
        System.out.println(object);
        
        org.json.JSONArray jsonArray = (org.json.JSONArray)object.get("users");
        System.out.println(jsonArray);
        
        object = (org.json.JSONObject)jsonArray.get(0);
        System.out.println(object.get("username"));
    }
    
    // org.json默认不支持将JsonObject转为Java对象,需要自己增强
    @Test
    public void testOrgJson4Object() {
        // Object -> String
        String bean2Json = new CuitJSONObject(jsonString).toString();
        System.out.println(bean2Json);
        
        // String -> Object // 有问题
        person = (Person) new CuitJSONObject(bean2Json).toJavaBean(Person.class);
        System.out.println(person);
    }
    
    // json-simple 4 String
    @Test
    public void testJsonSimple4String() throws ParseException {
        JSONParser jsonParser = new JSONParser();
        org.json.simple.JSONObject  jsonObject = (org.json.simple.JSONObject)jsonParser.parse(jsonString);
        System.out.println(jsonObject);
        
        jsonObject = (org.json.simple.JSONObject)jsonObject.get("result");
        System.out.println(jsonObject);
        
        org.json.simple.JSONArray jsonArray = (org.json.simple.JSONArray)jsonObject.get("users");
        System.out.println(jsonArray);
        
        jsonObject = (org.json.simple.JSONObject)jsonArray.get(0);
        System.out.println(jsonObject.get("username"));
    }
    
    // Gson 4 String 
    @Test
    public void testGson4String() {
        // 格式化Json
        System.out.println(GsonUtil.jsonFormatter(jsonString));
        
        JsonParser jsonParser = new JsonParser();
        JsonObject jsonObject = (JsonObject)jsonParser.parse(jsonString);
        System.out.println(jsonObject);
        
        jsonObject = (JsonObject)jsonObject.get("result");
        System.out.println(jsonObject);
        
        JsonArray jsonArray =  (JsonArray)jsonObject.get("users");
        System.out.println(jsonArray);
        jsonObject = (JsonObject)jsonArray.get(0);
        
        // 最终输出的还是带有""包裹
        System.out.println(jsonObject.get("username"));
    }
    
    // Gson 4 Object 
    @Test
    public void testGson4Object() {
        // Object -> String
        String bean2Json = GsonUtil.bean2Json(person);
        System.out.println(bean2Json);
        
        // String -> Object
        person = GsonUtil.json2Bean(bean2Json, Person.class);
        System.out.println(person);
    }
    
    // Jackson 4 String
    @Test
    public void testJackson4String() throws IOException {
        ObjectMapper objectMapper = new ObjectMapper();
        
        // 方式一
        JsonNode rootNode = objectMapper.readTree(jsonString);
        System.out.println(rootNode);
        
        JsonNode resultPath = rootNode.path("result");
        System.out.println(resultPath);
        
        JsonNode usersPath = resultPath.path("users");
        System.out.println(usersPath);
        
        JsonNode userJsonNode = usersPath.get(0);
        System.out.println(userJsonNode);
        // 最终输出的还是带有""包裹
        System.out.println(userJsonNode.get("username"));
        
        // 方式二
        JsonNode resultJsonNode = rootNode.get("result");
        System.out.println(resultJsonNode);
        
        JsonNode usersJsonNode = resultJsonNode.get("users");
        System.out.println(usersJsonNode);
        
        JsonNode userNode = usersJsonNode.get(0);
        System.out.println(userNode.get("username"));
        
        // 返回""
        String result1 = resultJsonNode != null ? resultJsonNode.asText() : "";
        // 返回值
        String result2 = resultJsonNode != null ? resultJsonNode.toString() : "";
        System.out.println(result1);
        System.out.println(result2);
    }
    
    // Jackson 4 Object
    @Test
    public void testJackson4Object() {
        String bean2Json = JacksonUtil.bean2Json(person);
        System.out.println(bean2Json);
        
        person = JacksonUtil.json2Bean(bean2Json, Person.class);
        System.out.println(person);
    }
}

 

 

【好物推荐】JSON Formatter 是一款为 JetBrains IDEs（如 IntelliJ IDEA等）设计的插件，旨在帮助开发者更高效地处理 JSON 数据
本本本添哥
03-10 137
JSON Formatter 是一个用于 JetBrains 系列开发工具的插件，它能够对 JSON 数据进行格式化、压缩和验证，就像处理.json文件一样。它为开发者提供了一个便捷的工具，用于快速整理和优化 JSON 数据，提升开发效率。
Json字符串、Json对象、java对象之间的转换
Carry_Jey
09-28 1516
JSONObject 不知道哪来的那么多的，又是alibaba的，又是org.json，又是net.minidev.json，统统都是废物 在这里全部用的： import net.sf.json.JSONObject; 反正在转换方面最有效的还是JSONObject.fromObject。 话不多说，上例子 package com.sky.hrpro.service; import c...
javaBean--jsonObject--jsonString相互转化
12-19
最近在研究Webservice的时候遇到一个问题，把java对象转化问json后传过去，接受的是String类型，怎么恢复到原来的java对象呢，后来再一个项目中看到了转换方法，转换顺序为javaBean--jsonObject--jsonString，还原顺序为jsonString--jsonObject--javaBean，所用jar包为json-lib-2.3-jdk15.jar，压缩包里是测试程序和jar包
[JSON]org.json包深解析JSON字符串并转化为javaBean
weixin_43717407的博客
08-24 731
org.json包深解析JSON字符串并转化javaBean前言 前言   在使用org.json.JSONObject解析json字符串并转化为JavaBean的时候，发现只能进行浅解析，如果JavaBean的属性中含有JavaBean、Map、List等属性时，JSONObject无法进行解析转化。   在网上大量搜索，没有发现能够进行深解析的办法或公开代码   因此，无奈之下自己动手写了一个深解析的方法，用于将JSON字符串完全解析并转化为JavaBean，主要是利用Java 反射原理实现。   
java构造和解析json_Java构造和解析Json数据之org.json
weixin_39622891的博客
02-17 178
一、介绍org.json包是另一个用来beans,collections,maps,java arrays 和XML和JSON互相转换的包，主要就是用来解析Json数据，在其官网http://www.json.org/上有详细讲解，有兴趣的可以去研究。二、下载jar依赖包可以去这里下载三、基本方法介绍packagecom.json;importjava.lang.reflect.Method;...
JSON入门Java篇-5-用JavaBean来构建JSON
Anthony_tester的博客
08-22 1644
前面我们介绍用JSONObject和HashMap来构造JSON数据，其实实际项目开发中，可能更多利用JavaBean来构造JSON。简单来说，JavaBean是可复用的平台独立的软件组件，也就是说复用性很高。 1.打开eclipse，新建两个包 2.JavaBean类内容如下 package bean; /** * @author Administrator * */
实现JSON和POJO的相互转换
qd_liyp的专栏
03-21 730
1.import java.util.Collection;      2. import java.util.HashMap;      3. import java.util.Map;      4.   5. import net.sf.json.JSONArray;      6. import net.sf.json.JSONObject;      7.
Java中json与javaBean几种互转的讲解
10-17
接下来，我们可以使用org.json库中的JSONObject类和JSONArray类将Student对象转换为JSON字符串。 ```java import org.json.JSONObject; import org.json.JSONArray; public static void convertObject() { ...
Json一键转Javabean工具
12-03
这些库提供了API，可以将JSON字符串转化为JSON对象或者JSON数组。 2. **映射属性**：解析后的JSON对象会被映射到JavaBean的属性上。这个过程需要考虑到JSON键（key）与JavaBean字段（field）之间的对应关系。例如，...
Javabean转换成json字符并首字母大写代码实例
10-15
在处理请求时，如果JSON字符串为空，我们可以直接初始化`DiagResponeBean`对象并设置默认值，然后使用`ObjectMapper`将其转换为JSON字符串并写入响应输出流： ```java if (StringUtil.isEmpty(json)) { ...
Java bean转换为Json Schema
最新发布
01-19
Java Bean转换为Json Schema是一种常见的数据转换操作，特别是在开发基于RESTful API的Web服务时，因为JSON Schema提供了数据验证和文档化的功能。Java Bean是Java编程中的一个概念，它是一类具有特定规则的POJO...
JavaBean与Json的互转方法解析
- Jackson库中主要的类是`ObjectMapper`，这个类提供了`readValue()`方法，可以将JSON字符串转换为JavaBean对象。 - 示例代码如下： ```java ObjectMapper objectMapper = new ObjectMapper(); String jsonStr = ...
阿里巴巴的JSON实用jar包集合整理
04-04
fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴开发。 包中包含fastjson-1.1.37.jar，fastjson-1.2.2.jar ，fastjson-1.2.2-sources.jar等
使用org.json包，new JSONObject（Object obj）后，obj信息在生成的json对象（json字符串）中消失一部分（不完整）
qq_15134905的博客
03-22 867
从JSONObject源码注释知：obj应该是一个Bean，其类型必须为public的class，将obj的实际类型【Object的子类，即EventType】改为public的类型后，信息保存完整，问题解决。   JSONObject部分源码如下（看注释）： /**      * Construct a JSONObject from an Object using bean gette
java bean转string_Json、JavaBean、String等互转
weixin_39644494的博客
02-12 776
Json、JavaBean、String等互转本文介绍简单的Json、JavaBean、String互换(下文JavaBean简称Object对象，这里不是很严谨)转换关系如下：其中String和javaBean之间的转换可以通过“中间态”Json来完成。先上代码，再补充解释实体类package com.blue.yanxishe.controller.app.market;public clas...
JSON 字符串 与 java 对象的转换
weixin_30911451的博客
01-22 61
1. //把Map<String,Object> 对象列表转换为javaBean对象 　　BeanUtils.populate(exhibitions, map); // 引入相应的包 //json-lib-2.2-jdk15.jar import net.sf.json.JSONArray; import net.sf.json.JSONObject; 1. //...
json字符串转换成java对象
weixin_34356310的博客
11-12 277
转载于:https://www.cnblogs.com/chao-zjj/p/9945564.html
idea搭建maven程序：04-添加子程序的代码部分
weixin_44641804的博客
11-26 737
一、直接写8001端口程序里，不用改的部分 pom.xml、application.yml、程序入口、实体entity 二、开始书写添加的方法 2.1 先写数据库代码 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.8//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > <
Android解析Json速度最快的库:json-smart
热门推荐
编程是一门艺术
05-22 1万+
本文验证了在安卓环境下使用Json的Key作为反序列化条件的解析速度。结论是解析速度最快的不是阿里的fastjson，也不是Google的Gson，而是json-smart。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值