java----JSON

最新推荐文章于 2024-06-25 17:03:05 发布
最新推荐文章于 2024-06-25 17:03:05 发布
阅读量120 收藏
点赞数
文章标签： json java
原文链接：http://www.cnblogs.com/yanxiaoge/p/10772625.html
版权

 JSON：

下载组件 GSON jar 包

https://mvnrepository.com/artifact/com.google.code.gson/gson

创建JSON

import com.google.gson.JsonArray;
import com.google.gson.JsonObject;

import java.io.*;
import java.util.ArrayList;


public class Demo {
    public static void main(String[] args) throws IOException {
        createJson();
    }
    public static void createJson(){
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("花花",10));
        list.add(new Person("哈哈",12));
        JsonArray jsonElements = new JsonArray();
        for (int i = 0; i < list.size(); i++) {
            JsonObject jsonObject = new JsonObject();
            jsonObject.addProperty("name",list.get(i).getName());
            jsonObject.addProperty("age",list.get(i).getAge());
            jsonElements.add(jsonObject);
        }
        //
        System.out.println(jsonElements.toString());
        try {
            BufferedWriter bw = new BufferedWriter(new FileWriter("a.json"));
            bw.write(jsonElements.toString());
            bw.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
class Person{
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Person() {
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

　　

解析json数据(适合解析复杂的json数据)

必须严格准守解析流程，中途如果出现错误，就会发生解析失败

[]  : beginArray;

{} : beginObject;

import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;

import java.io.*;
import java.util.ArrayList;

public class Demo {
    public static void main(String[] args){
        jsonParse();
    }
    public static void jsonParse(){
        try {
            InputStream resourceAsStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("json\\person_json.json");
            InputStreamReader inputStreamReader = new InputStreamReader(resourceAsStream);
            //json解释工具a
            JsonReader jsonReader = new JsonReader(inputStreamReader);
            ArrayList<Person> nameList = new ArrayList<>();
            //开始解析数组
            jsonReader.beginArray();
            while (jsonReader.hasNext()){
                nameList.add(parsePerson(jsonReader));
            }
            //结束解析数组
            jsonReader.endArray();
            nameList.forEach((p)-> System.out.println(p));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    private static Person parsePerson(JsonReader jsonReader) throws IOException {
        Person person = new Person();
        jsonReader.beginObject();
        while (jsonReader.hasNext()){
            String name = jsonReader.nextName();
            if ("name".equals(name)&&jsonReader.peek()!=JsonToken.NUMBER){
                person.setName(jsonReader.nextString());
            }else if("age".equals(name)){
                person.setAge(Integer.parseInt(jsonReader.nextString()));
            }else{
                //表示当所有都不成立的时候,就跳过该字段；解析下一个
                jsonReader.skipValue();
            }
        }
        jsonReader.endObject();
        return person;
    }
}
class Person{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

json数据

[{"name":"花花","age":"10"},{"name":"哈哈","age":"10"}]

　　

补充：

{"name":null}

while (jsonReader.hasNext()){
            String name = jsonReader.nextName();
            if ("name".equals(name)&&jsonReader.peek()!=JsonToken.NULL){
                person.setName(jsonReader.nextString());//表示如果name为空，就不设置值，此时默认情况下，就为空
            }else{
　　　　　　　　　　//跳过该字段
　　　　　　　　　　jsonReader.skipValue()　
　　　　　　　}
}

 

JsonReader.peek()：看看值：没有真正的读取；(即光标没有移动)

JsonToken.STRING  ：值是否为字符串

JsonToken.NUMBER：值是否为数字

jsonReader.nextString()：读取字符串；

JsongReader.nextInt()：读取int数据

jsonReader.nextDouble()：读取数组：

 

使用GSON工具解析json数据为单个对象

将一个java对象转换为json字符串，或者将json字符串解析并创建java对象

注意：只能是一个对象；

import com.google.gson.Gson;

import java.io.*;

public class Demo {
    public static void main(String[] args) {
        Mygson();
    }

    private static void Mygson() {
        Gson gson = new Gson();
        InputStream resourceAsStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("json\\person_json.json");
        InputStreamReader inputStreamReader = new InputStreamReader(resourceAsStream);
        Person person = gson.fromJson(inputStreamReader, Person.class);
        System.out.println(person);
    }
}
class Person{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

json数据

{"name":"花花","age":10}

　　

把一组JSON数据转换为java对象集合，或者把一个java对象集合转换为Json字符串

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.io.*;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
        Mygson();
    }

    private static void Mygson() {
        Gson gson = new Gson();
        InputStream resourceAsStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("json" +
                "\\person_json.json");
        InputStreamReader inputStreamReader = new InputStreamReader(resourceAsStream);
        TypeToken<List<Person>> listTypeToken = new TypeToken<List<Person>>() {
        };
        List<Person> list = gson.fromJson(inputStreamReader, listTypeToken.getType());
        System.out.println(list);
        System.out.println("---------------------------------------------------------");

        //将list对象转换json字符串
        String s = gson.toJson(list, listTypeToken.getType());
        System.out.println(s);
    }
}
class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

json数据

[{"name":"花花","age":"10"},{"name":"哈哈","age":"10"}]

　　

 

MapperUtils

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;

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


public class MapperUtils {
    private final static ObjectMapper objectMapper = new ObjectMapper();

    public static ObjectMapper getInstance() {
        return objectMapper;
    }

    /**
     * 转换为 JSON 字符串
     *
     * @param obj
     * @return
     * @throws Exception
     */
    public static String obj2json(Object obj) throws Exception {
        return objectMapper.writeValueAsString(obj);
    }

    /**
     * 转换为 JSON 字符串，忽略空值
     *
     * @param obj
     * @return
     * @throws Exception
     */
    public static String obj2jsonIgnoreNull(Object obj) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        return mapper.writeValueAsString(obj);
    }

    /**
     * 转换为 JavaBean
     *
     * @param jsonString
     * @param clazz
     * @return
     * @throws Exception
     */
    public static <T> T json2pojo(String jsonString, Class<T> clazz) throws Exception {
        objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
        return objectMapper.readValue(jsonString, clazz);
    }

    /**
     * 字符串转换为 Map<String, Object>
     *
     * @param jsonString
     * @return
     * @throws Exception
     */
    public static <T> Map<String, Object> json2map(String jsonString) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        return mapper.readValue(jsonString, Map.class);
    }

    /**
     * 字符串转换为 Map<String, T>
     */
    public static <T> Map<String, T> json2map(String jsonString, Class<T> clazz) throws Exception {
        Map<String, Map<String, Object>> map = objectMapper.readValue(jsonString, new TypeReference<Map<String, T>>() {
        });
        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
     */
    public static Map<String, Object> json2mapDeeply(String json) throws Exception {
        return json2MapRecursion(json, objectMapper);
    }

    /**
     * 把 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;
    }

    /**
     * 将 JSON 数组转换为集合
     *
     * @param jsonArrayStr
     * @param clazz
     * @return
     * @throws Exception
     */
    public static <T> List<T> json2list(String jsonArrayStr, Class<T> clazz) throws Exception {
        JavaType javaType = getCollectionType(ArrayList.class, clazz);
        List<T> list = (List<T>) objectMapper.readValue(jsonArrayStr, javaType);
        return list;
    }


    /**
     * 获取泛型的 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
     *
     * @param map
     * @param clazz
     * @return
     */
    public static <T> T map2pojo(Map map, Class<T> clazz) {
        return objectMapper.convertValue(map, clazz);
    }

    /**
     * 将 Map 转换为 JSON
     *
     * @param map
     * @return
     */
    public static String mapToJson(Map map) {
        try {
            return objectMapper.writeValueAsString(map);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 将 JSON 对象转换为 JavaBean
     *
     * @param obj
     * @param clazz
     * @return
     */
    public static <T> T obj2pojo(Object obj, Class<T> clazz) {
        return objectMapper.convertValue(obj, clazz);
    }
}

 使用

ObjectMapper instance = MapperUtils.getInstance(); 
JsonNode jsonNode = instance.readTree(data);  //封装的json字符串
JsonNode data1 = jsonNode.findPath("data");   //找到key为data的数据
String s = data1.toString();                  //data1转换为String
List<TbContent> tbContentDtos = MapperUtils.json2list(s, TbContent.class);  //json数据变成java对象

　　

转载于:https://www.cnblogs.com/yanxiaoge/p/10772625.html

weixin_30256505
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
序列化工具(Gson, Jackson, FastJson, ProtoBuf)
02-23
各种序列化工具类，包括Gson, Jackson, FastJson, ProtoBuf以及proto.exe，希望大家喜欢
SpringBoot--封装JSON工具类（基于Jackson）
IT利刃出鞘的博客
09-28 1794
本文提供一个JSON工具类，本工具是对Jackson（也就是ObjectMapper）的封装。
springboot中的jackson配置及Jackson工具类分享
vampire_Violet的博客
04-01 2865
文章目录springboot中的Jackson配置Jackson工具类 springboot中的Jackson配置 spring: jackson: # 设置属性命名策略,对应jackson下PropertyNamingStrategy中的常量值，SNAKE_CASE-返回的json驼峰式转下划线，json body下划线传到后端自动转驼峰式 property-...
jackson 序列化工具类
愿世界和平
08-11 777
jackson 序列化工具类\ 代码如下 ↓↓↓↓ package com.mmall.util; import com.google.common.collect.Lists; import com.mmall.pojo.Category; import com.mmall.pojo.TestPojo; import com.mmall.pojo.User; import lombok...
jackson序列化工具类
qq_42794038的博客
06-07 412
public class JsonMapper { private static final Logger LOGGER=LogManager.getLogger(JsonMapper.class); private ObjectMapper mapper; public JsonMapper() { this(null); } public JsonMapper(Include include) { mapper = new ObjectMapper(); // 设置输出时.
java-json.jar.zip
06-27
Java JSON.jar.zip是一个压缩包，其中包含了一个名为`java-json.jar`的Java库，这个库主要功能是处理XML和JSON之间的转换。XML（Extensible Markup Language）和JSON（JavaScript Object Notation）是两种广泛用于...
JAVA-JSON工具转换类
06-19
在JAVA开发中，处理JSON数据通常需要借助特定的库来完成，如本话题中提到的`json-lib`和`ezmorph`。 `json-lib`是一个Java语言实现的JSON库，它提供了多种数据类型到JSON的转换，包括JavaBean、Map、List、数组等。...
jsonld-java:Java的JSON-LD实现
04-29
用法从Maven <dependency> <groupId>com.github.jsonld-java</groupId> <artifactId>jsonld-java</artifactId> <version>0.13.3</version></dependency>代码示例// Open a valid json(-ld) input fileInputStream ...
simple-json-rpc:Java的简单JSON-RPC
03-06
目的是提供一种简单，快速和可靠的方法，以将JSON-RPC 2.0协议集成到服务器和/或客户端上的Java应用程序中。 为此，您需要配置JsonRpcClient或JsonRpcServer并实现传输代码-库负责其余工作。 没有手动的JSON转换，...
json-2.2.1可用
02-22
描述中提到的"json-2.2.1"可能是指一个特定的Java JSON处理库，比如Gson或Jackson，这两个都是Java开发者常用的JSON库。它们提供了将Java对象转换为JSON字符串以及将JSON字符串反序列化为Java对象的能力，极大地简化...
jackson序列化方法实现
09-19
支持列表 范型的转换等工具 Json字符串生成或解析处理工具类
Springboot项目常用工具类
qq_45243783的博客
08-18 3309
json转换工具类
基于jackson的序列化工具类
Fighting
04-07 493
1.引入maven依赖 <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.9.9</version> </de...
Jackson Json序列化和反序列化工具类
ks_1998的博客
03-21 410
Jackson Json序列化和反序列化工具类
json序列化工具类 用的jackson包
在写bug的路上越走越远
11-23 1985
序列化类可以根据自己的需要自定义增删。 package com.home.util; import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAccessor; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.core.JsonParser; i
SpringBoot中的Jackson使用笔记
ThinkPet
07-01 558
springboot中使用jackson笔记
全面掌握 Jackson 序列化工具：原理、使用与高级配置详解
最新发布
微笑听雨
06-25 2308
Jackson 是一个功能强大的 JSON 处理库，广泛应用于 Java 项目中。它提供了丰富的功能和灵活的配置选项，可以轻松地在 Java 对象和 JSON 数据之间进行转换。本文将详细介绍 Jackson 的核心概念、基本用法、高级配置及处理集合类型的数据，旨在帮助你全面掌握 Jackson 的使用方法
【高效开发插件】12 MapperUtils JackSon 工具类
Yuu
02-28 631
import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.da...
JackSon的自定义工具类
m0_53025743的博客
06-17 659
static {
使用JSON-RPC-Java构建下一代Web应用
"这是一份关于使用JSON-RPC与Java构建下一代Web应用程序的演讲稿，由Michael Clark在2005年2月25日发表。演讲内容涵盖了当前Web交互的状态、更动态的方法、Web应用程序（Weblication）的概念以及Web远程调用，特别...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值