java jdk8 list排序（项目实测）

首先声明，排序的方法是通用的，但是这个方法是很有针对性的，如果想要用，必须要自己改装；
首先是最简单的Integer类型和String类型的排序（这个是通用的）

 /**
     * 字符串类型list排序
     * author byH
     * data 2021/2/1
     * @param list 需要排序的list
     */
    public static void listStringSorted(List<String> list){
          list.sort(String::compareTo);
    }

    /**
     * int类型list排序
     * author byH
     * data 2021/2/1
     * @param list 需要排序的list
     */
    public static void listIntegerSorted(List<Integer> list){
        list.sort(Integer::compareTo);
    }

然后是稍微复杂一点点的，list里面包含了一个Integer或者String类型的list（基本算是通用的）

/**
     * list包含int类型list的list排序
     * author byH
     * data 2021/2/1
     * @param list 需要排序的list
     * @param subscript 下标
     */
    public static void listListIntegerSorted(List<List<Integer>> list,int subscript){
        list.sort(Comparator.comparing(a -> a.get(subscript)));
    }

    /**
     * list包含字符串类型list的list排序
     * author byH
     * data 2021/2/1
     * @param list 需要排序的list
     * @param subscript 下标
     */
    public static void listListStringSorted(List<List<String>> list,int subscript){
        list.sort(Comparator.comparing(a -> Integer.parseInt(a.get(subscript))));
    }

然后是最最复杂的，也是不通用的，可以借鉴改装，就是像这种类型：
[[1, [0, 2, 3, 4]], [7, [2, 2, 3, 4]], [9, [5, 2, 3, 4]], [7, [8, 2, 3, 4]], [9, [9, 2, 3, 4]]]
就是list里面包含了一个list，包含的list里面又包含了一个list，
我现在要做的是按照最里面的list的第一个字符进行排序

        //生成测试list
        List<Object> list = new ArrayList<>();
        for(int i = 0 ; i < 5; i ++){
            List<Object> list2 = new ArrayList<>();
            List<String> list3 = new ArrayList<>();
            list2.add(String.valueOf((int) (Math.random() * 10)));
            list3.add(String.valueOf((int) (Math.random() * 10)));
            list3.add("2");
            list3.add("3");
            list3.add("4");
            list2.add(list3);
            list.add(list2);
        }
        System.out.println("排序前："+list.toString());
        //用匿名内部类的方式排序
        Collections.sort(list, (o1, o2) -> {
            //获取第一层list
            List<Object> list1 = (List<Object>) o1;
            List<Object> list2 = (List<Object>) o2;
            //获取最里层list
            List<String> integerList1 = (List<String>) list1.get(1);
            List<String> integerList2 = (List<String>) list2.get(1);
            return Integer.parseInt(integerList1.get(0)) - Integer.parseInt(integerList2.get(0));
        });
        System.out.println("排序后："+list.toString());

结果：

排序前：[[3, [6, 2, 3, 4]], [5, [0, 2, 3, 4]], [3, [8, 2, 3, 4]], [7, [3, 2, 3, 4]], [4, [6, 2, 3, 4]]]
排序后：[[5, [0, 2, 3, 4]], [7, [3, 2, 3, 4]], [3, [6, 2, 3, 4]], [4, [6, 2, 3, 4]], [3, [8, 2, 3, 4]]]

当然了，如果你想按照第二层的list排序，只要获取第二层的第一个数据就可以了；

 //生成测试list
        List<Object> list = new ArrayList<>();
        for(int i = 0 ; i < 5; i ++){
            List<Object> list2 = new ArrayList<>();
            List<String> list3 = new ArrayList<>();
            list2.add(String.valueOf((int) (Math.random() * 10)));
            list3.add(String.valueOf((int) (Math.random() * 10)));
            list3.add("2");
            list3.add("3");
            list3.add("4");
            list2.add(list3);
            list.add(list2);
        }
        System.out.println("排序前："+list.toString());
        //用匿名内部类的方式排序
        Collections.sort(list, (o1, o2) -> {
            //获取第一层list
            List<Object> list1 = (List<Object>) o1;
            List<Object> list2 = (List<Object>) o2;
            return Integer.parseInt(String.valueOf(list1.get(0))) - Integer.parseInt(String.valueOf(list2.get(0)));
        });
        System.out.println("排序后："+list.toString());