Java递归分类排序——通过重写Sort（）中的Comparator实现自定义的复杂List或Map等的自定义排序规则

正文：

当我们在编程，特别是偏向底层或者涉及到排序或比较的功能的时候，就会经常遇到sort方法，它能满足一帮的排序或者简单的List排序

但是当遇见复查的类型，例如List>，像这种类型，如果想取其中的一个Key作为判断和排序的时候，我们就需要学会重写Sort（）中的Comparato来实现我们的需求（这种方法能很快解决嵌套排序或者分层、树级的排序），示例如下：

//递归排序   
private static void ReWriteSort(List> obj) {
        if (obj == null) return;//判空
        obj.sort(new Comparator>() {
            @Override // 重写，从小到大排序
            public int compare(Map o1, Map o2) {
                Long num1 = Long.parseLong(o1.get("序号").toString());
                Long num2 = Long.parseLong(o2.get("序号").toString());
                Long diff = num1 - num2;//通过两者的差来决定先后顺序
                if (diff < 0) {
                    return -1;
                } else if (diff > 0) {
                    return 1;
                }
                return 0;
            }
        });
        for (Map item : obj) {
           ReWriteSort((List>) item.get("子层"));
        }
    }

示例用到的是递归重写的方法，而且能实现对不同层级进行分类排序，供参考和以及讨论

背景学习：

常见的Sort（）方法有两种，一种是Arrays.sort，另一种是Collections.sort；

两者的特点是，Collection.sort的底层使用的是Arrays.sort的方法，如下：

@SuppressWarnings("unchecked") 
public static > void sort(List list) { 
    list.sort(null); 
}

//深入List的sort展开

@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparator c) { 
    Object[] a = this.toArray(); 
    Arrays.sort(a, (Comparator) c);
    ListIterator i = this.listIterator(); 
    for (Object e : a) { 
        i.next();
        i.set((E) e); 
    } 
}

深入展开List.sort不难看出，最终是调用了Arrays.sort进行排序，最后再进行集合起来。

而我们有常听见jdk7和jdk8的Arrays.sort又有区别，现在来看看源码：

jdk7：

//jdk7
public static void sort(Object[] a) { 
    if (LegacyMergeSort.userRequested)
    legacyMergeSort(a); 
    else ComparableTimSort.sort(a); 
}

jdk8:

//jdk8
public static  void sort(T[] a, Comparator c) { 
    if (c == null){ 
        sort(a); 
    } else { 
        if (LegacyMergeSort.userRequested)
             legacyMergeSort(a, c);
        else 
             TimSort.sort(a, 0, a.length, c, null, 0, 0); 
    } 
}

可以看出，jdk7调用的是 ComparableTimSort.sort(a);  而jdk8调用的是TimSort.sort（）； 根据查询的知识，ComparableTimSort不使用自定义比较器，而.TimSort.sort需要传入比较器；两者都是采用了混合排序，不会单独采用归并排序。

【背景学习的知识由网上学习资料学习总结，在此感谢https://www.toolsou.com/article/200539808】