AI 助理
备案控制台
开发者社区 云计算 文章 正文

复杂数据的几种遍历方式（有点绕）

2023-07-13 63
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 复杂数据的几种遍历方式（有点绕）

我们有一组原始数据，通过原始数据转化成为固定想要的数据；

原始数据：
{data=[{类别=电网基建, 金额=2208.8}, {类别=生成科技, 金额=55.1}], name=sheet1}
转换后的数据：
{"sheets":[{"datas":[{"cells":[{"dataType":2,"value":"电网基建"},{"dataType":1,"value":"2208.8"}]},{"cells":[{"dataType":2,"value":"生成科技"},{"dataType":1,"value":"55.1"}]}],"name":"sheet1","titles":["类别","金额"]}]}

DEMO1

package com.example.democrud.democurd.sqldemo;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;
import java.util.*;
public class Demo02 {
    static String regStr = "^[+-]?[1-9][0-9]*$|^0$";
    public static void main(String[] args) {
        String sql = "{\"data\":[{\"类别\": '电网基建', \"金额\": \"2208.8\"},{\"类别\":'生成科技', \"金额\": \"55.1\"}],\"name\":\"sheet1\"}";
        JSONObject jsonObject = JSONObject.parseObject(sql,Feature.OrderedField);
        JSONArray jsonArray = JSONArray.parseArray(jsonObject.get("data").toString());
        Set<String> titleSet = new HashSet<>();
        List<JSONObject> cells = new ArrayList<>();
        for (Object o : jsonArray) {
            if(Objects.isNull(o)){
                continue;
            }
            JSONObject json = JSONObject.parseObject(o.toString(),Feature.OrderedField);
            for (Map.Entry<String, Object> stringObjectEntry : json.entrySet()) {
                titleSet.add(stringObjectEntry.getKey());
                String value = stringObjectEntry.getValue().toString();
                JSONObject sing = new JSONObject();
                sing.put("value", value);
                if(value.matches(regStr)) {
                    sing.put("dataType", 1);
                }else{
                    sing.put("dataType", 2);
                }
                cells.add(sing);
            }
        }
        JSONObject cellsJson = new JSONObject();
        cellsJson.put("cells", cells);
        cellsJson.put("name", jsonObject.get("name"));
        cellsJson.put("titles", titleSet);
        JSONArray sheetsArray = new JSONArray();
        sheetsArray.add(cellsJson);
        JSONObject result = new JSONObject();
        result.put("sheets", sheetsArray);
        System.out.println("原始数据:" + jsonObject);
        System.out.println("修改后数据：" + result);
    }
}
原始数据:{"data":[{"类别":"电网基建","金额":"2208.8"},{"类别":"生成科技","金额":"55.1"}],"name":"sheet1"}
修改后数据：{"sheets":[{"cells":[{"dataType":2,"value":"2208.8"},{"dataType":2,"value":"电网基建"},{"dataType":2,"value":"55.1"},{"dataType":2,"value":"生成科技"}],"name":"sheet1","titles":["金额","类别"]}]}

上面那个方式基本都是正常的，只是有些许问题；

DEMO1 优化

package com.example.democrud.democurd.sqldemo;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;
import java.util.*;
public class Demo02 {
    static String regStr = "^[+-]?[1-9][0-9]*$|^0$";
    public static void main(String[] args) {
        String sql = "{\"data\":[{\"类别\": '电网基建', \"金额\": \"2208.8\"},{\"类别\":'生成科技', \"金额\": \"55.1\"}],\"name\":\"sheet1\"}";
        JSONObject jsonObject = JSONObject.parseObject(sql);
        JSONArray jsonArray = JSONArray.parseArray(jsonObject.get("data").toString());
        Set<String> titleSet = new HashSet<>();
        List<JSONObject> cells = new ArrayList<>();
        for (Object o : jsonArray) {
            if(Objects.isNull(o)){
                continue;
            }
            JSONObject json = JSONObject.parseObject(o.toString());
            JSONObject jsonObject1 = new JSONObject();
            JSONArray jsonArray1 = new JSONArray();
            for (Map.Entry<String, Object> stringObjectEntry : json.entrySet()) {
                titleSet.add(stringObjectEntry.getKey());
                String value = stringObjectEntry.getValue().toString();
                JSONObject sing = new JSONObject();
                if(value.matches(regStr)) {
                    sing.put("dataType", 1);
                }else{
                    sing.put("dataType", 2);
                }
                sing.put("value", value);
                jsonArray1.add(sing);
            }
            jsonObject1.put("cells", jsonArray1);
            jsonArray1.sort(Comparator.comparing(obj -> ((JSONObject) obj).getString("value").length()));
            cells.add(jsonObject1);
        }
        JSONObject cellsJson = new JSONObject();
        cellsJson.put("data", cells);
        cellsJson.put("name", jsonObject.get("name"));
        cellsJson.put("titles", titleSet);
        JSONArray sheetsArray = new JSONArray();
        sheetsArray.add(cellsJson);
        JSONObject result = new JSONObject();
        result.put("sheets", sheetsArray);
        System.out.println("原始数据:" + jsonObject);
        System.out.println("修改后数据：" + result);
    }
}
原始数据:{"data":[{"金额":"2208.8","类别":"电网基建"},{"金额":"55.1","类别":"生成科技"}],"name":"sheet1"}
修改后数据：{"sheets":[{"data":[{"cells":[{"dataType":2,"value":"电网基建"},{"dataType":2,"value":"2208.8"}]},{"cells":[{"dataType":2,"value":"55.1"},{"dataType":2,"value":"生成科技"}]}],"name":"sheet1","titles":["金额","类别"]}]}

DEMO2

package com.ruoyi.web.controller.tool;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import java.util.*;
public class demo03 {
    static String regStr = "^[+-]?([1-9][0-9]*|0)(\\.[0-9]+)?$";
    public static void main(String[] args) {
        String sql = "{\"data\":[{\"类别\": '电网基建', \"金额\": \"2208.8\"},{\"类别\":'生成科技', \"金额\": \"55.1\"}],\"name\":\"sheet1\"}";
        Map map = json2Map(sql);
        System.out.println(map.toString());
        JSONObject sheets = new JSONObject(){{
            put("sheets",new JSONArray(){{
                add(new JSONObject(){{
                    put("datas",new JSONArray(){{
                        ((List<Map>)map.get("data")).forEach(d->{
                            add(new JSONObject(){{
                                put("cells",new JSONArray(){{
                                    d.values().forEach(e->{
                                        add(new JSONObject(){{
                                            if (e.toString().matches(regStr)){
                                                put("dataType",1);
                                            }else {
                                                put("dataType",2);
                                            }
                                            put("value",e);
                                        }});
                                    });
                                }});
                            }});
                        });
                    }});
                    put("name",map.get("name"));
                    put("titles",((List<Map>)map.get("data")).get(0).keySet());
                }});
            }});
        }};
        System.out.println(sheets);
    }
    public static Map<String, Object> json2Map(String jsonStr){
        Map<String, Object> map = new TreeMap<>();
        JSONObject json = JSON.parseObject(jsonStr);
        if (jsonStr != null||!"".equals(jsonStr)){
            for (Object k : json.keySet()){
                Object v = json.get(k);
                if (v instanceof JSONArray){
                    List<Map<String, Object>> list = new ArrayList<>();
                    Iterator<Object> it = ((JSONArray)v).iterator();
                    while (it.hasNext()){
                        list.add(json2Map(it.next().toString()));
                    }
                    map.put(k.toString(), list);
                }else if(v instanceof JSONObject){
                    map.put(k.toString(), json2Map(v.toString()));
                }else {
                    map.put(k.toString(), v);
                }
            }
            return map;
        }else {
            return null;
        }
    }
}
{data=[{类别=电网基建, 金额=2208.8}, {类别=生成科技, 金额=55.1}], name=sheet1}
{"sheets":[{"datas":[{"cells":[{"dataType":2,"value":"电网基建"},{"dataType":1,"value":"2208.8"}]},{"cells":[{"dataType":2,"value":"生成科技"},{"dataType":1,"value":"55.1"}]}],"name":"sheet1","titles":["类别","金额"]}]}

Demo3

有点乱不太推荐

package com.example.democrud.democurd.sqldemo;
import com.alibaba.fastjson.JSON;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.commons.lang3.StringUtils;
import java.util.*;
public class demo01 {
    public static void main(String[] args) {
        //  String sql = "{data:[{id: 242124591104, fileName: \"接口文档-1675230120230.pdf\", filePath: \"/file/SECOND/\", fileType: \"1\"}],[{id: 24218888888, fileName: \"接口文档-167588888.pdf\", filePath: \"/file/SECOND/\", fileType: \"8\"}],\"name\":\"sheet1\"}";
        String sql = "{\"data\":[{\"类别\": '电网基建', \"金额\": \"2208.8\"},{\"类别\":'生成科技', \"金额\": \"55.1\"}],\"name\":\"sheet1\"}";
        user user3 = new user();
        JSONObject json = JSONObject.fromObject(sql);
        if (StringUtils.isNoneBlank(json.get("name").toString())){
            user3.setName(json.get("name").toString());
        }
      //  Map<String, Object> map = json2Map(sql);
        Map<String, Object> map = json2Map(sql);
        System.out.println("------------------------------");
        Object map1 = map.get("data");
        System.out.println(map1);
        HashMap<Object, Object> map4 = new HashMap<>();
        List<Object> list1 = new ArrayList<>();
        List<Object> list2 = new ArrayList<>();
        List<Object> list3 = new ArrayList<>();
        List<Object> list4 = new ArrayList<>();
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            String key = entry.getKey();
            System.out.println("key===>" + key);
            Object list = entry.getValue();
            System.out.println("list===>" + list);
            JSONArray aa = JSONArray.fromObject(list);
            System.out.println("aa===>" + aa);
            for (Object map2 : aa) {
                String regStr = "^[+-]?[1-9][0-9]*$|^0$";
                int te;
                JSONObject map3 = JSONObject.fromObject(map2);
                String values;
                for (Object entry1 : map3.entrySet()) {
                    String keys= (String) ((Map.Entry)entry1).getKey();
                    values = (String) ((Map.Entry)entry1).getValue();
                    System.out.println("key的值==>"+keys);
                    System.out.println("value的值==>"+values);
                    if(values.matches(regStr)) {
                        te=1;
                    }else{
                        te=2;
                    }
                     user1 user1 = new user1(te,values);
                    String str1 = JSON.toJSONString(user1);
                    list1.add(str1);
                    System.out.println(list1);
                  list3.add(keys);
                }
            }
            list3.forEach(i -> {
                if (!list4.contains(i)) { // 如果新集合中不存在则插入
                    list4.add(i);
                }
            });
            list2.addAll(list1);
            map4.put("cells",list2);
            map4.put("titles",list4);
            map4.put("name",user3.getName());
            System.out.println(map4);
       HashMap<Object, Object> map5 = new HashMap<>();
            map5.put("sheets",map4);
            System.out.println(map5);
        }
    }
    public static Map<String, Object> json2Map(String sql) {
        Map<String, Object> map = new HashMap<>();
        HashMap<String, Object> hashMap = new HashMap<>();
        if (sql != null && !"".equals(sql)) {
            //转换为json
            JSONObject json = JSONObject.fromObject(sql);
            System.out.println("json的==》"+json);
            for (Object k : json.keySet()) {
                Object v = json.get(k);
                System.out.println("获取的k==>" + k + ":获取的v==>" + v);
                map.put(k.toString(), v);
               /* if (v instanceof JSONArray) {
                    List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
                    Iterator iterator = ((JSONArray) v).iterator();
                    while (iterator.hasNext()) {
                        Object next = iterator.next();
                        list.add(json2Map(next.toString()));
                    }
                    map.put(k.toString(), list);
                } else {
                    map.put(k.toString(), v);
                }*/
                System.out.println("map的值---1------------------"+map);
                return map;
            }
            System.out.println("map的值---2------------------"+map);
            return map;
        }else {
            return null;
        }
    }
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public static class user1 {
        //k的值的类型
        public int dataType;
        //v的值
        public String value;
    }
        public static class user{
        //k的值的类型
        public String dataType;
        //v的值
        public String value;
        //表的值  表名
        public String name;
        //k的值 数据方式展示
        public byte titles[];
        //集合 包住值的类型和值
        public  List<Object> cells;
        public String getDataType() {
            return dataType;
        }
        public void setDataType(String dataType) {
            this.dataType = dataType;
        }
        public String getValue() {
            return value;
        }
        public void setValue(String value) {
            this.value = value;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public byte[] getTitles() {
            return titles;
        }
        public void setTitles(byte[] titles) {
            this.titles = titles;
        }
        public List<Object> getCells() {
            return cells;
        }
        public void setCells(List<Object> cells) {
            this.cells = cells;
        }
    }
}
json的==》{"data":[{"类别":"电网基建","金额":"2208.8"},{"类别":"生成科技","金额":"55.1"}],"name":"sheet1"}
获取的k==>data:获取的v==>[{"类别":"电网基建","金额":"2208.8"},{"类别":"生成科技","金额":"55.1"}]
map的值---1------------------{data=[{"类别":"电网基建","金额":"2208.8"},{"类别":"生成科技","金额":"55.1"}]}
------------------------------
[{"类别":"电网基建","金额":"2208.8"},{"类别":"生成科技","金额":"55.1"}]
key===>data
list===>[{"类别":"电网基建","金额":"2208.8"},{"类别":"生成科技","金额":"55.1"}]
aa===>[{"类别":"电网基建","金额":"2208.8"},{"类别":"生成科技","金额":"55.1"}]
key的值==>类别
value的值==>电网基建
[{"dataType":2,"value":"电网基建"}]
key的值==>金额
value的值==>2208.8
[{"dataType":2,"value":"电网基建"}, {"dataType":2,"value":"2208.8"}]
key的值==>类别
value的值==>生成科技
[{"dataType":2,"value":"电网基建"}, {"dataType":2,"value":"2208.8"}, {"dataType":2,"value":"生成科技"}]
key的值==>金额
value的值==>55.1
[{"dataType":2,"value":"电网基建"}, {"dataType":2,"value":"2208.8"}, {"dataType":2,"value":"生成科技"}, {"dataType":2,"value":"55.1"}]
{cells=[{"dataType":2,"value":"电网基建"}, {"dataType":2,"value":"2208.8"}, {"dataType":2,"value":"生成科技"}, {"dataType":2,"value":"55.1"}], name=sheet1, titles=[类别, 金额]}
{sheets={cells=[{"dataType":2,"value":"电网基建"}, {"dataType":2,"value":"2208.8"}, {"dataType":2,"value":"生成科技"}, {"dataType":2,"value":"55.1"}], name=sheet1, titles=[类别, 金额]}}

递归小demo(上面用到了 简单理解下)

我的理解 ：（不对别骂我）

递归 是不是就是 执行 递归循环（也就是符合跳出条件）跳出循环之后先输出跳出的循环的值 然后依次倒序输出 中间的过程

这个文章写的不错大家可以才看下；

参考

package com.example.democrud.democurd.sqldemo;
import lombok.Data;
import java.util.Date;
public class demo5 {
    public static int test(int i){
        System.out.println("这是"+i);
        return i+1;
    }
    public static void test2(int i){
        if (i>2){
            System.out.println("i=="+i);
        }else {
            System.out.println("i="+i+"进入递归");
            test2(i+1);
            System.out.println("i="+i+"递归屁股");
        }
    }
    public static void main(String[] args) {
      //  methodTest(9);
      //  test(test(test(1)));
  /*    test2的理解：
当i为1的时候，进入方法体，i=1>2 不满足进入else递归中，i=1+1=2 此时的i=2 他也不大于2 故再次else 2+1=3; 3>2 故进入 if方法中输出if中的sout;
其次 这块的我的理解 就是倒序 输入前面的2个值   */
      //  test2(1);
        test3(5);
    }
    public static void test3(int i){
      if (i<1){
          System.out.println(i);
      }else{
          System.out.println("开始"+i);
          test3(i-2);
          System.out.println("中间"+i);
      //    test(i*2-1);
      //    System.out.println("结尾"+i);
      }
    }
    /*
     * @Author LY
     * @Description 递归方式实现九九乘法表
     * @Date 22:21 2020/8/13
     **/
    private static void methodTest(int i) {
        if (i == 1) {   //递归头：控制什么时候结束调用自己
            System.out.println("1*1=1 ");
        } else {  //递归体：什么时候调用自己
            methodTest(i - 1);
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + j * i + "\t");
            }
            System.out.println();
        }
    }
}


叫我默语
目录
相关文章
nanshaws
|
1月前
论多段图的最短路径问题（我认为本质上还是暴力枚举法）
本文讨论了多段图最短路径问题的解决方法，认为本质上是使用暴力枚举法，通过逐步计算每个阶段点的最短距离来确定从起点到终点的最短路径。
nanshaws
36 1
论多段图的最短路径问题（我认为本质上还是暴力枚举法）
碳基肥宅
|
6月前
|
存储 算法
轮转数组问题：如何实现数组“整体逆序，内部有序”？“三步转换法”妙转数组（一）
这篇内容讲述了数组向右轮转k个位置的问题，主要分为两种解决思路。第一种是“轮转k次法”，直接在原数组上操作，每次循环k次，将数组末尾元素移到开头，时间复杂度为O(N*K)，效率较低。第二种是“额外数组法”，使用额外数组存储部分元素，然后移动原数组元素，最后归还额外数组元素，时间复杂度和空间复杂度均为O(N)。文章还介绍了更高效的“三步转换法”，通过三次逆序操作实现数组轮转，分别是逆置后k个元素、逆置前n-k个元素以及整体逆置，这种方法时间复杂度为O(N)且空间复杂度为O(1)。
碳基肥宅
73 1
碳基肥宅
|
6月前
|
C语言
轮转数组问题：如何实现数组“整体逆序，内部有序”？“三步转换法”妙转数组 （二）
这是一个关于字符串处理的问题，要求将一句话中的单词顺序倒置，但保持单词内部的字符顺序不变。例如，"I like beijing." 变为 "beijing. like I"。解决方法可以分为三个步骤：分块、内部逆序和整体逆序。代码示例使用C语言实现，通过指针和while循环操作字符串数组。最终总结提到，无论先逆置哪个部分，只要确保所有部分都逆置过，结果都是相同的。
碳基肥宅
52 0
HelloDam
射线法——判断一个点是否在多边形内部（适用于凸多边形和凹多边形）【关键原理解释+文字伪代码】
射线法——判断一个点是否在多边形内部（适用于凸多边形和凹多边形）【关键原理解释+文字伪代码】
HelloDam
689 0
天界程序员
|
前端开发 算法 JavaScript
【前端算法】将一个数组旋转K步
使用typescript完成将一个数组旋转K步的过程
天界程序员
105 0
月同学不写Bug
|
算法
数据结构与算法__01--单链表无顺序添加时，节点对象形成封闭环问题，无法添加同一个对象导致遍历输出时一直执行输出
单链表无顺序添加时，节点对象形成封闭环问题，无法添加同一个对象导致遍历输出时一直执行输出
月同学不写Bug
67 0
superlistboy
|
算法
判断三角形的性质（直角或等腰）简便算法
判断三角形的性质（直角或等腰）简便算法
superlistboy
134 0
胡哥有话说
|
存储 算法 前端开发
数组旋转，来来来，走个K步~
在前端算法面试中，数组是经常被问到的、使用到的。今天我们来看一道经典的前端基础面试题：【数组旋转K步】。
胡哥有话说
220 0
游客gsugatesykzaq
|
算法 Serverless 索引
二叉树的路径解析（任意两点/自顶向下）
二叉树的路径解析（任意两点/自顶向下）
游客gsugatesykzaq
246 0
二叉树的路径解析（任意两点/自顶向下）
一乐乐
|
人工智能 算法 图计算
算法之双指针（共同点：核心逻辑思路：即先找到比较小的区域（例如决定了存水量），然后在比较小的区域中找到一个最大值））~盛最多水的容器~~~接雨水
算法之双指针（共同点：核心逻辑思路：即先找到比较小的区域（例如决定了存水量），然后在比较小的区域中找到一个最大值））~盛最多水的容器~~~接雨水
一乐乐
155 0
算法之双指针（共同点：核心逻辑思路：即先找到比较小的区域（例如决定了存水量），然后在比较小的区域中找到一个最大值））~盛最多水的容器~~~接雨水