FastJSON自定义工具类

已于 2024-01-17 13:54:54 修改
阅读量233 收藏
点赞数 1
分类专栏： JAVA 文章标签： java json javascript
于 2023-05-17 16:58:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AnameJL/article/details/130730038
版权

废话不多说,直接上代码

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

import java.util.*;

/**
 * @Author: J
 * @Version: 1.0
 * @CreateTime: 2023/5/9
 * @Description: JSON工具类
 **/
public class JSONUtils {

    /**
     *@Autor J
     *@Param jsonStr
     *@return JSONObject
     *@CreateTime 2023/5/10 11:05
     *@Version 1.0
     *@Description TODO 将JSON 字符串转成 JSONObject
    **/
    public static JSONObject str2JSONObject(String jsonStr) {
        JSONObject jsonObject = JSONObject.parseObject(jsonStr);
        return jsonObject;
    }

    /**
     * @return int
     * @Autor J
     * @Param jsonStr
     * @CreateTime 2023/5/9 14:38
     * @Version 1.0
     * @Description TODO 获取JSON字符串层级
     **/
    public static int getJSONDepth(String jsonStr) {
        JSONObject jsonObject = str2JSONObject(jsonStr);
        return getJSONDepth(jsonObject, 1);
    }

    /**
     * @return int
     * @Autor J
     * @Param jsonObject
     * @Param depth
     * @CreateTime 2023/5/9 14:38
     * @Version 1.0
     * @Description TODO 获取JSON Object对象层级
     **/
    public static int getJSONDepth(JSONObject jsonObject, int depth) {
        int maxDepth = depth;
        for (String key : jsonObject.keySet()) {
            Object value = jsonObject.get(key);
            if (value instanceof JSONObject) {
                int childDepth = getJSONDepth((JSONObject) value, depth + 1);
                if (childDepth > maxDepth) {
                    maxDepth = childDepth;
                }
            }
        }
        return maxDepth;
    }

    /**
     * @return Set<String>
     * @Autor J
     * @Param jsonObject
     * @Param level
     * @Param currentLevel
     * @CreateTime 2023/5/9 14:50
     * @Version 1.0
     * @Description TODO 根据指定层级返回key
     **/
    public static Set<String> getJSONKeyByLevel(Object json, int level, int currentLevel) {
        Set<String> keys = new HashSet<String>();
        if (currentLevel == level) {
            if (json instanceof JSONObject) {
                JSONObject jsonObject = (JSONObject) json;
                for (String key : jsonObject.keySet()) {
                    keys.add(key);
                }
            }
        } else {
            if (json instanceof JSONObject) {
                JSONObject jsonObject = (JSONObject) json;
                for (String key : jsonObject.keySet()) {
                    keys.addAll(getJSONKeyByLevel(jsonObject.get(key), level, currentLevel + 1));
                }
            } else if (json instanceof JSONArray) {
                JSONArray jsonArray = (JSONArray) json;
                for (Object obj : jsonArray) {
                    keys.addAll(getJSONKeyByLevel(obj, level, currentLevel + 1));
                }
            }
        }
        return keys;
    }

    /**
     * @return Object
     * @Autor J
     * @Param jsonObject
     * @Param key
     * @CreateTime 2023/5/9 15:46
     * @Version 1.0
     * @Description TODO 根据指定key返回value
     **/
    public static Object getValueByKey(JSONObject jsonObject, String key) {
        if (jsonObject.containsKey(key)) {
            return jsonObject.get(key);
        } else {
            for (String k : jsonObject.keySet()) {
                Object value = jsonObject.get(k);
                if (value instanceof JSONObject) {
                    Object result = getValueByKey((JSONObject) value, key);
                    if (result != null) {
                        return result;
                    }
                } else if (value instanceof JSONArray) {
                    JSONArray array = (JSONArray) value;
                    for (int i = 0; i < array.size(); i++) {
                        Object item = array.get(i);
                        if (item instanceof JSONObject) {
                            Object result = getValueByKey((JSONObject) item, key);
                            if (result != null) {
                                return result;
                            }
                        }
                    }
                }
            }
            return null;
        }
    }

    /**
     *@Autor J
     *@Param jsonObject
     *@return ArrayList<JSONObject>
     *@CreateTime 2023/5/10 10:44
     *@Version 1.0
     *@Description TODO 将JSONObject中1级key都以单独的JSONObject存储到ArrayList中
    **/
    public static List<JSONObject> getFirstJSONList(JSONObject jsonObject) {
        ArrayList<JSONObject> jsonObjectArrayList = new ArrayList<JSONObject>();
        // 获取JSONObject中所有1级key
        Set<String> firstJSONKeys = getJSONKeyByLevel(jsonObject, 1, 1);
        for (String firstKey : firstJSONKeys) {
            JSONObject levelJSONObject = new JSONObject();
            // 将1级key及value以JSONObject存储到List中
            levelJSONObject.put(firstKey, jsonObject.getJSONObject(firstKey));
            jsonObjectArrayList.add(levelJSONObject);
        }
        return jsonObjectArrayList;
    }

    /**
     *@Autor J
     *@Param jsonObject
     *@return List<JSONObject>
     *@CreateTime 2023/5/12 17:33
     *@Version 1.0
     *@Description TODO 获取第二级JSON,以一级key + 二级key分组组成新的JSON并存如List中
    **/
    public static List<JSONObject> getSecondJSONList(JSONObject jsonObject) {
        ArrayList<JSONObject> jsonObjectList = new ArrayList<JSONObject>();
        // 获取一级key
        String firstKey = jsonObject.keySet().iterator().next();
        // 获取二级JSON
        JSONObject secondJSON = (JSONObject) jsonObject.get(firstKey);
        // 将二级JSON打散成一个个JSON对象存储List中
        List<JSONObject> secondJSONList = getFirstJSONList(secondJSON);
        // 遍历打散的二级JSON List,将一级key作为key,将打散的二级JSONObject最为value进行存储
        for (JSONObject object : secondJSONList) {
            JSONObject newJSON = new JSONObject();
            newJSON.put(firstKey, object);
            jsonObjectList.add(newJSON);
        }
        return jsonObjectList;
    }

    /**
     *@Autor J
     *@Param jsonObject
     *@return List<JSONObject>
     *@CreateTime 2023/5/15 10:01
     *@Version 1.0
     *@Description TODO 获取第三级JSON,以一级key + 二级key + 三级key 分组组成新的JSON并存如List中
    **/
    public static List<JSONObject> getThirdJSONList(JSONObject jsonObject) {
        ArrayList<JSONObject> jsonObjects = new ArrayList<JSONObject>();
        // 获取一级key
        String firstKey = jsonObject.keySet().iterator().next();
        // 获取二级Key
        String secondKey = getJSONKeyByLevel(jsonObject, 2, 1).iterator().next();
        // 获取三级JSON
        JSONObject thirdJSON = (JSONObject) getValueByKey(jsonObject, secondKey);
        // 将三级JSON打散成一个个JSON对象存储到List中
        List<JSONObject> thirdJSONList = getFirstJSONList(thirdJSON);
        // 遍历打散的三级JSON List将一级key和二级key整合到打散的三级JSON中
        for (JSONObject object : thirdJSONList) {
            // 用以存储二级key,和三级JSON
            JSONObject jsonObject1 = new JSONObject();
            jsonObject1.put(secondKey, object);
            // 用以存储一级key和上文拼接好的二级JSON
            JSONObject jsonObject2 = new JSONObject();
            jsonObject2.put(firstKey, jsonObject1);
            // 将结果添加到List中
            jsonObjects.add(jsonObject2);
        }
        return jsonObjects;
    }

    /**
     *@Autor J
     *@Param jsonObject
     *@return List<JSONObject>
     *@CreateTime 2023/5/15 10:06
     *@Version 1.0
     *@Description TODO 以JSON前三级key为分组变成一个个JSON对象存储到List中
    **/
    public static List<JSONObject> getGroupBy3LevelJSONList(JSONObject jsonObject) {
        ArrayList<JSONObject> groupBy3LevelJSONList = new ArrayList<JSONObject>();
        // 获取一级JSON List
        List<JSONObject> firstJSONList = getFirstJSONList(jsonObject);
        for (JSONObject object : firstJSONList) {
            // 获取二级JSON List
            List<JSONObject> secondJSONList = getSecondJSONList(object);
            for (JSONObject jsonObject1 : secondJSONList) {
                // 获取三级JSON List
                List<JSONObject> thirdJSONList = getThirdJSONList(jsonObject1);
                // 将结果添加到List中
                groupBy3LevelJSONList.addAll(thirdJSONList);
            }
        }
        return groupBy3LevelJSONList;
    }
    /**
     *@Autor J
     *@Param jsonObject
     *@Param key
     *@return String
     *@CreateTime 2023/5/10 16:48
     *@Version 1.0
     *@Description TODO 获取JSON当前key及其所有父级key并拼接成字符串
    **/
    public static String getParentKeys(JSONObject jsonObject, String key) {
        for (String k: jsonObject.keySet()) {
            Object v = jsonObject.get(k);
            if (k.equals(key)) {
                return k;
            } else if (v instanceof JSONObject) {
                String result = getParentKeys((JSONObject) v, key);
                if (result != null) {
                    return k + "," + result;
                }
            }
        }
        return null;
    }

    /**
     *@Autor J
     *@Param jsonObject
     *@Param targetKey
     *@return List<String>
     *@CreateTime 2023/5/11 11:44
     *@Version 1.0
     *@Description TODO 根据传入的key获取该key的子节点key
    **/
    public static List<String> getChildKeys(JSONObject jsonObject, String targetKey) {
        ArrayList<String> childKeys = new ArrayList<String>();
        if (jsonObject == null || jsonObject.isEmpty()) {
            return childKeys;
        }
        for (String key : jsonObject.keySet()) {
            Object value = jsonObject.get(key);
            if (key.equals(targetKey)) {
                if (value instanceof JSONObject) {
                    for (String childKey : ((JSONObject) value).keySet()) {
                        childKeys.add(childKey);
                    }
                }
            } else if (value instanceof JSONObject) {
                childKeys.addAll(getChildKeys((JSONObject) value, targetKey));
            }
        }
        return childKeys;
    }

    /**
     *@Autor J
     *@Param jsonObject
     *@return List<String>
     *@CreateTime 2023/5/15 19:30
     *@Version 1.0
     *@Description TODO 将每个子节点递归拼接其父节点
    **/
    public static List<String> flattenJson(JSONObject jsonObject) {
        List<String> result = new ArrayList<String>();
        flattenJsonHelper(jsonObject, "", result);
        return result;
    }

    /**
     *@Autor J
     *@Param jsonObject
     *@Param prefix
     *@Param result
     *@return void
     *@CreateTime 2023/5/15 19:31
     *@Version 1.0
     *@Description TODO 递归拼接父节点
    **/
    private static void flattenJsonHelper(JSONObject jsonObject, String prefix, List<String> result) {
        for (Map.Entry<String, Object> entry : jsonObject.entrySet()) {
            String key = entry.getKey();
            Object value = entry.getValue();
            String newKey = prefix.isEmpty() ? key : prefix + "," + key;
            result.add(newKey);
            if (value instanceof JSONObject) {
                flattenJsonHelper((JSONObject) value, newKey, result);
            }
        }
    }
}
飞天小老头
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FastJson封装工具类（直接使用）
09-07
这是一个封装好的FastJson工具类、里面已经处理各种情况~分享给大家
fastjson工具类
大哥的阔落
06-09 576
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的学习使用
weixin_53998054的博客
07-21 1315
FastJson的学习
【常用工具类】fastjson
整理输出各类知识
11-01 256
在项目种经常要调用第三方的接口获取返回值，返回结果一般都是JSON格式的字符串，需要使用JSON解析工具进行解析，比较常用的就是fastjson。将对象或者集合序列化成JSON字符串。将JSON字符串反序列化为指定对象。将JSON数组的字符串转换为集合。目前感觉这三个在项目中就够用了。
Java工具库——FastJson的40个常用方法
最新发布
IT小辉同学
10-25 2018
那些想看却没看的书，在心里摆满一个图书馆。。。。。。
springboot整合Jackson实例项目-附工具类
03-21
说明：本篇讲的是Jackson的详细用法，Jackson工具类在文章最后，直接复制粘贴即可使用。 Jackson是公司中必用的组件之一，常用的还用阿里的Fastjson，但是由于一些原因bug与漏洞是在是太多，在注重安全的公司直接被...
java自定义类对象转json字符串（记录我是如何从一无所知到最后的了解）
12-22
写一个工具类，有两个方法，一个是输入类对象，输出类对象的json字符串，还有一个是输入json字符串和对象类型，输出类对象。 既然跟json有关，我开始百度了解json字符串： 百度是这样说的：JSON(JavaScript Object ...
Android-ZBLibrary：:fire:AndroidMVP快速开发框架，做本地“示例最全面”“注释最详细”“使用最简单”“代码最严谨”的Android开源UI框架。 ，简单的用法和严格的代码
02-21
MVP架构，提供一套开发标准（视图，数据，事件）以及模板和工具类并编写规范代码。封装层级少，简单高效兼容性好。 OKHttp网络请求，Glide图片加载，Zing二维码，沉浸状态栏，下载安装，自动缓存以及各种Base，...
敏感：java基于Java注释的Java敏感日志工具。 （基于注解的java脱敏框架，更优雅的日志打印）
02-03
普通的基于工具类方法的方式，对代码的入侵性太强。编写起来又特别麻烦。 本项目提供基于注解的方式，并内置了常见的脱敏方式，便于开发。 用户也可以基于自己的实际需要，自定义注解。 日志脱敏 为了金融交易的安全...
一个可以直接运行的基于SpringMVC的web框架1.1.12
05-26
工具类数据校验 jsp自定义标签 Spring自定义注解 默认requestMapping 1.1.2 代码生成器 1.1.3 首页修改 dateformat.js 时间参数转换 SpringMVC配置文件集中 快递参数接口 1.1.4 des加解密字符串和文件 1.1.5 redis...
FastJson快速上手【Json解析工具】
路漫漫其修远兮，吾将上下而求索
10-22 1988
针对JSON序列化和反序列化，为了方便快捷，我们一般使用json序列化工具进行操作常见的json序列化工具有Gson和FastJsonFastJson是阿里巴巴开源的项目，号称是速度最快的json解析工具。
Fastjson实用工具类，List转JSONString，List转JSONArray，JSONArray转List，JSONArray转ArrayList，JSONObject转HashMap
热门推荐
cucgyfjklx的博客
03-19 1万+
Fastjson实用工具类，List转JSONString，List转JSONArray，JSONArray转List，JSONArray转ArrayList，JSONObject转HashMap
阿里巴巴fastjson工具类,xml与json互转
文章仅作为参考使用，持续更新中，欢迎批评指导！
07-15 2487
fastjson工具类转xml，xml转json
fastjson- JSON工具类
ws - 兮的博客空间
05-08 380
一、工具类API API 说明 toJSONString(Object object) 将任意对象转为json字符串, 并忽略值为 null的属性（默认） toJSONStringNoNull(Object object) 将任意对象转为json字符串, 并忽略值为null的属性 toJSONStringIsNull(Object object) 将任意对象转为json字符串转为json字符串, 并保留值为null的属性 parse(String text) 把 JSON字符串转
java 基于fastjson封装的JSON工具类 JsonUtil
shengguimin的博客
04-09 405
/ 遍历jsonObject数据，添加到Map对象。// 遍历jsonObject数据，添加到Map对象。// 将json字符串转换成jsonObject。// 将json字符串转换成jsonObject。* string类型的json转换成map。* 通过键值,获取jsonObject。* 通过键值,获取jsonObject。* 是否是json字符串。
java json工具类（FastJson）
Code-lover's Learning Notes
07-09 2261
FastJSON是一个很好的java开源json工具类库，相比其他同类的json类库，它的速度的确是fast，最快！但是文档做得不好，在应用前不得不亲测一些功能。实际上其他的json处理工具都和它差不多，api也有几分相似。一、JSON规范 JSON是一个标准规范，用于数据交互，规范的中文文档如下： http://www.json.org/json-zh.html参看规范，来对比JSON类库处理
fastjson2工具类
wk的专栏
08-29 273
fastjson工具类
fastjson 自定义反序列化器
04-28
Fastjson 是一款高效的 Java 序列化和反序列化工具，可以轻松地将 Java 对象转换为 JSON 格式的数据。自定义反序列化器可以在 Fastjson 默认反序列化器的基础上，对某些数据进行特殊处理。 Fastjson 自定义反序列化...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值