程序员经验分享-hwhale

Java中常用的几种JSON格式的转换

2023-05-16

JSON在传输数据时，起到了特别大的作用，因此出现了各种各样五花八门的JSON转换第三方包，在这里做一个汇总，总结一些常用的

目录

com.alibaba.fastjson

常用的API

Lsit--->JSON

JSON字符串--->List

6种json转MAP

json-lib（即net.sf.json ）

常用的API

1.把java 对象列表转换为json对象数组，并转为字符串

2.把java对象转换成json对象，并转化为字符串(好像是map)

3.把JSON字符串转换为JAVA 对象数组

4.把JSON字符串转换为JAVA 对象

案例

org.json.JSONObject

构建JSONObject

直接使用 new 关键字实例化一个JSONObject对象

使用Map构建

使用JavaBean构建

解析JSONObject

com.google.gson

创建Gson对象

创建JsonObject

API

数组的序列化与反序列化

List的序列化与反序列化

对象的序列化和反序列化

com.fasterxml.jackson

com.alibaba.fastjson

可以下载第三方jar包，也可以直接建Maven项目导入依赖

https://download.csdn.net/download/qq_44709970/87607297?spm=1001.2014.3001.5503

    <!-- 阿里fastjson包JSON转换-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.47</version>
    </dependency>

常用的API

  • 对象 ---> json字符串      JSON.toJSONString(Object)
  • json字符串 ---> 对象      JSON.parseObject(jsonStr，Object)
  • json字符串 ---> 数组      JSON.parseArray(jsonStr，T.class）

Lsit--->JSON

JSON.toJSONString(list)

JSON字符串--->List

List<T> list = JSON.parseArray(要解析字符串,T.class);

6种json转MAP

       String str = "{'0':'zhangsan','1':'lisi','2':'wangwu','3':'maliu'}";
        //第一种方式
        Map maps = (Map) JSON.parse(str);
        System.out.println("这个是用JSON类来解析JSON字符串!!!");
        for (Object map : maps.entrySet()){
            System.out.println(((Map.Entry)map).getKey()+"     " + ((Map.Entry)map).getValue());
        }
        //第二种方式
        Map mapTypes = JSON.parseObject(str);
        System.out.println("这个是用JSON类的parseObject来解析JSON字符串!!!");
        for (Object obj : mapTypes.keySet()){
            System.out.println("key为："+obj+"值为："+mapTypes.get(obj));
        }
        //第三种方式
        Map mapType = JSON.parseObject(str,Map.class);
        System.out.println("这个是用JSON类,指定解析类型，来解析JSON字符串!!!");
        for (Object obj : mapType.keySet()){
            System.out.println("key为："+obj+"值为："+mapType.get(obj));
        }
        //第四种方式
        /**
         * JSONObject是Map接口的一个实现类
         */
        Map json = (Map) JSONObject.parse(str);
        System.out.println("这个是用JSONObject类的parse方法来解析JSON字符串!!!");
        for (Object map : json.entrySet()){
            System.out.println(((Map.Entry)map).getKey()+"  "+((Map.Entry)map).getValue());
        }
        //第五种方式
        JSONObject jsonObject = JSONObject.parseObject(str);
        System.out.println("这个是用JSONObject的parseObject方法来解析JSON字符串!!!");
        for (Object map : json.entrySet()){
            System.out.println(((Map.Entry)map).getKey()+"  "+((Map.Entry)map).getValue());
        }
        //第六种方式
        Map mapObj = JSONObject.parseObject(str,Map.class);
        System.out.println("这个是用JSONObject的parseObject方法并执行返回类型来解析JSON字符串!!!");
        for (Object map: json.entrySet()){
            System.out.println(((Map.Entry)map).getKey()+"  "+((Map.Entry)map).getValue());
        }
        String strArr = "{{\"0\":\"zhangsan\",\"1\":\"lisi\",\"2\":\"wangwu\",\"3\":\"maliu\"}," +
                "{\"00\":\"zhangsan\",\"11\":\"lisi\",\"22\":\"wangwu\",\"33\":\"maliu\"}}";
        // JSONArray.parse()
        System.out.println(json);
    }

json-lib（即net.sf.json ）

用net.sf.json包，要导入6个包来支持：

  • commons-beanutils-1.7.0.jar

  • commons-collections-3.1.jar

  • commons-lang-2.5.jar

  • commons-logging.jar

  • ezmorph-1.0.3.jar

  • json-lib-2.1-jdk15.jar

Maven依赖：

		<dependency>
			<groupId>net.sf.json-lib</groupId>
			<artifactId>json-lib</artifactId>
			<version>2.4</version>
			<classifier>jdk15</classifier>
		</dependency>
 		<dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.9.3</version>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
        <dependency>
            <groupId>net.sf.ezmorph</groupId>
            <artifactId>ezmorph</artifactId>
            <version>1.0.6</version>
        </dependency>

常用的API

import net.sf.json.JSONArray;  //用于集合或数组
import net.sf.json.JSONObject; //用于对象
JSONObject object = new JSONObject();

1.把java 对象列表转换为json对象数组，并转为字符串

JSONArray array = JSONArray.fromObject(userlist);
String jsonstr = array.toString();

2.把java对象转换成json对象，并转化为字符串(好像是map)

JSONObject object = JSONObject.fromObject(invite);
String str=object.toString();

3.把JSON字符串转换为JAVA 对象数组

String personstr = getRequest().getParameter("persons");
JSONArray json = JSONArray.fromObject(personstr);
List<InvoidPerison> persons = (List<InvoidPerson>)JSONArray.toCollection(json, nvoidPerson.class);

4.把JSON字符串转换为JAVA 对象

JSONObject jsonobject = JSONObject.fromObject(str);
PassportLendsEntity passportlends = null;
try {
　　//获取一个json数组
　　JSONArray array = jsonobject.getJSONArray("passports");
　　//将json数组 转换成 List<PassPortForLendsEntity>泛型
　　List<PassPortForLendsEntity> list = new ArrayList<PassPortForLendsEntity>();
　　for (int i = 0; i < array.size(); i++) {   
　　　　JSONObject object = (JSONObject)array.get(i);  
　　　　PassPortForLendsEntity passport = (PassPortForLendsEntity)JSONObject.toBean(object,
　　　　PassPortForLendsEntity.class);

　　if(passport != null){
　　list.add(passport);
　　}
}

案例

 public static void main(String[] args) {
        String jsonStr = "{\"payTime\":\"2022-11-15 11:51:39\",\"errMsg\":\"查询成功\",\"targetStatus\":\"SUCCESS\",\"totalAmount\":1,\"errCode\":\"SUCCESS\"}";
//        import net.sf.json.JSONObject;
        JSONObject netSfJson = JSONObject.fromObject(jsonStr);
        Map<String, String> data = new HashMap<String, String>();
        Iterator ite = netSfJson.keys();
        // 遍历jsonObject数据,添加到Map对象
        while (ite.hasNext()) {
            String key = ite.next().toString();
            String value = netSfJson.get(key).toString();
            data.put(key, value);
        }
        log.info("Json转Map对象之net.sf.json.JSONObject：data[{}]", data);
     
     	//java序列化为json
        Student student = Student.getStudent();
        JSONObject jsonObject = JSONObject.fromObject(student);
     
     	//Json反序列化为java
        //如果对象中含有复杂对象，如List、Map或自定义javaBean,
        // 需要使用一下的classMap,否则转换过程中会报错
        Map<String,Class> classMap=new HashMap<>();
        classMap.put("stuObject",Student.class);
        student=(Student)JSONObject.toBean(jsonObject,Student.class,classMap);
    }

org.json.JSONObject 

		<!-- 引入org.json所需依赖 -->
		<dependency>
			<groupId>org.json</groupId>
			<artifactId>json</artifactId>
			<version>20160810</version>
		</dependency>

构建JSONObject

直接使用 new 关键字实例化一个JSONObject对象

然后调用它的 put() 方法对其字段值进行设置。

		JSONObject jsonObj = new JSONObject();
		jsonObj.put("female", true);
		jsonObj.put("hobbies", Arrays.asList(new String[] { "yoga", "swimming" }));
		jsonObj.put("discount", 9.5);
		jsonObj.put("age", "26");
		jsonObj.put("features", new HashMap<String, Integer>() {
			private static final long serialVersionUID = 1L;
			{
				put("height", 175);
				put("weight", 70);
			}
		});
		System.out.println(jsonObj);

{
    "features": {
        "weight": 70,
        "height": 175
    },
    "hobbies": ["yoga", "swimming"],
    "discount": 9.5,
    "female": true,
    "age": 26
}

使用Map构建

		Map<String, Object> map = new HashMap<String, Object>();
		map.put("female", true);
		map.put("hobbies", Arrays.asList(new String[] { "yoga", "swimming" }));
		map.put("discount", 9.5);
		map.put("age", "26");
		map.put("features", new HashMap<String, Integer>() {
			private static final long serialVersionUID = 1L;
			{
				put("height", 175);
				put("weight", 70);
			}
		});
		JSONObject jsonObj = new JSONObject(map);
		System.out.println(jsonObj);

使用JavaBean构建

		UserInfo userInfo = new UserInfo();
		userInfo.setFemale(true);
		userInfo.setHobbies(new String[] { "yoga", "swimming" });
		userInfo.setDiscount(9.5);
		userInfo.setAge(26);
		userInfo.setFeatures(new HashMap<String, Integer>() {
			private static final long serialVersionUID = 1L;
			{
				put("height", 175);
				put("weight", 70);
			}
		});
		JSONObject jsonObj = new JSONObject(userInfo);
		System.out.println(jsonObj);
 
public class UserInfo {
 
	private Boolean female;
	private String[] hobbies;
	private Double discount;
	private Integer age;
	private Map<String, Integer> features;
 
	public Boolean getFemale() {
		return female;
	}
 
	public void setFemale(Boolean female) {
		this.female = female;
	}
 
	public String[] getHobbies() {
		return hobbies;
	}
 
	public void setHobbies(String[] hobbies) {
		this.hobbies = hobbies;
	}
 
	public Double getDiscount() {
		return discount;
	}
 
	public void setDiscount(Double discount) {
		this.discount = discount;
	}
 
	public Integer getAge() {
		return age;
	}
 
	public void setAge(Integer age) {
		this.age = age;
	}
 
	public Map<String, Integer> getFeatures() {
		return features;
	}
 
	public void setFeatures(Map<String, Integer> features) {
		this.features = features;
	}
 
}

解析JSONObject

JSONObject为每一种数据类型都提供了一个getXXX(key)方法

例如：获取字符串类型的字段值就使用getString()方法，获取数组类型的字段值就使用getJSONArray()方法。

		// 获取基本类型数据
		System.out.println("Female: " + jsonObj.getBoolean("female"));
		System.out.println("Discount: " + jsonObj.getDouble("discount"));
		System.out.println("Age: " + jsonObj.getLong("age"));
		
		// 获取JSONObject类型数据
		JSONObject features = jsonObj.getJSONObject("features");
		String[] names = JSONObject.getNames(features);
		System.out.println("Features: ");
		for (int i = 0; i < names.length; i++) {
			System.out.println("\t"+features.get(names[i]));
		}
 
		// 获取数组类型数据
		JSONArray hobbies = jsonObj.getJSONArray("hobbies");
		System.out.println("Hobbies: ");
		for (int i = 0; i < hobbies.length(); i++) {
			System.out.println("\t"+hobbies.get(i));
		}

com.google.gson

Gson是google提供的用来操作json数据的一个非常好用的类库 gson 在 github 上开源地址：https://github.com/google/gson

其提供了序列化和反序列化的功能。在我们进行网络开发的过程中通常会把参数封装成json格式传给后台，后台解析后的返回结果也会封装成json格式返回给调用者

如果项目中要求不要使用Fastjson，原因：Fastjson≤1.2.80的版本存在安全漏洞

序列化的前提是实现Serializable接口和序列化版本号

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

创建Gson对象

		//第一种方式
        Gson gson = new Gson();
        //第二种方式
        Gson gson1 = new GsonBuilder().create();
        //方式二除了可以创建一个Gson对象以外还可以进行多项配置,例如，设置日期的格式化
//       例如： new GsonBuilder().setDateFormat("yyyy-MM-dd");

创建JsonObject

        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("id", "1");//给jsonObject创建一个id属性值为1
        jsonObject.addProperty("bookName", "《深入Java虚拟机》");
        jsonObject.addProperty("bookPrice", 36.8);
        //打印Json字符串
        System.out.println(jsonObject.toString());// {"id":"1","bookName":"《深入Java虚拟机》","bookPrice":36.8}
        //给JsonObject添加对象
        JsonObject jsonObject1 = new JsonObject();
        jsonObject1.addProperty("chapterId", "1");
        jsonObject1.addProperty("chapterName", "第一章");
        //给JsonObject添加实体对象
        jsonObject.add("chapter", jsonObject1);
        System.out.println(jsonObject.toString());`

这里的JsonObject表示我们一样可以创建一个json对象；但是我们后面一般使用的是java对象跟json字符串的转换，可以用通过创建好的gson对象来操作

API

反序列化 toJson(对象)

序列化 fromJson(JSON字符串, 要转成的对象类型)

数组的序列化与反序列化

数组 ===>JSON字符串 toJson(arrs)

         String[] str = new String[]{"《深入Java虚拟机》", "《Android插件编程》", "《OpenCV全解》"};
         Gson gson = new Gson();
         String jsonStr = gson.toJson(str);//返回一个Json字符串
         System.out.println(jsonStr);// ["《深入Java虚拟机》","《Android插件编程》","《OpenCV全解》"]

JSON字符串 ===>数组 fromJson(jsonStr, T)

         String[] strArray = gson.fromJson(jsonStr, String[].class);
         for (String s : strArray) {
             System.out.println(s);
         }

List的序列化与反序列化

List集合 ===>JSON字符串 toJson(list)

         List<Book> books = new ArrayList<>();
         books.add(new Book("1", "《深入Java虚拟机》"));
         books.add(new Book("2", "《OpenCV进阶》"));
         Gson gson = new Gson();
         String jsonListStr = gson.toJson(books);
         System.out.println(jsonListStr);// [{"id":"1","name":"《深入Java虚拟机》"},{"id":"2","name":"《OpenCV进阶》"}]

JSON字符串 ===>List集合 fromJson(jsonStr, T)

         //获取泛型的类型
         Type type = new TypeToken<List<Book>>() {
         }.getType();
         //使用gson将字符串转换为泛型集合，即List<Book>
         List<Book> books1 = gson.fromJson(jsonListStr, type);
         for (Book book : books1) {
             System.out.println(book.getName());
         }

对象的序列化和反序列化

         Gson gson = new Gson();
         Book book = new Book("1", "《深入Java虚拟机》");
         //将book类序列化成字符串
         String bookStr = gson.toJson(book);
         System.out.println(bookStr);
         //将bookStr反序列化成为Book类
         Book b = gson.fromJson(bookStr, Book.class);
         System.out.println(b.getName());

com.fasterxml.jackson 

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.0</version>
        </dependency>
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonDemo {
    public static void main(String[] args) {
        String jsonString=null;

        try {
            Map jsonMap=new HashMap();
            ObjectMapper mapper = new ObjectMapper();
            Student student = Student.getStudent();
            jsonMap.put("param1","value1");
            jsonMap.put("param2","value2");
            jsonMap.put("student",student);

            jsonString= mapper.writeValueAsString(jsonMap);
            
            System.out.println("Json String");
            System.out.println(jsonString);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        //反序列化
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            JsonNode root = objectMapper.readTree(jsonString);
            Map jsonMap = objectMapper.readValue(jsonString, Map.class);
            System.out.println("json Object");
            System.out.println(jsonMap);
            Object student = jsonMap.get("student");
            System.out.println(student);
            System.out.println(jsonMap.get("param1"));
            System.out.println(jsonMap.get("param2"));
            System.out.println("----------------");
            System.out.println(root.get("student"));
            System.out.println(root.get("student").get("id"));
            System.out.println(root.get("student").get("teacher"));

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Java

json

中常用的几种

格式的转换

Java中常用的几种JSON格式的转换 的相关文章

随机推荐

  • mariadb的源码安装

    xff08 1 xff09 登上mariadb的官方网站 2 选择下载mariadb server 3 下载10 2版本 4 找到源码安装方式 xff08 5 xff09 下载传输到主机上 6 准备编译环境 yum span class t

  • HTTP协议以及Apache的httpd配置

    HTTP协议 前言HTTP简介HTTP诞生HTTP版本历史HTTP 0 9HTTP 1 0HTTP 1 1HTTP 2 0 web资源HTTP工作流程HTTP报文报文语法格式method xff08 方法 xff09 status xff0

  • 狂神说Redis笔记，Redis【入门】就这一篇就够了！

    Redis学习笔记 视频链接 xff1a 狂神说Redis链接 1 Nosql概述 1 1 为什么要使用Nosql 1 单片机Mysql时代 90年代 xff0c 一个网站的访问量太大 xff0c 单个数据库完全够用 随着用户的增多 xff

  • manjaro一些常用软件，指令（持续更新中）

    manjaro使用很久了 xff0c 由于对linux的陌生和迷惑 xff0c 重装了很多很多很多次 xff0c 最近的系统大概是使用最久的一次 xff0c 也解决了很多以前的问题在此记录下 系统如下 xff1a 软件安装 换源 烂大街的教

  • 在开发板上安装gdb

    网上对于在开发板上安装gdb的教程大多都是将开发板的文件系统放在虚拟机主机上 xff0c 从而通过nfs挂载上去的 xff0c 主要是针对性能较差开发板 xff0c 本教程讲解的是如何在开发板上直接安装gdb 为什么不能直接将pc上交叉编译

  • Idea Intellij 远程开发调试

    一 背景 在构建MiniOB开发环境时需要Linux环境 xff0c 另外结合分布式系统 xff0c 利用较好的通信 xff0c 萌发了远程开发的想法 xff1b 实际上远程部署 开发在很久之前有过想法 xff08 大约刚开始学Spring

  • Java笔记（4）——方法重载和this关键字

    1 方法的重载 不能通过参数名去区分两个方法 不能通过返回值类型来区分两个方法 可以通过参数列表 xff1a 参数个数 xff0c 参数类型来区分 span class token keyword public span span clas

  • 基于 java+springboot 工资管理系统设计和实现

    博主介绍 xff1a 5年java开发经验 xff0c 专注Java开发 定制 远程 指导等 csdn特邀作者 专注于Java技术领域 作者主页 超级帅帅吴 Java项目精品实战案例 500套 欢迎点赞 收藏 留言 文末获取源码联系方式 目

  • ubuntu 安装gcc 或g++ 时提示未发现软件包 gcc或g++

    问题 xff1a 安装gcc 或g 43 43 时提示未发现软件包 xff1f 1 这时 xff0c 只需更新apt get即可 xff0c 那么apt get是什么呢 xff1f apt get xff0c 是一条linux命令 xff0

  • ubuntu设置固定ip地址的方法

    ubuntu设置固定ip的方法 问题 xff1a 在连接虚拟机上的mysql数据库时 xff0c 发现连接不上了 检查了数据库的连接信息后 xff0c 发现并没有问题 xff0c 然后去虚拟机上查看ip地址 xff0c 发现是ip地址发生了

  • 在VMware Workstation中ubuntu屏幕小如何解决？-安装vm tools工具

    在VMware Workstation中ubuntu屏幕小如何解决 xff1f 安装vm tools工具 问题 xff1a 安装好ubuntu后 xff0c 开机后发现屏幕太小或没有占满全屏 xff0c 如下图所示 xff1a 解决 xff

  • 美团3.25笔试记录-第一题

    第一题 xff1a 题目描述 xff1a 小美是一个火车迷 最近她在观察家附近火车站的火车驶入和驶出情况 xff0c 发现火车驶入和驶出的顺序并不一致 经过小美调查发现 xff0c 原来这个火车站里面有一个类似于栈的结构 xff0c 如下图

  • Java中的取模(Math.floorMod())与取余(%)

    在Java中运算符 并不是取模运算 Modulo Operation xff0c 而是取余运算 Complementation 那么取模运算和取余运算的区别是什么呢 xff1f 计算方法 对于整数 a b 来说 xff0c 取模运算和取余运

  • redis的持久化策略

    redis提供持久化策略 xff0c 在适当的时机采用适当的手段把内存中的数据持久化到磁盘中 xff0c 每次redis服务启动时 xff0c 都可以把磁盘上的数据再次加载到内存中使用 RDB策略 xff08 数据快照模式 xff09 xf

  • HashMap的7种遍历方式

    HashMap的遍历方式 从大方向来说 xff0c HashMap遍历方式可以分为4类 xff1a 迭代器 xff08 Iterator xff09 方式遍历 xff1b For Each方式遍历 xff1b Lambda表达式遍历 xff

  • C语言中如何计算结构体的大小

    由于存储变量地址对齐的问题 xff0c 计算结构体大小的3条规则 xff1a 结构体的大小由n个 结构体中最大的那个类型 的大小模块组成 xff08 n lt 61 成员个数 xff09 xff1b 一个模块中 xff0c 可以存储多个成员

  • java多线程七大编程题(十分受用)

    前置须知知识 java多线程的实现方式主要由两种 一 创建子类继承Thread类 xff0c 重写run方法 span class token keyword public span span class token keyword cla

  • Java笔记（5）——类的继承、访问控制、super关键字

    在类中 xff0c 不写构造方法 xff0c 相当于执行了默认的无参构造方法 xff1b 写了有参构造方法 xff0c 则只执行有参构造方法 xff0c 默认的无参构造方法则会被屏蔽掉 xff1b 若想拥有有参和无参构造方法 xff0c 则

  • 配置maven使用本地仓库

    由于工作时是在内网环境 xff0c maven无法连接互联网 xff0c 所以只能事先将jar下载到本地 xff0c 然后通过配置pom文件 xff0c 将jar引用至本地仓库即可 1 首先 xff0c 我们需要打开本地的仓库 xff0c

  • Java中常用的几种JSON格式的转换

    JSON在传输数据时 xff0c 起到了特别大的作用 xff0c 因此出现了各种各样五花八门的JSON转换第三方包 xff0c 在这里做一个汇总 xff0c 总结一些常用的 目录 com alibaba fastjson 常用的API Ls

热门标签