精华内容
下载资源
问答
  • JSP/JAVA循环获取JSON中的KEY和VALUE

    千次阅读 2019-07-24 18:43:44
    JSP文件中循环获取JSON中的KV值: ...JAVA文件中循环获取JSON中的KEY值: 采用递归的方式,遍历JSON中所有的KEYJSON格式如下: {"username":"tom","age":18,"address":[{"province":"上海市"},{"...

    JSP文件中循环获取JSON中的KV值:

    https://blog.csdn.net/mcYang0929/article/details/83312548

    JAVA文件中循环获取JSON中的KEY值:

    采用递归的方式,遍历JSON中所有的KEY。
    
    JSON格式如下:
    
    {"username":"tom","age":18,"address":[{"province":"上海市"},{"city":"上海市"},{"disrtict":"静安区"}]}
    
    处理后,得到的结果如下:
    
    address|province|city|disrtict|username|age
    
    package ai.advance.until;
    import com.alibaba.fastjson.JSONObject;
    import com.alibaba.fastjson.JSONArray;
    
    public class fastJsonDiff {
        /**
         * 递归读取所有的key
         *
         * @param jsonObject
         */
        public static StringBuffer getAllKey(JSONObject jsonObject) {
            StringBuffer stringBuffer = new StringBuffer();
            Iterator<String> keys = jsonObject.keySet().iterator();// jsonObject.keys();
            while (keys.hasNext()) {
                String key = keys.next();
                stringBuffer.append(key.toString()).append("|");
                if (jsonObject.get(key) instanceof JSONObject) {
                    JSONObject innerObject = (JSONObject) jsonObject.get(key);
                    stringBuffer.append(getAllKey(innerObject));
                } else if (jsonObject.get(key) instanceof JSONArray) {
                    JSONArray innerObject = (JSONArray) jsonObject.get(key);
                    stringBuffer.append(getAllKey(innerObject));
                }
            }
            return stringBuffer;
        }
    
        public static StringBuffer getAllKey(JSONArray json1) {
            StringBuffer stringBuffer = new StringBuffer();
            if (json1 != null ) {
                Iterator i1 = json1.iterator();
                while (i1.hasNext()) {
                    Object key = i1.next();
                    if (key instanceof  JSONObject) {
                        JSONObject innerObject = (JSONObject) key;
                        stringBuffer.append(getAllKey(innerObject));
                    } else if (key instanceof JSONArray) {
                        JSONArray innerObject = (JSONArray) key;
                        stringBuffer.append(getAllKey(innerObject));
                    }else{
                    }
                }
            }
            return stringBuffer;
        }
    
        private final static String st1 = "{\"username\":\"tom\",\"age\":18,\"address\":[{\"province\":\"上海市\"},{\"city\":\"上海市\"},{\"disrtict\":\"静安区\"}]}";
        private final static String st2 = "{username:\"tom\",age:18}";
    
        public static void main(String[] args) {
            System.out.println(st1);
            JSONObject jsonObject1 = JSONObject.parseObject(st1);
            StringBuffer stb = getAllKey(jsonObject1);
            System.err.println(stb);
    
        }
    
    }

     

    展开全文
  • 使用java实现复杂结构多层级的json diff主要思路:遍历json,根据key排序,判断json element类型,如果是jsonArray的话,转成list并排序,并循环验证list中的每个json element是否相等package service.utils;...

    使用java实现复杂结构多层级的json diff

    主要思路:遍历json,根据key排序,判断json element类型,如果是jsonArray的话,转成list并排序,并循环验证list中的每个json element是否相等

    package service.utils;

    import com.google.gson.*;

    import org.slf4j.*;

    import org.testng.Assert;

    import java.util.*;

    public class JsonDiffUtil {

    private static final JsonParser parser = new JsonParser();

    private static final Gson gson = new Gson();

    //默认是忽略值比较

    private boolean diffValue = false;

    private static final Logger logger = LoggerFactory.getLogger(JsonDiffUtil.class);

    public JsonDiffUtil(){};

    public JsonDiffUtil(boolean diffValue){

    this.diffValue = diffValue;

    }

    /*

    * 验证两个json字符串结构是否一致,正反两次比较

    */

    public void diff(String exceptJson,String actualJson){

    Assert.assertTrue(equals(exceptJson, actualJson));

    Assert.assertTrue(equals(actualJson, exceptJson));

    }

    /**

    * 比较两个json字符串是否

    */

    public boolean equals(String exceptJson, String actualJson) {

    if(exceptJson.equals(actualJson)){

    return true;

    }

    //json String 转 JsonElement

    JsonElement exceptJsonElement = parser.parse(exceptJson);

    JsonElement actualJsonElement = parser.parse(actualJson);

    //按key排序

    sort(exceptJsonElement);

    sort(actualJsonElement);

    return equals(exceptJsonElement, actualJsonElement);

    }

    private boolean equals(JsonElement except, JsonElement actual) {

    if (except.isJsonObject()) {

    return equals(except.getAsJsonObject(), actual.getAsJsonObject());

    } else if (except.isJsonArray() ) {

    return equals(except.getAsJsonArray(), actual.getAsJsonArray());

    } else if (except.isJsonPrimitive()) {

    return equals(except.getAsJsonPrimitive(), actual.getAsJsonPrimitive());

    } else {

    logger.info("except= {},actual= {}",except,actual);

    return false;

    }

    }

    private boolean equals(JsonObject except, JsonObject actual) {

    Set exceptSet = except.keySet();

    for (String key : exceptSet) {

    JsonElement exceptValue = except.get(key);

    JsonElement actualValue = actual.get(key);

    if(actualValue == null){

    logger.error("not found key:"+key);

    return false;

    }

    if (exceptValue.isJsonArray() && exceptValue.getAsJsonArray().size() != actualValue.getAsJsonArray().size()) {

    logger.error("JSON Array size not equal,key is {}",key);

    return false;

    }

    boolean flag = equals(exceptValue, actualValue);

    if(!flag){

    if(exceptValue.isJsonPrimitive()){

    if (diffValue) {

    logger.error("value not equal,key is {}, except value is {}, actual value is {}",key,exceptValue,actualValue);

    }

    else {

    logger.error("not found key:"+key);

    }

    }

    return false;

    }

    }

    return true;

    }

    private boolean equals(JsonArray exceptArray, JsonArray actualArray) {

    List exceptList = toSortedList(exceptArray);

    List actaulList = toSortedList(actualArray);

    for (int i = 0; i < exceptList.size(); i++) {

    if (!equals(exceptList.get(i), actaulList.get(i))) {

    return false;

    }

    }

    return true;

    }

    private boolean equals(JsonPrimitive except, JsonPrimitive actual) {

    if(!diffValue){

    return actual != null;

    }

    return except.equals(actual);

    }

    private List toSortedList(JsonArray array) {

    List list = new ArrayList<>();

    array.forEach(list::add);

    list.sort(Comparator.comparing(gson::toJson));

    return list;

    }

    /*

    * 根据json key排序

    */

    public static void sort(JsonElement je) {

    if (je.isJsonNull()) {

    return;

    }

    if (je.isJsonPrimitive()) {

    return;

    }

    if (je.isJsonArray()) {

    JsonArray array = je.getAsJsonArray();

    Iterator it = array.iterator();

    while (it.hasNext()) {

    sort(it.next());

    }

    return;

    }

    if (je.isJsonObject()) {

    Map tm = new TreeMap(getComparator());

    for (Map.Entry en : je.getAsJsonObject().entrySet()) {

    tm.put(en.getKey(), en.getValue());

    }

    for (Map.Entry en : tm.entrySet()) {

    je.getAsJsonObject().remove(en.getKey());

    je.getAsJsonObject().add(en.getKey(), en.getValue());

    sort(en.getValue());

    }

    return;

    }

    }

    private static Comparator getComparator() {

    return String::compareTo;

    }

    }

    用到的依赖包

    org.testng

    testng

    6.9.8

    com.google.code.gson

    gson

    2.8.5

    org.slf4j

    slf4j-log4j12

    1.7.25

    原文:https://www.cnblogs.com/Eric-zhao/p/13154450.html

    展开全文
  • Set keys = body.keySet();for(String key :keys){System.out.println...}map循环json有可能有问题给模糊处理了。。不是原来的数据 了把json转为 map在把map中key 全大写了import com.alibaba.fastjson.JSON;import...

    Set keys = body.keySet();

    for(String key :keys){

    System.out.println(key.toUpperCase()+" "+body.get(key));

    }

    map循环

    json有可能有问题给模糊处理了。。不是原来的数据 了

    把json转为 map

    在把map中key 全大写了

    import com.alibaba.fastjson.JSON;

    import org.apache.commons.collections.map.HashedMap;

    import java.util.Map;

    import java.util.Set;

    public class JsonUtil {

    public static void main(String[] args) {

    String json2 ="{\"header\":{\"sdf\":\"sf\",\"fs\":\"ds1\",\"fas\":\"sfasdf\",\"code\":\"sfs\",\"message\":null},\"body\":\"{\\\"dsf\\\":\\\"sdf\\\",\\\"dsffds\\\":\\\"sffdsf\\\",\\\"realFromPartnerId\\\":\\\"sfsdf\\\",\\\"receiptNo\\\":\\\"sfdsaf\\\",\\\"responseMsg\\\":\\\"sfdsfsdfsdfassfasdfasdf\\\",\\\"sfsfsdffd\\\":\\\"1\\\",\\\"sfsdf\\\":\\\"fsfssfa\\\"}\"}";

    Map map = JSON.parseObject(json2,Map.class);

    Map header = JSON.parseObject( map.get("header").toString(),Map.class);

    Map header1 = getUpperMap(header);

    Map body = JSON.parseObject( map.get("body").toString(),Map.class);

    Map body1 = getUpperMap(body);

    System.out.println("调用后body"+body.toString());

    System.out.println("调用前body"+body1.toString());

    System.out.println("调用后header"+header.toString());

    System.out.println("调用前header"+header1.toString());

    }

    private static Map getUpperMap(Map body) {

    Set keys = body.keySet();

    Map body1 = new HashedMap();

    for(String key :keys){

    //System.out.println(key.toUpperCase()+" "+body.get(key));

    body1.put(key.toUpperCase(),body.get(key));

    }

    return body1;

    }

    }

    展开全文
  • JAVA JSON流式解析

    千次阅读 2018-11-12 14:28:51
    一次传入超大的JSON的数据(比如1G数据)到一个方法的内部,进行解析处理,很容易发生内存溢出,fastjson能流式的解析数据,比如1G的数据在获取传入方法内部之前先获取这1G的流,即每次只读取一点数据,依次去解析他的key-...

    一次传入超大的JSON的数据(比如1G数据)到一个方法的内部,进行解析处理,很容易发生内存溢出,fastjson能流式的解析数据,比如1G的数据在获取传入方法内部之前先获取这1G的流,即每次只读取一点数据,依次去解析他的key-value,解析得到单个key:value之后,只将单个key:value传入方法内部,使用while循环读取流中的数据,读取一次传入方法解析,解析完成之后再读取流的下一个位置的数据,因为这样调用解析这个方法一次之后,方法内部的内存数据会被标记为可回收状态,下一次GC会回收资源,所以程序占用的内存很小,可以解决内存溢出问题

    pom.xml依赖   <fastjson版本可根据需求设置,这里使用的是1.2.47>

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

    代码

    import com.alibaba.fastjson.JSONReader;
    
    import java.io.*;
    
    /**
     * JAVA Json流式解析
     */
    public class Stream {
        /**
         * 将字符串转化为Reader流
         * 这一种方式只是用于演示功能,因为整个字符串会加载在内存中,并不能降低内存消耗
         *
         * @return
         */
        public static Reader getStringReader(String jsonString) {
            Reader reader = new StringReader(jsonString);//转化为流
            return reader;
        }
    
        /**
         * 获取文件Reader流,推荐这一种方式
         *
         * @param pathFile json文件路径
         * @return
         */
        public static Reader getFileReader(String pathFile) throws FileNotFoundException {
            Reader reader = new FileReader(pathFile);//转化为流
            return reader;
        }
    
        /**
         * 获取其它Reader流,推荐http响应流等等
         *
         * @param inputStream 流
         * @return
         */
        public static Reader getHttpResponseReader(InputStream inputStream) {
            Reader reader = new InputStreamReader(inputStream);
            return reader;
        }
    
        /**
         * 按照JSON数组的方式解析
         * 数据示例: [{},{}]
         */
        public static void analysisArray(Reader reader) {
            JSONReader jsonArray = new JSONReader(reader);//传入流
            jsonArray.startArray();//相当于开始读整个json的Object对象。
            while (jsonArray.hasNext()) {//是否有下一个对象 {}
                Object jsonOne = jsonArray.readObject();
                //处理单个JSON对象内容 {}.这里可以再一次使用流式解析analysisObject,解析单个对象
                System.out.println(jsonOne);
            }
            jsonArray.endArray();//结束读取
            jsonArray.close();//关闭reader流
        }
    
        /**
         * 按照JSON对象的方式解析
         * 数据示例: {"k1":"v1","k2":"v2"}
         */
        public static void analysisObject(Reader reader) {
            JSONReader jsonObject = new JSONReader(reader);//传入流
            jsonObject.startObject();//相当于开始读整个json的Object对象。
            while (jsonObject.hasNext()) {//是否有下一个k-v值
                Object key = jsonObject.readObject();//获取key
                Object value = jsonObject.readObject();//获取value
                System.out.println(key + ":" + value);//处理kv值
            }
            jsonObject.endObject();//结束读取
            jsonObject.close();//关闭reader流
        }
    
        /**
         * 测试用例
         *
         * @param args
         * @throws IOException
         */
        public static void main(String[] args) throws IOException {
            //类型1
            String jsonStr = "{\"result\":[{\"name\":\"周瑜\",\"age\":13,\"hb\":114},{\"name\":\"黄盖\",\"age\":15,\"amt\":132}],\"message\":\"获取数据\",\"sum\":\"2\"}";
            Reader reader = getStringReader(jsonStr);
            analysisObject(reader);
            //类型2
            String jsonStrArray = "[{\"name\":\"周瑜\",\"age\":13,\"hb\":114},{\"name\":\"黄盖\",\"age\":15,\"amt\":132}]";
            Reader readerArray = getStringReader(jsonStrArray);
            analysisArray(readerArray);
            reader.close();//注意关闭流
            readerArray.close();
        }
    }
    展开全文
  • 循环遍历json

    千次阅读 2016-01-01 15:59:46
    #*被序列化前的java数据格式 Map> e.g:*# var dataObj=eval("("+data+")");//转换为json对象 $.each(dataObj,function(key,list) { alert(key); alert(list) //n 为List转换后的数组下标 //obj 为list中Person...
  • 当请求得到的数据不是json对象,而是map对象如理方式如下:var map = result.data.map;var infoText = "共有";var i = 0;for(var key in map) {i++;if(i < Object.getOwnPropertyNames(map).length){infoText += ...
  • 无论在将一个对象转为json字符串的时候采用何种算法,如果你的对象的属性的类型不是基本类型或对应的引用类型,转换应该都不会就此结束,那么有一种方式可以导致这种转换陷入无限循环:将某个对象的属性设为对象自己...
  • 首先html布局菜单jsonconst menuList = [{title: '首页',key: '/home'},{title: 'UI',key: '/ui',children: [{title: '按钮',key: '/ui/buttons',},{title: '弹框',key: '/ui/modals',},{title: 'Loading',key: '/ui...
  • java零碎点

    2018-08-13 16:45:18
    Gson: Java对象和Json之间的互转,一般用的比较多的两个类库是Jackson和Gson。Gson.fromJson &amp;Gson.toJson。 forEachRemainning: 迭代器循环处理。 Spark: mapWithState(StateSpec.function()) ...
  • 1.调用两个接口写代码循环删除可以先调用list接口,返回如下的的json信息然后循环调用delete接口一一删除以python为例:# -*- coding: utf-8 -*-from qiniu import Authfrom qiniu import BucketManageraccess_key =...
  • python之for循环遍历字典数据类型

    千次阅读 2018-12-21 18:24:58
    实际上,字典这种数据类型非常类似于JavaScript语言中的jsonJava语言的Map。 语法 {key1:value1,......} 特点 key不允许重复 for循环遍历 第一种 第二种 第三种 总结 字典在实际开发中用的很多,...
  • 问题背景:今天开发时需要一个功能,需要根据map的value 找出与之对应的key。这时候我想到了 lambda 表达式。 问题:lambda 表达式中 无法使用break;找到对应的不能手动结束循环。并且必须要是成员变量(final) 先...
  • 后来我转变思路,先用openssl以AES-128-ECB模式对第二步的串进行加密,获取到的结果和步骤三中的完全不一样,我改用先获取openssl的加密模式列表然后循环加密,输出各个加密方式的结果,发现没有一个能对上,到此以我的...
  • // 循环读取流,若不到结尾处 while ((line = bf.readLine()) != null) { //sb.append(bf.readLine()); String lin=new String(line.getBytes(), "utf-8"); sb.append(lin); } bf.close(); // 重要且易...
  • echo json_encode($res);exit; /*计算概率*/ function getRand($proArr) { $result = ''; /*概率数组的总概率精度*/ $proSum = array_sum($proArr); /*概率数组循环*/ foreach ($proArr as $key => $proCur)...
  • 一、处理JSONJSON知识: JSON 有两种格式:① Json ...java对象转Json: ① Bean 和 map —》Json 对象;② List —》 json数组 1、 返回JSON 加入 jar 包: 下载地址:https://repo1.maven.org/maven2/com/f
  • java对象转Json: ① Bean 和 map —》Json 对象;② List —》 json数组 1、 返回JSON 加入 jar 包: 下载地址:地址 注意: 请根据自己的Spring版本下载最新的jar,否则有肯能会报错。 报错异常可
  • fontobject application/x-msdownload image/x-icon image/webp application/json application/vnd.ms-access application/vnd.ms-project application/x-font-otf application/vnd.ms-opentype application/vnd....
  • [code="java"] $con = mysql_connect("localhost","root","5555555551"); //mysql_query("SET NAMES 'UTF-8'"); if (!$con) { die('Could not connect: ' . mysql_error()); } mysql_select_db("zuobiao...
  • python处理utf8编码中文,需要在py文件的第一行加入:# -*- coding:...打印中文列表时,使用循环 for key in list:print key 打印中文字典时,可以使用循环,也可以使用json: [code="java"]import ...
  • 表示从json中读取某个String类型key的值 getMap(JSONObject jsonObject, String key) 得到map getMap(String jsonData, String key) 得到map 表示从json中读取某个Map类型key的值 源码可见JSONUtils.java,更多...
  • 40、JSON操作相关 41、软键盘相关 42、打印日志 43、循环定时器 44、阴历阳历相关 45、m3u8文件解析类 46、偶对象相关 47、获取MD5相关 48、音频播放相关 49、共享内存相关 50、元数据相关 51、单币种货币类,处理...
  • <entry key="json" value="application/json" /> <entry key="jsonp" value="application/javascript" /> <property name="parameterName" value="return_fmt"></property> ...
  • data : {"queryDate" : $("queryDate").val()},//(Map) :发送至服务器的 key/value 数据 type : "POST",//客户端请求的类型(JSON,XML,等等) dataType : "json", columns : [ {field : 'orgId',...
  • go key/value存储 https://github.com/etcd-io/bbolt 基于ringbuffer的无锁golang workpool https://github.com/Dai0522/workpool 轻量级的协程池 https://github.com/ivpusic/grpool 打印go的详细数据...
  • 为了解开"死循环",你可以在第一次下载平台证书时,按照下述方法临时"跳过”应答签名的验证。 CloseableHttpClient httpClient = WechatPayHttpClientBuilder.create() .withMerchant(mchId, mchSerialNo, ...
  • RESTful API风格接口化、Json形式数据传输 前端页面进行了升级,引用了一些基本的组件,如dataTables.js、bootstrap.js、bootbox.js 前端没有采用主流框架如Vue、React等,使用基本的HTML+CSS+JQ也减轻了上手难度 ...

空空如也

空空如也

1 2
收藏数 35
精华内容 14
关键字:

java循环jsonkey

java 订阅