常用工具类fastjson的学习使用

已于 2022-09-05 14:29:36 修改
阅读量1.3k 收藏 4
点赞数 1
分类专栏： 常用工具类 文章标签： json spring boot 学习
于 2022-07-21 15:59:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53998054/article/details/125914266
版权

JSON数据格式

什么是JSON

JSON（JavaScript Object Notation, JS对象简谱）是一种轻量级的数据交换格式。它基于 ECMAScript（European Computer Manufacturers Association, 欧洲计算机协会制定的js规范）的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

JSON数组格式

Json的数据本身是数组，中括号包裹，数组的元素之间逗号分开，数组元素的数据类型没有限制。

var jsonArray=["元素1","元素2","元素3"];//定义数组格式json
console.log(jsonArray[0]);//访问json元素
for(var i=0 ; i<jsonArray.length;i++){
   console.log(jsonArray[i])  //遍历数组，访问每一个元素
}

测试

　　jsonArray.html　　

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script type="text/javascript">
       /**
        *  定义json的数组格式
        *中括号包裹，数组的元素的数据类型没有限制
        *元素之间，逗号分开
        **/
        var jsonArray=["k1","k2",100,9,true];
        //访问数组元素，通过索引访问
       console.log(jsonArray[1]);
       //遍历数组，取出数组中的元素
       for (var i=0;i< jsonArray.length;i++) {
           console.log(jsonArray[i]);
       }

    </script>
</head>
<body>



</body>
</html>

  对象格式

json的数据本身是对象，大括号包裹1，对象采用键值对形式进行存储，健固定为字符串类型，值是任意类型的数据，健和值使用冒号分开

例如

var jsonObject={"k1":"v1","k2":"v2","k3":100,"k4":9.9,"k5":true};//定义对象格式json
       console.log(jsonObject.k1);//取出键k1对应的值

　 测试jsonObject.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
  <script type="text/javascript">
    /**
     * 定义json的对象格式
     * 大括号包裹，定义键值对，健必须是字符串类型，值的数据类型不限制
     * 键值对之间，是冒号分开
     * 每个键值对之间，逗号分开
     **/
    var jsonObject={"k1":"v1","k2":"v2","k3":100,"k4":9.9,"k5":true};
    //取出键值对,健找值的方式
    console.log(jsonObject.k1);
    console.log(jsonObject.k2);
    console.log(jsonObject.k3);
    console.log(jsonObject.k4);
    console.log(jsonObject.k5);

    </script>
</head>
<body>

</body>
</html>　　

数组对象相互嵌套

1.数组的元素是对象

jectArrayObject.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script type="text/javascript">
       /**
        * json数组的元素是对象
        *数组定义2个元素，每个元素是对象
        *对象是键值对形式
        **/
   var jsonArray=[
           {"name":"张三","age":20},
           {"name":"李四","age":22}
       ];
   //取出需要的数据李四22
       console.log(jsonArray[1],name+"=="+jsonArray[1].age);
       //遍历数组，取出数组中的元素
       for (var i=0;i< jsonArray.length;i++) {
           console.log(jsonArray[i],name+"=="+jsonArray[i].age);
       }
    </script>
</head>
<body>



</body>
</html>

2.对象中的值是数组

jectObjectArray.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script type="text/javascript">
       /**
        * json数据是对象
        *数组定义2个元素，每个元素是对象
        *对象是键值对形式
        **/
   var jsonObject=
           {
               "k1":["北京","天津","上海"],
               "k2":["中国","美国","英国"]
           };
   //取出上海
       console.log(jsonObject.k1[2]);
       //分别取出k1和k2的数组,遍历
       for (var i=0;i< jsonObject.k1.length;i++) {
           console.log(jsonObject.k1[i]);
       }
       console.log("=================");
       for (var i=0;i< jsonObject.k2.length;i++) {
           console.log(jsonObject.k2[i]);
       }
    </script>
</head>
<body>

3.你中有我我中有你

json.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<script type="text/javascript">
    /**
     * json的数据嵌套,你中有我，我中有你
     * json的数据本质上是对象
     * 对象的健是字符串，对象的值是数组
     * 数组的元素是对象
     **/
    var json={
      //健是k1,值是数组，数组的元素是对象
      "k1":[
          //数组的元素是2个元素
          {"name":"张三","age":20},
          {"name":"李四","age":22}
      ] ,
        "k2":[
            //数组的元素是2个元素
            {"name":"王五","age":24},
            {"name":"赵六","age":26}
        ]
    };
    //取出数据李四22
    console.log(json.k1[1].name+"=="+json.k1[1].age);
    //遍历k2对应的数组
    for (var i=0;i< json.k2.length;i++) {
        console.log(json.k2[i].name+"=="+json.k2[i].age);
    }

</script>
</body>
</html>

Fastjson介绍

fastjson是阿里巴巴的开源JSON解析库,它可以解析JSON格式的字符串,支持将Java Bean序列化为JSON字符串,也可以从JSON字符串反序列化到JavaBean。

fastjson的优点

速度快

fastjson相对其他JSON库的特点是快，从2011年fastjson发布1.1.x版本之后，其性能从未被其他Java实现的JSON库超越。

使用广泛

fastjson在阿里巴巴大规模使用，在数万台服务器上部署，fastjson在业界被广泛接受。在2012年被开源中国评选为最受欢迎的国产开源软件之一。

 测试完备

fastjson有非常多的testcase，在1.2.11版本中，testcase超过3321个。每次发布都会进行回归测试，保证质量稳定。

 使用简单

fastjson的API十分简洁。

String text = JSON.toJSONString(obj); //序列化
VO vo = JSON.parseObject("{...}", VO.class); //反序列化

 功能完备

支持泛型，支持流处理超大文本，支持枚举，支持序列化和反序列化扩展。

FastJson序列化Api

序列号:是指将java对象转成json格式化的过程javaBean对象List集合对象,Map集合，为应用最广泛。

JSON.toJSONString

序列化Java对象

pom.xml

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

最新

<dependency>
 <groupId>com.alibaba.fastjson2</groupId>
 <artifactId>fastjson2</artifactId>
 <version>2.0.1</version>
</dependency>

序列化

对象转JSON

String json = JSON.toJSONString(user); //序列化　　

List转JSON

 String jsonString = JSON.toJSONString(list);

Map转JSON　　

JSONObject jsonObject = JSONObject.parseObject(JSON.toJSONString(maps));
或者
String jsonString = JSON.toJSONString(map);

对象转JsonObject

  //student对象,转为Object格式字符串
        //调用静态方法,传递要转换的对象
        JSONObject jsonObject=(JSONObject)JSON.toJSON(student);
        //查看参数
        jsonObject.getIntValue("id");
        jsonObject.getString("name");
        System.out.println(jsonObject);
        System.out.println(jsonObject.getIntValue("id"));
        System.out.println(jsonObject.getString("name"));

反序列化

　JSON 字符串转换为 Java 对象

User user =JSON.parseObject(json,User.class); //反序列化

　JSON数组转List

        //反序列化
        //JSON类的静态对象parseObject
        //传递要反序列化的JSON对象，传递转换后的集合的泛型的class对象
        List<Student> listMaps = JSONArray.parseArray(JSON.toJSONString(list),Student.class);
        List<Student> mapsList = JSONObject.parseArray(JSON.toJSONString(list), Student.class);
        System.out.println(listMaps);
        System.out.println(mapsList);
        for (Student map : listMaps) {
            System.out.println(map);
        }
        for (Student map : mapsList) {
            System.out.println(map);
        }

　JSON转Map　

 //反序列化1
        Map<String,Object> maps = JSONObject.parseObject(jsonString,Map.class);
        for (String key1 : maps.keySet()) {
            System.out.println(key1+"::"+map.get(key1));
        }
        //JSON类的静态方法,parseObject
        //直接进行反序列化,Map集合没有泛型的，泛型没有是不安全的集合
        //转后的集合，必须有泛型
        //调用parseObject传递参数TypeReference类型在TypeReference类的泛型传递转后的Map集合
        Map<String, Student> map1 = JSON.parseObject(jsonString, new TypeReference<Map<String, Student>>() {
        });
        for (String key : map1.keySet()) {
            System.out.println(key+"::"+map.get(key));
        }

JsonObject转对象

  //反序列化
        Student student1=JSON.toJavaObject(jsonObject, Student.class);
        System.out.println(student1);

　扩展

　JsonObject转JsonString(JSON)

String jsonString1=JSON.toJSONString(jsonObject);

JsonString转JsonObject

JSONObject jsonObject=JSON.parseObject(jsonString);
#查询
jsonObject.getString("Name");

JsonString转JsonArray

JSONArray jArray=JSON.parseArray(JSON.toJSONString(list));

JSONArray转String 　

String jsonString = jsonArray.toString();

fastjson2的使用　

序列化

对象转JSON

String json = JSON.toJSONString(user); //序列化　　

List转JSON

 String jsonString = JSON.toJSONString(list);

Map转JSON　　

JSONObject jsonObject = JSONObject.parseObject(JSON.toJSONString(maps));
或者
String jsonString = JSON.toJSONString(map);

对象转JsonObject

  //student对象,转为Object格式字符串
        //调用静态方法,传递要转换的对象
        JSONObject jsonObject=(JSONObject)JSON.toJSON(student);
        //查看参数
        jsonObject.getIntValue("id");
        jsonObject.getString("name");
        System.out.println(jsonObject);
        System.out.println(jsonObject.getIntValue("id"));
        System.out.println(jsonObject.getString("name"));

反序列化

JSON 字符串转换为 Java 对象

User user =JSON.parseObject(json,User.class); //反序列化
　JSON转Map　

      //JSON类的静态方法,parseObject
        //直接进行反序列化,Map集合没有泛型的，泛型没有是不安全的集合
        //转后的集合，必须有泛型
        //调用parseObject传递参数TypeReference类型在TypeReference类的泛型传递转后的Map集合
        JSONObject map1 = JSON.parseObject(jsonString);
        for (String key : map1.keySet()) {
            System.out.println(key+"::"+map.get(key));
        }

JsonObject转对象

        //反序列化
        Student student1=JSON.toJavaObject(jsonObject, Student.class);
        System.out.println(student1);

实体类

import lombok.Data;

import java.util.Date;

@Data
public class Student {
    private Integer id;
    private String name;
    private Integer age;
    private String email;
    private Date birthday;

}　
测试类
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.lianxi.cs.pojo.Student;
import org.junit.jupiter.api.Test;

import java.util.*;

public class TestFastJson {
    public Date getDate(){
        Date date = new Date();
        return date;
    }

    @Test
    //Java中的集合Map,序列化为Json格式字符串
    void testMapToJson(){
        //创建Map集合,健为字符串，值为Student对象
        HashMap<String, Student> map = new HashMap<>();
        Student student1 = new Student();
        student1.setId(1);
        student1.setName("张三");
        student1.setAge(20);
        student1.setEmail("zs@163.com");
        student1.setBirthday(getDate());
        Student student2 = new Student();
        student2.setId(2);
        student2.setName("李四");
        student2.setAge(25);
        student2.setEmail("ls@163.com");
        student2.setBirthday(getDate());
        //Student存到Map中
        map.put("student",student1);
        map.put("student2",student2);
        JSONObject jsonObject = JSONObject.parseObject(JSON.toJSONString(map));
        System.out.println(jsonObject);
        String jsonString = JSON.toJSONString(map);
        System.out.println(jsonString);

        //jsonObject转jsonString
        String jsonString1=JSON.toJSONString(jsonObject);

        //json格式字符串是对象,对象中有两个健，健对应的值是Student对象
        //反序列化1
        Map<String,Object> maps = JSONObject.parseObject(jsonString1,Map.class);
        for (String key1 : maps.keySet()) {
            System.out.println(key1+"::"+map.get(key1));
        }
        //JSON类的静态方法,parseObject
        //直接进行反序列化,Map集合没有泛型的，泛型没有是不安全的集合
        //转后的集合，必须有泛型
        //调用parseObject传递参数TypeReference类型在TypeReference类的泛型传递转后的Map集合
        Map<String, Student> map1 = JSON.parseObject(jsonString, new TypeReference<Map<String, Student>>() {
        });
        for (String key : map1.keySet()) {
            System.out.println(key+"::"+map.get(key));
        }

    }
    @Test
    //Java中的集合List,序列号为JSON格式字符串
    void testListJson(){
        //集合List，存储Student对象
        ArrayList<Student> list = new ArrayList<>();
        Student student1 = new Student();
        student1.setId(1);
        student1.setName("张三");
        student1.setAge(20);
        student1.setEmail("zs@163.com");
        student1.setBirthday(getDate());
        Student student2 = new Student();
        student2.setId(2);
        student2.setName("李四");
        student2.setAge(25);
        student2.setEmail("ls@163.com");
        student2.setBirthday(getDate());
        //Student存到List中
        list.add(student1);
        list.add(student2);
        //List集合，序列化为Json格式字符串
        String jsonString = JSON.toJSONString(list);
        System.out.println(jsonString);
        //反序列化
        //JSON类的静态对象parseObject
        //传递要反序列化的JSON对象，传递转换后的集合的泛型的class对象
        List<Student> listMaps = JSONArray.parseArray(JSON.toJSONString(list),Student.class);
        List<Student> mapsList = JSONObject.parseArray(JSON.toJSONString(list), Student.class);
        System.out.println(listMaps);
        System.out.println(mapsList);
        for (Student map : listMaps) {
            System.out.println(map);
        }
        for (Student map : mapsList) {
            System.out.println(map);
        }
        List<Student> list1 = JSONObject.parseArray(jsonString, Student.class);
        for (Student student : list1) {
            System.out.println(student);
        }
        System.out.println(list1);


    }
    @Test
    //Java中的对象，Student对象,序列化为JSON格式字符串
    public void testObjectToJson(){
        Student student = new Student();
        student.setId(1);
        student.setName("张三");
        student.setAge(20);
        student.setEmail("zs@163.com");
        student.setBirthday(getDate());
        //student对象,转为JSON格式字符串
        //调用静态方法,传递要转换的对象
        String jsonString = JSON.toJSONString(student);
        System.out.println(jsonString);
        //{"age":20,"birthday":1657462817623,"email":"zs@163.com","id":1,"name":"张三"}
        //反序列化
        //JSON类的静态对象parseObject
        //传递要反序列化的JSON对象，传递JAVA对象的class对象
        Student student1 =JSON.parseObject(jsonString,Student.class);
        System.out.println(student1);
    }

    @Test
    //Java中的对象，Student对象,序列化为Object格式字符串
    public void testObjectToObject(){
        Student student = new Student();
        student.setId(1);
        student.setName("张三");
        student.setAge(20);
        student.setEmail("zs@163.com");
        student.setBirthday(getDate());
        //student对象,转为Object格式字符串
        //调用静态方法,传递要转换的对象
        JSONObject jsonObject=(JSONObject)JSON.toJSON(student);
        //查看参数
        jsonObject.getIntValue("id");
        jsonObject.getString("name");
        System.out.println(jsonObject);
        System.out.println(jsonObject.getIntValue("id"));
        System.out.println(jsonObject.getString("name"));

        //反序列化
        Student student1=JSON.toJavaObject(jsonObject, Student.class);
        System.out.println(student1);

    }
}

SerializerFeature枚举

TestFastJson2
package com.lianxi.cs;

/*
* SerializerFeature枚举:进行序列化时候，可以自己定义特殊需求
* JSON静态方法:toJSONString()
* 方法的参数:第一个是要序列化的对象
* 方法的参数:第二个参数 枚举类型的可变参数
* SerializerFeature枚举的常量,做序列化的个性需求
* */
public class TestFastJson2 {
}

枚举常量WriteMapNullValue序列化为null的字段

   //方法的参数上，添加枚举类型
        String jsonString = JSON.toJSONString(student, SerializerFeature.WriteMapNullValue);

枚举常量WriteNullStringAsEmpty字段为null序列化为""

    String jsonString = JSON.toJSONString(student, SerializerFeature.WriteNullStringAsEmpty);

枚举常量WriteNullNumberAsZero字段为null序列化为0

   String jsonString = JSON.toJSONString(student, SerializerFeature.WriteNullNumberAsZero);

枚举常量WriteNullBooleanAsFalse字段null输出false

        String jsonString = JSON.toJSONString(student, SerializerFeature.WriteNullBooleanAsFalse);

枚举常量WriteDateUseDateFormat格式化日期格式

        String jsonString = JSON.toJSONString(student, SerializerFeature.WriteDateUseDateFormat);

枚举常量PrettyFormat格式化输出

  String jsonString = JSON.toJSONString(student, SerializerFeature.PrettyFormat);

JSonFieId注解的使用　　

/**
*@JSonFleId注解
*该注解作用于方法上,字段上和参数上，可在序列化和反序列化时候进行特性功能定制
*JSONFieId注解属性name,指定序列化后的名字
*注解属性ordina序列化后的顺序 值越小属性越靠前
*注解属性format序列化后的格式
*注解属性serialize是否序列化该字段
*注解属性deserialize是否反序列化该字段
*注解属性SerialzeFeatures序列化时的特性定义
**/
//JSONFieId注解属性name,指定序列化后的名字
@JSONFieId(name="studentName")
private String name;
输入后字段为studentName

//注解属性format序列化后的格式
@JSONFieId(format="yyyy-MM-dd")
private Date birthday;

//注解属性serialize是否反序列化该字段
@JSONFieId(serialize="true")
private String email;

//注解属性deserialize是否反序列化该字段
@JSONFieId(deserialize="true")
private String email;

JsonType注解

/**
*@JSonType注解
*改注解作用于类上，对该类的字段进行序列化和反序列化时的特性功能定制
*注解属性:include要被序列化的字段
*注解属性:orders序列化后的顺序
*注解属性:serialzeFeatures序列化时候的特性定义
*
*
*
**/
@JSONType(includes={"id","name","age","address"},orders={"name","age","id","address"})

JSONArray转List对象　　

List<DataLastEntity> dataArr = JSONArray.parseArray(arr, DataLastEntity.class);

实体类如下:

在这里插入图片描述

　　

　　

　

　　

我是一个小仓鼠01
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android-常用的一些工具类
08-13
"Android-常用的一些工具类"这个资源可能是一个开源项目，名为MYXG-Tools-master，它很可能包含了开发者在日常工作中积累的各种实用工具函数。下面我们将详细探讨一些常见的Android工具类及其重要性。 1. **日期...
FastJson详解
Lyouths的移动笔记本
01-10 9126
一、Fastjson介绍 Fastjson是一个Java库，可用于将Java对象转换为其JSON表示形式。它还可以用于将JSON字符串转换为等效的Java对象。Fastjson可以与任意Java对象一起使用，包括您没有源代码的现有对象。 关于Json的处理，还有Google开发的Gson包，其他形式的如net.sf.json包，都可以实现json的转换。方法名称不同而已，最后的实现结果都是一样的。...
Json详解以及fastjson使用教程
热门推荐
srj1095530512的博客
09-08 22万+
Json是一种轻量级的数据交换格式，采用一种“键：值”对的文本格式来存储和表示数据，在系统交换数据过程中常常被使用，是一种理想的数据交换语言。在使用Java做Web开发时，不可避免的会遇到Json的使用。下面我们就简单讲一下Json的使用以及fastjson.jar包的使用。 一：JSON形式与语法 1.1：JSON对象 我们先来看以下数据： { "ID": 1001, "name"...
FastJson==xml与json格式互转工具类
最新发布
卓越之识论道，平常之识论事，狭隘之识论人
05-08 1220
FastJson==xml与json格式互转工具类
FastJson使用详解这一篇就够了
qq_28754027的博客
04-03 1万+
FastJson是一种高性能的Java JSON解析库，它采用类似于Jackson和Gson的JSON序列化和反序列化机制，但是速度更快。FastJson支持Java对象到JSON的序列化和JSON到Java对象的反序列化，同时支持对JSON字符串的高效解析。
Java工具库——FastJson的40个常用方法
IT小辉同学
10-25 5438
那些想看却没看的书，在心里摆满一个图书馆。。。。。。
fastjson详解
吴声子夜歌的博客
05-01 6万+
一、fastjson介绍 ​在前后端数据传输交互中,经常会遇到字符串(String)与json,XML等格式相互转换与解析，其中json以跨语言，跨前后端的优点在开发中被频繁使用，基本上可以说是标准的数据交换格式。fastjson 是一个java语言编写的高性能且功能完善的JSON库，它采用一种“假定有序快速匹配”的算法，把JSON Parse 的性能提升到了极致。它的接口简单易用，已经被广泛使用在缓存序列化，协议交互，Web输出等各种应用场景中。 FastJson是啊里巴巴的的开源库，用于对JSON格式的
Android开发常用工具类
12-15
以上列举的只是部分常用工具类，实际开发中还可能包括动画工具类、Log工具类、XML解析工具类等。这些工具类极大地提高了开发效率，降低了代码的复杂性。在编写工具类时，应遵循单一职责原则，每个工具类专注于一种...
Android代码-AyoLang常用工具类
08-06
常用工具类，java函数糖，安卓函数糖 没整到jcenter上，暂时就用aar包吧，也挺省劲：下载地址 下载下来文件名是：ayo-lang.aar，拷到libs目录里 然后在build.gradle里引入： repositories { flatDir { dirs 'libs'...
淘淘商城07-工具类
05-24
这些工具类通常包含了各种常用功能的封装，能够提高代码的复用性和开发效率。"淘淘商城07-工具类"这个压缩包文件很可能包含了用于电商项目的一系列Java工具类，如Cookie管理、FTP文件传输、HTTP客户端请求以及JSON...
Java开发常用工具类
09-10
fastjson，base64，redis，fileupload，jdbc，百度定位，localcache，断言，集合，日期，empty，异常，io（图片截图、压缩、获取像素以及文件的下载、拷贝、删除、循环读、等等），protocol（支持http&https;...
fastjson工具类
大哥的阔落
06-09 584
package com.dto; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.TypeReference; import java.util.List; import java.util.Map; public class JsonUtil { /** * 功能描述：把JSON数据转换成指定的java对象 * * @param jsonData JSO
Fastjson反序列化
Christ1na的博客
11-15 1万+
fastjson 是阿里巴巴的开源JSON解析库，它可以解析 JSON 格式的字符串，支持将 Java Bean 序列化为 JSON 字符串，也可以从 JSON 字符串反序列化到 JavaBean。fastjson是目前java语言中最快的json库,其功能完备且使用简单,因而使用非常广泛。自fastjson在1.2.24版本爆出第一次漏洞到至今，有着多次的安全补丁更新和绕过。
Java反序列化—Fastjson基础
..
01-06 7317
最近摆烂了很久，来学习一下fastjson Fastjson 是 Alibaba 开发的 Java 语言编写的高性能 JSON 库，用于将数据在 JSON 和 Java Object 之间互相转换。提供两个主要接口来分别实现序列化和反序列化操作。JSON.toJSONString 将 Java 对象转换为 json 对象，序列化的过程。JSON.parseObject/JSON.parse 将 json 对象重新变回 Java 对象；反序列化的过程所以可以简单的把 json 理解成是一个字符串。
FastJSON自定义工具类
AnameJL的博客
05-17 283
FastJSON工具类
阿里巴巴 - FastJson使用简介
什么是江湖?
09-12 1万+
1.FastJSON简介 FastJSOn是阿里巴巴开源的JSON处理工具，大家可以尝试使用一下。 官网地址：http://code.alibabatech.com/wiki/display/FastJSON/Overview Fastjson是一个json处理工具包，包括“序列化”和“反序列化”两部分，它具备如下特征： 速度最快，测试表明，fastjson具有极快的性能，超越
FastJson快速上手【Json解析工具】
路漫漫其修远兮，吾将上下而求索
10-22 2858
针对JSON序列化和反序列化，为了方便快捷，我们一般使用json序列化工具进行操作常见的json序列化工具有Gson和FastJsonFastJson是阿里巴巴开源的项目，号称是速度最快的json解析工具。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值