Java 比较器是否在内部使用堆

在对数组排序时，我试图理解比较器处理的元素的顺序

它是否继续随机选择任意两个索引，并使数组按排序顺序保持一致，并在匹配所有可能的索引对后继续这样做，这是我一直在思考的问题。或者索引是否依赖于

数组使用的内部排序算法。sort

使用，这些是我正在考虑的事情

另外，比较器是否在内部使用堆，因为在我看来，在输出的某个点上，比如说，数组看起来像这样

4 3 1 2 5 

在对元素

2,1

进行比较时，数组突然看起来如下所示，这意味着它不仅是刚刚比较的值2和1之间的交换，而且还影响了数组中的其他元素。这是通过使用堆实现的吗

1 3 4 2 5 

我试着按如下方式打印索引

public class HowComparatorsWork {
    public static void main(String[] args) {
        HowComparatorsWork obj = new HowComparatorsWork();

        obj.understandHowComparatorsWork();
    }

    public void understandHowComparatorsWork()
    {
        Integer[] a = {4,3,1,2,5};

        Arrays.sort(a, new Comparator<Integer>()
            {
                @Override
                public int compare(Integer a1, Integer a2)
                {
                    print(a);

                    System.out.println("");
                    System.out.println(a1 + "," + a2);
                    return a1 - a2;
                }
            });
        print(a);
    }

    public void print(Integer[] a)
    {
        for(int i = 0;i<a.length;i++)
            System.out.print(a[i] + " ");
        System.out.println("");
    }
}

4 3 1 2 5 

3,4
4 3 1 2 5 

1,3
4 3 1 2 5 

2,1
1 3 4 2 5 

2,3
1 3 4 2 5 

2,1
1 2 3 4 5 

5,3
1 2 3 4 5 

5,4
1 2 3 4 5

编辑：我觉得，这不仅仅是排序，而是使用比较器以任何顺序“安排”排序。例如，我可以使用比较方法将所有偶数排列（排序？）在奇数之前。即使在这种情况下，Java是否处理 与TimSort的顺序相同，因为我们使用的是array.sort

public void evenOddComparator()
    {
        Integer[] a = {4,3,1,2,5,6,8,9,7,10};

        Arrays.sort(a, new Comparator<Integer>()
            {
                final int BEFORE = -1;
                final int EQUAL = 0;
                final int AFTER = 1;

                @Override
                public int compare(Integer o1, Integer o2) {
                    if (o1 % 2 == 0 && o2 % 2 != 0) {
                        return BEFORE;
                    } else if (o1 % 2 != 0 && o2 % 2 == 0) {
                        return AFTER;
                    } else if (o1 % 2 == 0 && o2 % 2 == 0) {
                        return o1.compareTo(o2);
                    } else if (o1 % 2 != 0 && o2 % 2 != 0) {
                        return o2.compareTo(o1);
                    }
                    return EQUAL;
                }
            });
        print(a);   
    }

public比较程序（）
{
整数[]a={4,3,1,2,5,6,8,9,7,10}；
sort（一个新的比较器（）
{
之前的最终整数=-1；
最终整数等于0；
之后的最终整数=1；
@凌驾
公共整数比较（整数o1，整数o2）{
如果（o1%2==0&&o2%2！=0）{
提前返回；
}否则如果（o1%2！=0&&o2%2==0）{
返回后；
}否则如果（o1%2==0&&o2%2==0）{
返回o1。与（o2）相比；
}否则如果（o1%2！=0&&o2%2！=0）{
返回o2.compareTo（o1）；
}
回报相等；
}
});
印刷品（a）；
}

这是否意味着，与自定义比较器一起使用的Arrays.sort可用于按照compare（）方法逻辑定义的任何顺序排列元素，但处理的元素顺序将始终与TimSort相同，因为我们使用的是Arrays.sort

public void evenOddComparator()
    {
        Integer[] a = {4,3,1,2,5,6,8,9,7,10};

        Arrays.sort(a, new Comparator<Integer>()
            {
                final int BEFORE = -1;
                final int EQUAL = 0;
                final int AFTER = 1;

                @Override
                public int compare(Integer o1, Integer o2) {
                    if (o1 % 2 == 0 && o2 % 2 != 0) {
                        return BEFORE;
                    } else if (o1 % 2 != 0 && o2 % 2 == 0) {
                        return AFTER;
                    } else if (o1 % 2 == 0 && o2 % 2 == 0) {
                        return o1.compareTo(o2);
                    } else if (o1 % 2 != 0 && o2 % 2 != 0) {
                        return o2.compareTo(o1);
                    }
                    return EQUAL;
                }
            });
        print(a);   
    }

---

请澄清

处理元素顺序的不是

比较器

。

comparator

只是比较两个元素。您可能想知道

数组的
排序
-方法是如何工作的？排序期间元素提交给
比较器
的顺序由
比较器
的用户（实现排序算法的某个对象）控制，而不是由
比较器
本身控制。类似地，典型的
Comparator
实现不使用堆，但在整个排序中可能涉及堆。通常，
Comparator
s什么也不做，只回答对象对如何相互比较的问题，根据需要多次比较对象对。
Arrays.sort
对象（
Integer
wrappers）上的sort默认使用Java 8中名为ComparableTimSort的TimSort变体（看起来在以前的版本中使用了MergeSort）。你可以查看源代码来推断精确的算法。这个问题非常离奇，如果你只是好奇，或者你认为你需要知道比较的顺序才能解决一些更大的问题，那么我必须问你。但是你的比较器与TimSort的逻辑无关。正如前面的评论所说，比较器所做的只是比较项目并返回比较结果。操作顺序完全由调用比较器的对象定义。如果您有调用比较器的逻辑，以便可以将偶数排在奇数之前，则TimSort不起作用。尽管您可以使用TimSort和比较器来执行该任务，但您不必这样做。