Java 比较法违反了它的总合同，因为它提供了一个基于地图的比较器

我一直在努力解决这个问题：下面的代码实现了一个基于映射的比较器。贴图映射类型与整数值相当的对象。给定两个可比较的对象，比较器比较地图中这些对象的值。如果任何对象不在映射的键集中，则比较器返回0

所以比较器应该是传递的和反身的。然而，当我运行下面的测试用例对整数向量进行排序时，我得到以下错误：

java.lang.IllegalArgumentException: Comparison method violates its general contract!
at java.util.TimSort.mergeHi(TimSort.java:868)
at java.util.TimSort.mergeAt(TimSort.java:485)
at java.util.TimSort.mergeCollapse(TimSort.java:410)
at java.util.TimSort.sort(TimSort.java:214)
at java.util.TimSort.sort(TimSort.java:173)
at java.util.Arrays.sort(Arrays.java:659)
at java.util.Collections.sort(Collections.java:217) 
    at IndexComparatorTest.testSort(IndexComparatorTest.java:45)

我试图通过从列表中排除一些元素和从hashmap中删除一些元素来进一步减少这个问题，但是删除任何元素都会使问题消失。我也开始研究Timsort.java，但这有点难以理解

有什么想法吗

import org.junit.Test;

import java.util.*;

class MyComparator<N extends Comparable<N>> implements Comparator<N> {

    private final Map<N, Integer> node2index;

    public MyComparator(Map<N, Integer> node2Index) {
        this.node2index = node2Index;
    }

    @Override
    public int compare(N o1, N o2) {
        if (! node2index.containsKey(o1)) return 0;
        if (! node2index.containsKey(o2)) return 0;
        int result = Integer.compare(node2index.get(o1), node2index.get(o2));
        return result;
    }
}

public class IndexComparatorTest {

    @Test
    public void testSort() {
        Vector<Integer> toBeSorted = new Vector<>(Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31));
        HashMap<Integer, Integer> hashMap = new HashMap<>();
        hashMap.put(0, 5);
        hashMap.put(14, 6);
        hashMap.put(15, -2);
        hashMap.put(16, 4);
        hashMap.put(17, 1);
        hashMap.put(18, 8);
        hashMap.put(19, -12);
        hashMap.put(21, -3);
        hashMap.put(22, -13);
        hashMap.put(24, -19);
        hashMap.put(25, 2);
        hashMap.put(27, 7);
        hashMap.put(28, -6);
        hashMap.put(31, 0);
        hashMap.put(30, -4);
        Collections.sort(toBeSorted, new MyComparator<>(hashMap));
    }

}

import org.junit.Test；
导入java.util.*；
类MyComparator实现比较器{
私有最终映射节点2索引；
公共MyCompariator（映射节点2索引）{
this.node2index=node2index；
}
@凌驾
公共整数比较（nO1，nO2）{
如果（！node2index.containsKey（o1））返回0；
如果（！node2index.containsKey（o2））返回0；
int result=Integer.compare（node2index.get（o1），node2index.get（o2））；
返回结果；
}
}
公共类索引比较测试{
@试验
公共void testSort（）{
Vector toBeSorted=新向量（数组.asList（0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31））；
HashMap HashMap=新的HashMap（）；
hashMap.put（0,5）；
hashMap.put（14,6）；
hashMap.put（15，-2）；
hashMap.put（16,4）；
hashMap.put（17,1）；
hashMap.put（18,8）；
hashMap.put（19，-12）；
hashMap.put（21，-3）；
hashMap.put（22，-13）；
hashMap.put（24，-19）；
hashMap.put（25,2）；
hashMap.put（27,7）；
hashMap.put（28，-6）；
hashMap.put（31,0）；
hashMap.put（30，-4）；
排序（toBeSorted，新的MyComparator（hashMap））；
}
}

您发现，此比较器违反了其约定。例如，它告诉您

0=1，1=14，0这可能是一个暂时的问题，因为默认的排序算法使用TimSort代替MergeSort

尝试解决方法将JVM参数添加为：
-Djava.util.Arrays.useLegacyMergeSort=true

此命令将强制JVM使用传统的MergeSort排序算法。
可能重复我想我现在知道问题出在哪里了。如果第一个或第二个元素不在映射中，它应该是-1和+1，而不是0和0。这似乎确实是个问题。但也要注意，如果两个元素都不在映射中，则应返回0，否则会破坏对称性。好的，这修复了它。谢谢
@Override
public int compare(N o1, N o2) {
    if (!node2index.containsKey(o1) && !node2index.containsKey(o2)) return 0;
    if (!node2index.containsKey(o1)) return -1;
    if (!node2index.containsKey(o2)) return +1;
    int result = Integer.compare(node2index.get(o1), node2index.get(o2));
    return result;
}