java比较方法违反了它的一般约定

Question

使用自定义比较器执行< code > Collection.sort using >时，我得到一个< code > Java . lang . illegalargumentexception:Comparison方法违反了它的一般约定

我理解这是一个问题，因为该方法是不可传递的。在我的比较器中，调用了多个方法，我确定了违反此规则的代码段。然而，我无法修复它，也看不到它的问题。

private int compareInstancesBelowChangeNumberStructureElements(ISapInstance pInstance1,
ISapInstance pInstance2) {
// Sort algorithm below change number structure elements
    String[] tokens1 =     pInstance1.getName().asString().split(COMPOUND_NAME_DELIMITER_REGEX);
    String[] tokens2 =      pInstance2.getName().asString().split(COMPOUND_NAME_DELIMITER_REGEX);

    if ((tokens1 == null) || (tokens2 == null)) {
      return 0;
    }

     int minLength = tokens1.length;
     if (tokens2.length < minLength) {
      minLength = tokens2.length;
     }

    if (minLength < 3) {
      return 0;
    }

// Compare criterion 1: node name or assembly group name
int compareValue = tokens1[2].compareTo(tokens2[2]);
if ((compareValue == 0) && (minLength >= 4)) {
  // Compare criterion 2: class name
  compareValue = tokens1[3].compareTo(tokens2[3]);
  if (compareValue == 0) {
    // Compare criterion 3: pos var name or assembly position name
    compareValue = tokens1[1].compareTo(tokens2[1]);
    if (compareValue == 0) {
      // Compare criterion 4: instance name
      compareValue = tokens1[0].compareTo(tokens2[0]);
    }
  }
}
return compareValue;
  }

Answer 1

似乎是长度检查导致了这个问题，如果您正在检查长度以避免< code > arrayindexoutofboundsexception 。还有一种不涉及长度检查的方法。

static class Tokens implements Comparable<Tokens> {
    private static final int N = 4;
    // Order in which we would like to compare the tokens.
    private static final int [] TOKEN_POS = {2, 3, 1, 0};

    // Reordered tokens
    private final String [] tokens = new String[N];

    // The comparator used to compare each token
    private final Comparator<String> cmp = Comparator.nullsFirst(String::compareTo);

    Tokens(String []tokens) {
        int i = 0;
        for (int p : TOKEN_POS) {
            // Place token to it's *correct* position
            // put null if tokens does not have enough elements
            this.tokens[i++] = p < tokens.length ? tokens[p] : null;
        }
    }

    @Override
    public int compareTo(Tokens o) {
        for (int i = 0; i < N; i++) {
            int c = cmp.compare(tokens[i], o.tokens[i]);
            if (c != 0) return c;
        }
        return 0;
    }

    @Override
    public String toString() {
        return "Tokens{" +
                "tokens=" + Arrays.toString(tokens) +
                '}';
    }
}

private static Tokens getCompareKey(String [] tokens) {
    return new Tokens(tokens);
}

private static void compareAndPrint(Tokens k1, Tokens k2) {
    System.out.println(k1 + " cmp " + k2 + " = " + k1.compareTo(k2));
}

public static void main(String [] args) {
    Tokens key1 = getCompareKey(new String[]{"1", "2", "3"});
    Tokens key2 = getCompareKey(new String[]{"1", "2", "3", "5"});
    Tokens key3 = getCompareKey(new String[]{"1", "3"});
    compareAndPrint(key2, key1);
    compareAndPrint(key1, key3);
    compareAndPrint(key2, key3);
}

输出

Tokens{key=[3, 5, 2, 1]} cmp Tokens{key=[3, null, 2, 1]} = 1
Tokens{key=[3, null, 2, 1]} cmp Tokens{key=[null, null, 3, 1]} = 1
Tokens{key=[3, 5, 2, 1]} cmp Tokens{key=[null, null, 3, 1]} = 1

很明显，这种方式的排序是可传递的。然而，它确实将令牌与最后一个令牌进行比较。您可以决定它是否适合您的应用程序。

Answer 2

想象一下ISapInance有下一个令牌数量的情况。

a -> 4
b -> 2
c -> 4

它导致a=b和b=c（因为minL的长度是2），所以a必须等于c，但如果我们直接比较a和c，则不一定为真。

Answer 3

如果 ISapInstance.getName（） 的令牌少于三个，则比较方法违反了传递性要求。

假设您有三个ISapInstance实例：

< li >名称包含三个标记元素的-- < li>b -具有包含两个标记元素的名称 < Li > c --其名称具有三个标记元素，并且其< code >标记[2]值不同于的值

现在，如果使用a和b或者使用b和c来调用比较方法，那么比较方法将为两个调用返回

为了满足传递性规则，如果使用a和c调用比较方法，则比较方法还必须返回 。但是，由于两者的名称都有两个以上的标记，并且 标记[2]的值不同，因此如果按照所述的方式准备，它将返回与 0不同的内容。

这三种情况会出现相同的问题:

（所有实例的令牌值相同[2]）

• a-具有四个标记元素的名称
• b-具有三个标记元素的名称
• c-具有四个标记元素的名称，其标记[3]值与

要解决这个问题，如果只有一个实例的标记少于三个，或者第三个标记相同，而只有一个实例正好有三个标记，那么比较器不能返回< code>0。

例如：

private int compareInstancesBelowChangeNumberStructureElements(ISapInstance pInstance1,
            ISapInstance pInstance2) {
    // Sort algorithm below change number structure elements
    String[] tokens1 =     pInstance1.getName().asString().split(COMPOUND_NAME_DELIMITER_REGEX);
    String[] tokens2 =      pInstance2.getName().asString().split(COMPOUND_NAME_DELIMITER_REGEX);

    if (tokens1.length < 3) {
        return (tokens2.length < 3) ? 0 : -1;
    } else if (tokens2.length < 3) {
        return 1;
    }
    int minLength = tokens1.length;
    if (tokens2.length < minLength) {
        minLength = tokens2.length;
    }

    // Compare criterion 1: node name or assembly group name
    int compareValue = tokens1[2].compareTo(tokens2[2]);
    if (compareValue == 0) {
        if (tokens1.length < 4) {
            return (token2.length < 4) ? -1 : 0;
        } else if (tokens2.length < 4) {
            return 1;
        } else {
            // ... the remaining comparison operations
        }
    }
    return compareValue;
}