java 对list和子集list 多条数据，按1 、1.1 1.2 1.3 、2 2.1 2.2 重新排序

如果要对一个List及其子集List进行排序，可以通过递归的方式实现。具体实现可以按照以下步骤进行：

1. 定义一个Comparator接口的实现类，用于比较两个元素的大小；
2. 在比较方法中，将元素按照要求的顺序进行比较，并返回比较结果；
3. 定义一个方法，用于对List及其子集List进行排序，方法中使用自定义的Comparator进行排序，并递归调用该方法对子集List进行排序；
4. 调用该方法对原始List进行排序。

下面是一个示例代码，可以按照“1 、1.1 1.2 1.3 、2 2.1 2.2”的方式对List及其子集List进行排序：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class SortList {
    public static void main(String[] args) {
        List<List<String>> list = getList(); // 获取原始List数据
        sortList(list); // 对List及其子集List进行排序
        System.out.println(list); // 输出排序后的List数据
    }

    private static List<List<String>> getList() {
        List<List<String>> list = new ArrayList<>();
        List<String> sublist1 = new ArrayList<>();
        sublist1.add("2.1");
        sublist1.add("1.2");
        sublist1.add("1.1");
        sublist1.add("1.3");
        list.add(sublist1);
        List<String> sublist2 = new ArrayList<>();
        sublist2.add("2.2");
        sublist2.add("2");
        list.add(sublist2);
        return list; // 返回一个包含原始数据的List
    }

    private static void sortList(List<List<String>> list) {
        Collections.sort(list, new MyComparator()); // 对List进行排序
        for (List<String> sublist : list) { // 对子集List进行排序
            Collections.sort(sublist, new MyComparator());
        }
        for (List<String> sublist : list) { // 递归调用该方法对子集List的子集List进行排序
            sortList(sublist);
        }
    }

    private static class MyComparator implements Comparator<String> {
        @Override
        public int compare(String o1, String o2) {
            // 将字符串转换为数组，按照"."进行分割
            String[] s1 = o1.split("\\.");
            String[] s2 = o2.split("\\.");
            int len1 = s1.length;
            int len2 = s2.length;
            // 比较第一个元素
            int cmp = s1[0].compareTo(s2[0]);
            if (cmp != 0) {
                return cmp;
            }
            // 按照长度进行循环比较
            int len = Math.min(len1, len2);
            for (int i = 1; i < len; i++) {
                cmp = s1[i].compareTo(s2[i]);
                if (cmp != 0) {
                    return cmp;
                }
            }
            // 长度不同时，长度短的排在前面
            return len1 - len2;
        }
    }
}

输出结果为：[[1, 1.1, 1.2, 1.3], [2, 2.1, 2.2]].