Json数组列表中的数据分组排序、组内排序

最新推荐文章于 2024-06-06 15:02:07 发布
最新推荐文章于 2024-06-06 15:02:07 发布
阅读量2.5k 收藏 6
点赞数 2
分类专栏： 算法 java基础知识 文章标签： json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011047968/article/details/104689433
版权

文章目录

问题描述

现在有一个用户信息数组，用户信息都在这个数组里，数组中有组号也有排序，现在需要将这些元素按照组号（groupNo）分组并排序，同时组内元素也按照排序字段（sortNum）排序？
示例json数组，分组排序之前

[{
	"userId": "7",
	"userName": "neo1",
	"groupNo": "3",
	"sortNum": "2"
},
{
	"userId": "11",
	"userName": "leo08",
	"groupNo": "3",
	"sortNum": "1"
},
{
	"userId": "15",
	"userName": "zhangsan",
	"groupNo": "3",
	"sortNum": "8"
},
{
	"userId": "1",
	"userName": "neo",
	"groupNo": "1",
	"sortNum": "2"
},
{
	"userId": "2",
	"userName": "leo",
	"groupNo": "1",
	"sortNum": "8"
},
{
	"userId": "3",
	"userName": "zhangsan",
	"groupNo": "1",
	"sortNum": "3"
},
{
	"userId": "4",
	"userName": "neo1",
	"groupNo": "2",
	"sortNum": "6"
},
{
	"userId": "2",
	"userName": "leo08",
	"groupNo": "2",
	"sortNum": "2"
},
{
	"userId": "3",
	"userName": "zhangsan1",
	"groupNo": "2",
	"sortNum": "8"
}]

分组排序之后：

[
    {
        "list":[
            {
                "sortNum":"2",
                "userName":"neo",
                "userId":"1",
                "groupNo":"1"
            },
            {
                "sortNum":"3",
                "userName":"zhangsan",
                "userId":"3",
                "groupNo":"1"
            },
            {
                "sortNum":"8",
                "userName":"leo",
                "userId":"2",
                "groupNo":"1"
            }
        ],
        "groupNo":"1"
    },
    {
        "list":[
            {
                "sortNum":"2",
                "userName":"leo08",
                "userId":"2",
                "groupNo":"2"
            },
            {
                "sortNum":"6",
                "userName":"neo1",
                "userId":"4",
                "groupNo":"2"
            },
            {
                "sortNum":"8",
                "userName":"zhangsan1",
                "userId":"3",
                "groupNo":"2"
            }
        ],
        "groupNo":"2"
    },
    {
        "list":[
            {
                "sortNum":"1",
                "userName":"leo08",
                "userId":"11",
                "groupNo":"3"
            },
            {
                "sortNum":"2",
                "userName":"neo1",
                "userId":"7",
                "groupNo":"3"
            },
            {
                "sortNum":"8",
                "userName":"zhangsan",
                "userId":"15",
                "groupNo":"3"
            }
        ],
        "groupNo":"3"
    }
]
方式一：先全部排序，在分组排序
    /**
     * 方式一：先全部排序，在分组排序
     *
     * @return
     */
    public static List<Map<String, Object>> sortByGroupNo1() {
        String jsonList = "[{\"userId\":\"7\",\"userName\":\"neo1\",\"groupNo\":\"3\",\"sortNum\":\"2\"},{\"userId\":\"11\",\"userName\":\"leo08\",\"groupNo\":\"3\",\"sortNum\":\"1\"},{\"userId\":\"15\",\"userName\":\"zhangsan\",\"groupNo\":\"3\",\"sortNum\":\"8\"},{\"userId\":\"1\",\"userName\":\"neo\",\"groupNo\":\"1\",\"sortNum\":\"2\"},{\"userId\":\"2\",\"userName\":\"leo\",\"groupNo\":\"1\",\"sortNum\":\"8\"},{\"userId\":\"3\",\"userName\":\"zhangsan\",\"groupNo\":\"1\",\"sortNum\":\"3\"},{\"userId\":\"4\",\"userName\":\"neo1\",\"groupNo\":\"2\",\"sortNum\":\"6\"},{\"userId\":\"2\",\"userName\":\"leo08\",\"groupNo\":\"2\",\"sortNum\":\"2\"},{\"userId\":\"3\",\"userName\":\"zhangsan1\",\"groupNo\":\"2\",\"sortNum\":\"8\"}]";
        List<Map<String, Object>> list = (List<Map<String, Object>>) JSON.parse(jsonList);
        List<String> groupNoList = new ArrayList<>();
        //使用比较器，先对分组进行排序
        list.sort(new Comparator<Map<String, Object>>() {
            @Override
            public int compare(Map<String, Object> o1, Map<String, Object> o2) {
                if (!groupNoList.contains(o1.get("groupNo").toString())) {
                    groupNoList.add(o1.get("groupNo").toString());
                }
                if (!groupNoList.contains(o2.get("groupNo").toString())) {
                    groupNoList.add(o1.get("groupNo").toString());
                }
                if (Integer.valueOf(o1.get("groupNo").toString()) > Integer.valueOf(o2.get("groupNo").toString())) {
                    return 1;
                } else if (Integer.valueOf(o1.get("groupNo").toString()) < Integer.valueOf(o2.get("groupNo").toString())) {
                    return -1;
                } else {
                    return 0;
                }
            }
        });

        //定义一个要返回的新的List
        List<Map<String, Object>> returnList = new ArrayList<>();

        //先对分组列表排序
        Collections.sort(groupNoList);

        //对分组进行排序
        for (String groupNo : groupNoList) {
            Map<String, Object> newMap = new HashMap<>();
            newMap.put("groupNo", groupNo);
            newMap.put("list", new ArrayList<Map<String, Object>>());
            for (Map<String, Object> tmp : list) {
                if (groupNo.equals(tmp.get("groupNo").toString())) {
                    List list1 = (List<Map<String, Object>>) newMap.get("list");
                    list1.add(tmp);
                }
            }
            List<Map<String, Object>> list2 = (List<Map<String, Object>>) newMap.get("list");
            list2.sort(new Comparator<Map<String, Object>>() {
                @Override
                public int compare(Map<String, Object> o1, Map<String, Object> o2) {
                    if (Integer.valueOf(o1.get("sortNum").toString()) > Integer.valueOf(o2.get("sortNum").toString())) {
                        return 1;
                    } else if (Integer.valueOf(o1.get("sortNum").toString()) < Integer.valueOf(o2.get("sortNum").toString())) {
                        return -1;
                    } else {
                        return 0;
                    }
                }
            });
            returnList.add(newMap);
        }
        return returnList;
    }

本来就写了上面一个方法，但是作为程序员，需要尽可能的提高性能，我接下来又提供了两种实现方式：

方式二：使用HashMap取出来分组再组内排序
    /**
     * 方式二:直接使用HashMap取出来所有分组，在进行分组排序，组内排序
     */
    public static List<Map<String, Object>> sortByGroupNo2() {
        String jsonList = "[{\"userId\":\"7\",\"userName\":\"neo1\",\"groupNo\":\"3\",\"sortNum\":\"2\"},{\"userId\":\"11\",\"userName\":\"leo08\",\"groupNo\":\"3\",\"sortNum\":\"1\"},{\"userId\":\"15\",\"userName\":\"zhangsan\",\"groupNo\":\"3\",\"sortNum\":\"8\"},{\"userId\":\"1\",\"userName\":\"neo\",\"groupNo\":\"1\",\"sortNum\":\"2\"},{\"userId\":\"2\",\"userName\":\"leo\",\"groupNo\":\"1\",\"sortNum\":\"8\"},{\"userId\":\"3\",\"userName\":\"zhangsan\",\"groupNo\":\"1\",\"sortNum\":\"3\"},{\"userId\":\"4\",\"userName\":\"neo1\",\"groupNo\":\"2\",\"sortNum\":\"6\"},{\"userId\":\"2\",\"userName\":\"leo08\",\"groupNo\":\"2\",\"sortNum\":\"2\"},{\"userId\":\"3\",\"userName\":\"zhangsan1\",\"groupNo\":\"2\",\"sortNum\":\"8\"}]";
        List<Map<String, Object>> list = (List<Map<String, Object>>) JSON.parse(jsonList);

        //定义一个要返回的新的List
        List<Map<String, Object>> returnList = new ArrayList<>();
        Iterator iterator = list.iterator();
        Map<String, ArrayList<Map<String, Object>>> hashMap = new HashMap<>();
        while (iterator.hasNext()) {
            Map<String, Object> tmp = (Map<String, Object>) iterator.next();
            String groupNo = tmp.get("groupNo").toString();
            if (hashMap.containsKey(groupNo)) {
                ArrayList<Map<String, Object>> list2 = hashMap.get(groupNo);
                list2.add(tmp);
            } else {
                hashMap.put(groupNo, new ArrayList<>());
                ArrayList<Map<String, Object>> list1 = hashMap.get(groupNo);
                list1.add(tmp);
            }
        }

        //取出来key进行排序
        List<String> keySet = new ArrayList<>(hashMap.keySet());
        Collections.sort(keySet);
        Iterator iterator1 = keySet.iterator();
        while (iterator1.hasNext()) {
            String groupNo = (String) iterator1.next();
            Map<String, Object> newMap = new HashMap<>();
            List<Map<String, Object>> list2 = hashMap.get(groupNo);
            Collections.sort(list2, (o1, o2) -> {
                if (Integer.valueOf(o1.get("sortNum").toString()) > Integer.valueOf(o2.get("sortNum").toString())) {
                    return 1;
                } else if (Integer.valueOf(o1.get("sortNum").toString()) < Integer.valueOf(o2.get("sortNum").toString())) {
                    return -1;
                } else {
                    return 0;
                }
            });
            newMap.put("groupNo", groupNo);
            newMap.put("list", list2);
            returnList.add(newMap);
        }
        return returnList;
    }
方式三：使用TreeMap取出来分组再组内排序
    /**
     * 方式三:使用TreeMap先分组排序，在组内排序
     */
    public static List<Map<String, Object>> sortByGroupNo3() {
        String jsonList = "[{\"userId\":\"7\",\"userName\":\"neo1\",\"groupNo\":\"3\",\"sortNum\":\"2\"},{\"userId\":\"11\",\"userName\":\"leo08\",\"groupNo\":\"3\",\"sortNum\":\"1\"},{\"userId\":\"15\",\"userName\":\"zhangsan\",\"groupNo\":\"3\",\"sortNum\":\"8\"},{\"userId\":\"1\",\"userName\":\"neo\",\"groupNo\":\"1\",\"sortNum\":\"2\"},{\"userId\":\"2\",\"userName\":\"leo\",\"groupNo\":\"1\",\"sortNum\":\"8\"},{\"userId\":\"3\",\"userName\":\"zhangsan\",\"groupNo\":\"1\",\"sortNum\":\"3\"},{\"userId\":\"4\",\"userName\":\"neo1\",\"groupNo\":\"2\",\"sortNum\":\"6\"},{\"userId\":\"2\",\"userName\":\"leo08\",\"groupNo\":\"2\",\"sortNum\":\"2\"},{\"userId\":\"3\",\"userName\":\"zhangsan1\",\"groupNo\":\"2\",\"sortNum\":\"8\"}]";
        List<Map<String, Object>> list = (List<Map<String, Object>>) JSON.parse(jsonList);

        //这里使用treeMap的自动排序机制，对groupNo进行排序
        TreeMap<String, ArrayList<Map<String, Object>>> treeMap = new TreeMap<>();
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Map<String, Object> tmp = (Map<String, Object>) iterator.next();
            String groupNo = tmp.get("groupNo").toString();
            if (treeMap.containsKey(groupNo)) {
                ArrayList<Map<String, Object>> list2 = treeMap.get(groupNo);
                list2.add(tmp);
                Collections.sort(list2, (o1, o2) -> {
                    if (Integer.valueOf(o1.get("sortNum").toString()) > Integer.valueOf(o2.get("sortNum").toString())) {
                        return 1;
                    } else if (Integer.valueOf(o1.get("sortNum").toString()) < Integer.valueOf(o2.get("sortNum").toString())) {
                        return -1;
                    } else {
                        return 0;
                    }
                });
            } else {
                treeMap.put(groupNo, new ArrayList<Map<String, Object>>());
                ArrayList<Map<String, Object>> list1 = treeMap.get(groupNo);
                list1.add(tmp);
            }
        }
        //定义一个要返回的新的List
        List<Map<String, Object>> returnList = new ArrayList<>();
        Iterator iter = treeMap.entrySet().iterator();
        while (iter.hasNext()) {
            Map<String, Object> newMap = new HashMap<>();
            Map.Entry<String, ArrayList<Map<String, Object>>> entry = (Map.Entry<String, ArrayList<Map<String, Object>>>) iter.next();
            String keyGroupNo = entry.getKey();
            newMap.put("groupNo", keyGroupNo);
            newMap.put("list", entry.getValue());
            returnList.add(newMap);
        }
        return returnList;
    }
测试代码及耗时
    /**
     * 花费时间测试
     */
    public static void costTime() {
        System.out.println("sortByGroupNo1排序结果：" + JSON.toJSONString(sortByGroupNo1()));
        System.out.println("sortByGroupNo2排序结果：" + JSON.toJSONString(sortByGroupNo2()));
        System.out.println("sortByGroupNo3排序结果：" + JSON.toJSONString(sortByGroupNo3()));

        int loopTimes = 100000;
        long startTime1 = System.currentTimeMillis();
        for (int i = 0; i < loopTimes; i++) {
            sortByGroupNo1();
        }
        System.out.println(loopTimes + "次循环，sortByGroupNo1耗时：" + (System.currentTimeMillis() - startTime1) + "ms");

        long startTime2 = System.currentTimeMillis();
        for (int i = 0; i < loopTimes; i++) {
            sortByGroupNo2();
        }
        System.out.println(loopTimes + "次循环，sortByGroupNo2耗时：" + (System.currentTimeMillis() - startTime2) + "ms");

        long startTime3 = System.currentTimeMillis();
        for (int i = 0; i < loopTimes; i++) {
            sortByGroupNo3();
        }
        System.out.println(loopTimes + "次循环，sortByGroupNo3耗时：" + (System.currentTimeMillis() - startTime3) + "ms");
    }

结果如下

sortByGroupNo1排序结果：[{"list":[{"sortNum":"2","userName":"neo","userId":"1","groupNo":"1"},{"sortNum":"3","userName":"zhangsan","userId":"3","groupNo":"1"},{"sortNum":"8","userName":"leo","userId":"2","groupNo":"1"}],"groupNo":"1"},{"list":[{"sortNum":"2","userName":"leo08","userId":"2","groupNo":"2"},{"sortNum":"6","userName":"neo1","userId":"4","groupNo":"2"},{"sortNum":"8","userName":"zhangsan1","userId":"3","groupNo":"2"}],"groupNo":"2"},{"list":[{"sortNum":"1","userName":"leo08","userId":"11","groupNo":"3"},{"sortNum":"2","userName":"neo1","userId":"7","groupNo":"3"},{"sortNum":"8","userName":"zhangsan","userId":"15","groupNo":"3"}],"groupNo":"3"}]
sortByGroupNo2排序结果：[{"list":[{"sortNum":"2","userName":"neo","userId":"1","groupNo":"1"},{"sortNum":"3","userName":"zhangsan","userId":"3","groupNo":"1"},{"sortNum":"8","userName":"leo","userId":"2","groupNo":"1"}],"groupNo":"1"},{"list":[{"sortNum":"2","userName":"leo08","userId":"2","groupNo":"2"},{"sortNum":"6","userName":"neo1","userId":"4","groupNo":"2"},{"sortNum":"8","userName":"zhangsan1","userId":"3","groupNo":"2"}],"groupNo":"2"},{"list":[{"sortNum":"1","userName":"leo08","userId":"11","groupNo":"3"},{"sortNum":"2","userName":"neo1","userId":"7","groupNo":"3"},{"sortNum":"8","userName":"zhangsan","userId":"15","groupNo":"3"}],"groupNo":"3"}]
sortByGroupNo3排序结果：[{"list":[{"sortNum":"2","userName":"neo","userId":"1","groupNo":"1"},{"sortNum":"3","userName":"zhangsan","userId":"3","groupNo":"1"},{"sortNum":"8","userName":"leo","userId":"2","groupNo":"1"}],"groupNo":"1"},{"list":[{"sortNum":"2","userName":"leo08","userId":"2","groupNo":"2"},{"sortNum":"6","userName":"neo1","userId":"4","groupNo":"2"},{"sortNum":"8","userName":"zhangsan1","userId":"3","groupNo":"2"}],"groupNo":"2"},{"list":[{"sortNum":"1","userName":"leo08","userId":"11","groupNo":"3"},{"sortNum":"2","userName":"neo1","userId":"7","groupNo":"3"},{"sortNum":"8","userName":"zhangsan","userId":"15","groupNo":"3"}],"groupNo":"3"}]
100000次循环，sortByGroupNo1耗时：3433ms
100000次循环，sortByGroupNo2耗时：1338ms
100000次循环，sortByGroupNo3耗时：992ms
leo825...
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
JSON排序问题
ankangcool的专栏
04-05 790
最近在处理VOD网络应用的时候，碰到一个按id排序显示的需求，跟大家分享下，此代码片段通过VS2008调试完成。 1、JSON str排序前后打印。 2、基本的处理思路如下。 (1)构建一个json input str； (2)申请结构体资源，解析并存储； (3)针对此结构体数据做排序； (4)用排序后的结构体数据填充，并构造新的json output str； (5)释放结构体...
json对象的排序的方法
milijiangjun的博客
08-21 8629
例： 1.不传参数，将不会按照数值大小排序，按照字符编码的顺序进行排序； var arr = ['General','Tom','Bob','John','Army']; var resArr = arr.sort(); console.log(resArr);//输出 ["Army", "Bob", "General", "John", "Tom"] var arr2 = [30,10,111,35,1899,50,45]; var resArr2 = arr2.sort(); con
js对json数组进行排序
heromps的博客
03-29 6353
js中有一个sort()方法，可以直接通过arr.sort()进行排序，默认只能对数组的值进行排序，然而有一些数组数据却是json格式的，需要对其进行排序，则需要重新写相关方法 sort()方法定义 sort()方法用于对数组元素进行排序 语法：arrayObject.sort(sortby) 参数描述：sortby可选。规定排序顺序即规则，必须是函数 返回值：对数组的引用。数组会在原数组上进行排序，不生成副本。 注意： 如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序，说得更精确点，
Java JSON字符串内容排序与格式化工具类
最新发布
Mr_Hellon的博客
06-06 525
【代码】Java JSON字符串内容排序与格式化工具类。
json数组排序_JavaScript中对于JSON数组的两种排序方式
weixin_31473011的博客
01-14 1631
我们实际项目中会遇到后端接口返回的数据排列顺序不是我们界面想要的，所以我们需要进行排序，我这里整理了两种排序方式，供大家参考，希望大家提出更好的建议。// 比如我们有这么一条数据const data = [ { name: '张三', age: 10 }, { name: '李四', age: 30 }, { name: '王五', age: 20 }];方法一： 按首字母【A-...
json 数组排序
weixin_45427064的博客
11-11 805
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
JS 中 Json 数据的快速排序
Baimoc
12-02 6491
主角为 `sort(sortby)` 参数 `sortby` 是一个比较函数，该函数要比较两个值（a，b），返回值用来描述两个值的大小，具体规则为： - a < b，返回负值，排序后， a 在 b 之前 - a = b，返回 0 - a > b，返回正值，排序后， a 在 b 之后
json数组根据数组中对象某个属性排序
Kuroro_Lucifer的博客
12-03 441
if(DataUtil.isJsonArray(tidByVisitoid)) { Map<String, String> map = new HashMap<>(); JSONArray jArray = JSONArray.fromObject(tidByVisitoid); if(jArray.length()>0) { JSONArra...
JS实现中文汉字按拼音排序的方法
11-29
在JavaScript中，对中文汉字进行拼音排序是一种常见的需求，特别是在处理中文数据时。本文将详细介绍两种JS实现中文汉字按拼音排序的方法。 首先，我们来看第一种方法，即基础的拼音排序。这个方法利用了JavaScript...
JAVA JDK8 List分组获取第一个元素的方法
08-26
在这个例子中，我们使用了Collectors.collectingAndThen方法来对组内的元素进行处理，该方法将Collectors.toList()方法的结果作为输入，然后将其转换为一个 Coupon 对象。Collectors.toList()方法将List对象转换为一...
将数组或数据列表转换为字符串=>变得容易！ （C＃，MVC3，LINQ）
04-07
在处理数组或列表时，LINQ提供了丰富的查询操作，如筛选、排序、分组等。 在本示例中，我们将讨论如何使用LINQ的Select方法来转换数组或列表。Select方法允许我们对源序列中的每个元素应用一个函数，生成新的序列。...
JSON查询语言 Jaql
06-06
6. **数据转换**：Jaql允许用户定义函数来转换数据，比如通过`map`函数将数组中的每个元素应用一个函数，或使用`reduce`对数组进行累积运算。 7. **连接操作**：Jaql的`join`操作允许合并两个JSON数据源，类似于SQL...
jql：JSON查询语言CLI工具
01-30
1. **查询操作**：`jql` 支持类似于SQL的查询语法，例如，`SELECT` 用于选取JSON对象中的字段，`WHERE` 用于指定条件，`GROUP BY` 和`ORDER BY` 分别用于分组和排序结果。 2. **过滤器**：通过表达式或函数对JSON...
JSONArray操作汇总,排序,筛选,分组
当作记事本用
02-20 6897
【代码】JSONArray操作汇总,排序,筛选,分组。
【json数组排序】json数组按照某个字段升序降序（已实现，附完整代码）
赏樱看雪撸代码
07-04 1698
sort函数应用，数组排序，数组升序，数组降序，数组按字段升序，数组按字段降序，复杂数组排序处理，父子结构数组按照某字段排序，树状数组排序处理。
对已有的json重新排序
qq_29539827的博客
04-27 1254
JSONObject的底层是Map结构， 默认是 HashMap，也可以改成LinkedHashMap，二者在顺序上有些差别。改成LinkedHashMap的方法是。接口做签名时，拼接明文字符串时候，大部分人约定入参需要按字母顺序进行排序，所以写了json重新排序的方法。其中心思想还是用json自带的转字符串并排序。但是如果是LinkedHashMap类型的，则上述的工具类则会失效不起作用。，最后再转回json。
JSON数据进行groupby分组
Dexter's Laboratory
10-25 4335
JSON数据 [ { "name": "24-tiankong", "value": "填空回答内容1" }, { "name": "19-tiankong", "value": "填空回答内容2" }, { "name": "7-duoxuan", "value": "A" }, { "name": "7-duo...
js运用sort对json 数组进行排序
热门推荐
董庆贺的专栏
10-09 1万+
Array.sort()方法是用来对数组项进行排序的 ，默认情况下是进行升序排列。sort() 方法可以接受一个 方法为参数。sort()排序时每次比较两个数组项都回执行这个参数，并把两个比较的数组项作为参数传递给这个函数。当函数返回值为1的时候就交换两个数组项的顺序，否则就不交换。var p = [5, 2, 3, 1, 7, 5, 6, 9, 6, 0]; function
JSON数据某个字段进行排序
进阶的Typist的博客
12-03 770
对JSON数据某个字段进行排序 原文链接
JSON_ARRAYAGG和group by组合
12-06
在MySQL 8.0版本中，JSON_ARRAYAGG函数可以与GROUP BY子句一起使用，以便根据分组条件将结果聚合成JSON数组。例如： ```sql SELECT department, JSON_ARRAYAGG(employee_name) FROM employees GROUP BY department;...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

leo825...

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值