blocks|key|501183|text|您不能像这样比较对象数据：s1.getParent()+==+s2-这将比较对象引用。您应该覆盖Foo类的equals+function，然后像这样比较它们的s1.getParent().equals(s2)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|501184|entityMap^0|D|K|1H|F|27|P|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

You can't compare object data like this:<code>s1.getParent() == s2</code> - this will compare the object references. You should override <code>equals function</code> for Foo class and then compare them like this <code>s1.getParent().equals(s2)</code>

blocks|key|716745|text|只是因为这是我在谷歌上搜索这个错误时得到的，我的问题是我有|type|unstyled|depth|inlineStyleRanges|entityRanges|data|716746|if+(value+<+other.value)
++return+-1;
else+if+(value+>=+other.value)
++return+1;
else
++return+0;|code-block|syntax|javascript|716747|value+>=+other.value应该(显然)实际上是value+>+other.value，这样你就可以用相等的对象实际返回0。|offset|length|style|CODE|716748|entityMap^0|0|0|0|K|U|J|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Just because this is what I got when I Googled this error, my problem was that I had 

<pre><code>if (value &lt; other.value)
 return -1;
else if (value &gt;= other.value)
 return 1;
else
 return 0;
</code></pre>

the <code>value &gt;= other.value</code> should (obviously) actually be <code>value &gt; other.value</code> so that you can actually return 0 with equal objects.

blocks|key|501305|text|我在一段代码中看到过这种情况，其中经常重复检查null值：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|501306|if((+A==null+)+&&+(+B==null+)
++return+%2B1;//WRONG:+two+null+values+should+return+0!!!|code-block|syntax|javascript|501307|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I've seen this happen in a piece of code where the often recurring check for null values was performed:

<pre><code>if(( A==null ) &amp;&amp; ( B==null )
 return +1;//WRONG: two null values should return 0!!!
</code></pre>

blocks|key|716842|text|违反契约通常意味着比较器在比较对象时没有提供正确或一致的值。例如，您可能希望执行字符串比较，并使用以下命令强制空字符串排序到末尾：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|716843|if+(+one.length()+==+0+)+{
++++return+1;+++++++++++++++++++//+empty+string+sorts+last
}
if+(+two.length()+==+0+)+{
++++return+-1;++++++++++++++++++//+empty+string+sorts+last++++++++++++++++++
}
return+one.compareToIgnoreCase(+two+);|code-block|syntax|javascript|716844|但这忽略了1和2都为空的情况-在这种情况下，返回错误的值(1而不是0来显示匹配)，比较器将其报告为违规。它应该写成：|716845|if+(+one.length()+==+0+)+{
++++if+(+two.length()+==+0+)+{
++++++++return+0;+++++++++++++++//+BOth+empty+-+so+indicate
++++}
++++return+1;+++++++++++++++++++//+empty+string+sorts+last
}
if+(+two.length()+==+0+)+{
++++return+-1;++++++++++++++++++//+empty+string+sorts+last++++++++++++++++++
}
return+one.compareToIgnoreCase(+two+);|716846|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

The violation of the contract often means that the comparator is not providing the correct or consistent value when comparing objects. For example, you might want to perform a string compare and force empty strings to sort to the end with:

<pre><code>if ( one.length() == 0 ) {
 return 1; // empty string sorts last
}
if ( two.length() == 0 ) {
 return -1; // empty string sorts last 
}
return one.compareToIgnoreCase( two );
</code></pre>

But this overlooks the case where BOTH one and two are empty - and in that case, the wrong value is returned (1 instead of 0 to show a match), and the comparator reports that as a violation. It should have been written as:

<pre><code>if ( one.length() == 0 ) {
 if ( two.length() == 0 ) {
 return 0; // BOth empty - so indicate
 }
 return 1; // empty string sorts last
}
if ( two.length() == 0 ) {
 return -1; // empty string sorts last 
}
return one.compareToIgnoreCase( two );
</code></pre>

blocks|key|716896|text|Java不会严格地检查一致性，只有在遇到严重问题时才会通知您。此外，它不会为您提供来自错误的太多信息。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|716897|我对我的分类器中发生的事情感到困惑，并做了一个严格的consistencyChecker，也许这会对你有所帮助：|716898|/**
+*+@param+dailyReports
+*+@param+comparator
+*/
public+static+<T>+void+checkConsitency(final+List<T>+dailyReports,+final+Comparator<T>+comparator)+{
++final+Map<T,+List<T>>+objectMapSmallerOnes+=+new+HashMap<T,+List<T>>();

++iterateDistinctPairs(dailyReports.iterator(),+new+IPairIteratorCallback<T>()+{
++++/**
+++++*+@param+o1
+++++*+@param+o2
+++++*/
++++@Override
++++public+void+pair(T+o1,+T+o2)+{
++++++final+int+diff+=+comparator.compare(o1,+o2);
++++++if+(diff+<+Compare.EQUAL)+{
++++++++checkConsistency(objectMapSmallerOnes,+o1,+o2);
++++++++getListSafely(objectMapSmallerOnes,+o2).add(o1);
++++++}+else+if+(Compare.EQUAL+<+diff)+{
++++++++checkConsistency(objectMapSmallerOnes,+o2,+o1);
++++++++getListSafely(objectMapSmallerOnes,+o1).add(o2);
++++++}+else+{
++++++++throw+new+IllegalStateException("Equals+not+expected?");
++++++}
++++}
++});
}

/**
+*+@param+objectMapSmallerOnes
+*+@param+o1
+*+@param+o2
+*/
static+<T>+void+checkConsistency(final+Map<T,+List<T>>+objectMapSmallerOnes,+T+o1,+T+o2)+{
++final+List<T>+smallerThan+=+objectMapSmallerOnes.get(o1);

++if+(smallerThan+!=+null)+{
++++for+(final+T+o+:+smallerThan)+{
++++++if+(o+==+o2)+{
++++++++throw+new+IllegalStateException(o2+%2B+"++cannot+be+smaller+than+"+%2B+o1+%2B+"+if+it's+supposed+to+be+vice+versa.");
++++++}
++++++checkConsistency(objectMapSmallerOnes,+o,+o2);
++++}
++}
}

/**
+*+@param+keyMapValues+
+*+@param+key+
+*+@param+<Key>+
+*+@param+<Value>+
+*+@return+List<Value>
+*/+
public+static+<Key,+Value>+List<Value>+getListSafely(Map<Key,+List<Value>>+keyMapValues,+Key+key)+{
++List<Value>+values+=+keyMapValues.get(key);

++if+(values+==+null)+{
++++keyMapValues.put(key,+values+=+new+LinkedList<Value>());
++}

++return+values;
}

/**
+*+@author+Oku
+*
+*+@param+<T>
+*/
public+interface+IPairIteratorCallback<T>+{
++/**
+++*+@param+o1
+++*+@param+o2
+++*/
++void+pair(T+o1,+T+o2);
}

/**
+*+
+*+Iterates+through+each+distinct+unordered+pair+formed+by+the+elements+of+a+given+iterator
+*
+*+@param+it
+*+@param+callback
+*/
public+static+<T>+void+iterateDistinctPairs(final+Iterator<T>+it,+IPairIteratorCallback<T>+callback)+{
++List<T>+list+=+Convert.toMinimumArrayList(new+Iterable<T>()+{

++++@Override
++++public+Iterator<T>+iterator()+{
++++++return+it;
++++}

++});

++for+(int+outerIndex+=+0;+outerIndex+<+list.size()+-+1;+outerIndex%2B%2B)+{
++++for+(int+innerIndex+=+outerIndex+%2B+1;+innerIndex+<+list.size();+innerIndex%2B%2B)+{
++++++callback.pair(list.get(outerIndex),+list.get(innerIndex));
++++}
++}
}|code-block|syntax|javascript|716899|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Java does not check consistency in a strict sense, only notifies you if it runs into serious trouble. Also it does not give you much information from the error.

I was puzzled with what's happening in my sorter and made a strict consistencyChecker, maybe this will help you:

<pre><code>/**
 * @param dailyReports
 * @param comparator
 */
public static &lt;T&gt; void checkConsitency(final List&lt;T&gt; dailyReports, final Comparator&lt;T&gt; comparator) {
 final Map&lt;T, List&lt;T&gt;&gt; objectMapSmallerOnes = new HashMap&lt;T, List&lt;T&gt;&gt;();

 iterateDistinctPairs(dailyReports.iterator(), new IPairIteratorCallback&lt;T&gt;() {
 /**
 * @param o1
 * @param o2
 */
 @Override
 public void pair(T o1, T o2) {
 final int diff = comparator.compare(o1, o2);
 if (diff &lt; Compare.EQUAL) {
 checkConsistency(objectMapSmallerOnes, o1, o2);
 getListSafely(objectMapSmallerOnes, o2).add(o1);
 } else if (Compare.EQUAL &lt; diff) {
 checkConsistency(objectMapSmallerOnes, o2, o1);
 getListSafely(objectMapSmallerOnes, o1).add(o2);
 } else {
 throw new IllegalStateException("Equals not expected?");
 }
 }
 });
}

/**
 * @param objectMapSmallerOnes
 * @param o1
 * @param o2
 */
static &lt;T&gt; void checkConsistency(final Map&lt;T, List&lt;T&gt;&gt; objectMapSmallerOnes, T o1, T o2) {
 final List&lt;T&gt; smallerThan = objectMapSmallerOnes.get(o1);

 if (smallerThan != null) {
 for (final T o : smallerThan) {
 if (o == o2) {
 throw new IllegalStateException(o2 + " cannot be smaller than " + o1 + " if it's supposed to be vice versa.");
 }
 checkConsistency(objectMapSmallerOnes, o, o2);
 }
 }
}

/**
 * @param keyMapValues 
 * @param key 
 * @param &lt;Key&gt; 
 * @param &lt;Value&gt; 
 * @return List&lt;Value&gt;
 */ 
public static &lt;Key, Value&gt; List&lt;Value&gt; getListSafely(Map&lt;Key, List&lt;Value&gt;&gt; keyMapValues, Key key) {
 List&lt;Value&gt; values = keyMapValues.get(key);

 if (values == null) {
 keyMapValues.put(key, values = new LinkedList&lt;Value&gt;());
 }

 return values;
}

/**
 * @author Oku
 *
 * @param &lt;T&gt;
 */
public interface IPairIteratorCallback&lt;T&gt; {
 /**
 * @param o1
 * @param o2
 */
 void pair(T o1, T o2);
}

/**
 * 
 * Iterates through each distinct unordered pair formed by the elements of a given iterator
 *
 * @param it
 * @param callback
 */
public static &lt;T&gt; void iterateDistinctPairs(final Iterator&lt;T&gt; it, IPairIteratorCallback&lt;T&gt; callback) {
 List&lt;T&gt; list = Convert.toMinimumArrayList(new Iterable&lt;T&gt;() {

 @Override
 public Iterator&lt;T&gt; iterator() {
 return it;
 }

 });

 for (int outerIndex = 0; outerIndex &lt; list.size() - 1; outerIndex++) {
 for (int innerIndex = outerIndex + 1; innerIndex &lt; list.size(); innerIndex++) {
 callback.pair(list.get(outerIndex), list.get(innerIndex));
 }
 }
}
</code></pre>

blocks|key|501434|text|在我们的例子中，我们得到这个错误是因为我们意外地颠倒了s1和s2的比较顺序。所以请注意这一点。它显然比下面的要复杂得多，但这是一个例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|501435|s1+==+s2+++
++++return+0;
s2+>+s1+
++++return+1;
s1+<+s2+
++++return+-1;|code-block|syntax|javascript|501436|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In our case were were getting this error because we had accidentally flipped the order of comparison of s1 and s2. So watch out for that. It was obviously way more complicated than the following but this is an illustration:

<pre><code>s1 == s2 
 return 0;
s2 &gt; s1 
 return 1;
s1 &lt; s2 
 return -1;
</code></pre>

blocks|key|716950|text|即使你的compareTo在理论上保持传递性，有时细微的bug也会把事情搞砸……例如浮点算术错误。这事发生在我身上。这是我的代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|716951|public+int+compareTo(tfidfContainer+compareTfidf)+{
++++//descending+order
++++if+(this.tfidf+>+compareTfidf.tfidf)
++++++++return+-1;
++++else+if+(this.tfidf+<+compareTfidf.tfidf)
++++++++return+1;
++++else
++++++++return+0;

}+++|code-block|syntax|javascript|716952|传递性属性显然是成立的，但出于某种原因，我得到了IllegalArgumentException。事实证明，由于浮点算术中的微小错误，导致传递属性在不应该中断的地方发生舍入错误！所以我重写了代码来考虑真正的细微差别0，它起作用了：|716953|public+int+compareTo(tfidfContainer+compareTfidf)+{
++++//descending+order
++++if+((this.tfidf+-+compareTfidf.tfidf)+<+.000000001)
++++++++return+0;
++++if+(this.tfidf+>+compareTfidf.tfidf)
++++++++return+-1;
++++else+if+(this.tfidf+<+compareTfidf.tfidf)
++++++++return+1;
++++return+0;
}+++|716954|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Even if your compareTo is holds transitivity in theory, sometimes subtle bugs mess things up... such as floating point arithmetic error. It happened to me. this was my code:

<pre><code>public int compareTo(tfidfContainer compareTfidf) {
 //descending order
 if (this.tfidf &gt; compareTfidf.tfidf)
 return -1;
 else if (this.tfidf &lt; compareTfidf.tfidf)
 return 1;
 else
 return 0;

} 
</code></pre>

The transitive property clearly holds, but for some reason I was getting the IllegalArgumentException. And it turns out that due to tiny errors in floating point arithmetic, the round-off errors where causing the transitive property to break where they shouldn't! So I rewrote the code to consider really tiny differences 0, and it worked:

<pre><code>public int compareTo(tfidfContainer compareTfidf) {
 //descending order
 if ((this.tfidf - compareTfidf.tfidf) &lt; .000000001)
 return 0;
 if (this.tfidf &gt; compareTfidf.tfidf)
 return -1;
 else if (this.tfidf &lt; compareTfidf.tfidf)
 return 1;
 return 0;
} 
</code></pre>

blocks|key|717436|text|在我的例子中，我做了类似以下的事情：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|717437|if+(a.someField+==+null)+{
++++return+1;
}

if+(b.someField+==+null)+{
++++return+-1;
}

if+(a.someField.equals(b.someField))+{
++++return+a.someOtherField.compareTo(b.someOtherField);
}

return+a.someField.compareTo(b.someField);|code-block|syntax|javascript|717438|我忘记检查的是当a.someField和b.someField都为空时。|717439|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

In my case I was doing something like the following:

<pre><code>if (a.someField == null) {
 return 1;
}

if (b.someField == null) {
 return -1;
}

if (a.someField.equals(b.someField)) {
 return a.someOtherField.compareTo(b.someOtherField);
}

return a.someField.compareTo(b.someField);
</code></pre>

What I forgot to check was when both a.someField and b.someField are null.

blocks|key|501513|text|如果为compareParents(s1,+s2)+==+-1，则应为compareParents(s2,+s1)+==+1。对于你的代码来说，这并不总是正确的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|501514|特别是如果s1.getParent()+==+s2+&&+s2.getParent()+==+s1。这只是可能出现的问题之一。|501515|entityMap^0|3|S|Z|R|0|5|18|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

If <code>compareParents(s1, s2) == -1</code> then <code>compareParents(s2, s1) == 1</code> is expected. With your code it's not always true. 

Specifically if <code>s1.getParent() == s2 &amp;&amp; s2.getParent() == s1</code>. 
It's just one of the possible problems.

blocks|key|717492|text|编辑虚拟机配置对我很有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|717493|-Djava.util.Arrays.useLegacyMergeSort=true|code-block|syntax|javascript|717494|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Editing VM Configuration worked for me.

<pre><code>-Djava.util.Arrays.useLegacyMergeSort=true
</code></pre>

blocks|key|717516|text|在我的例子中，它是一个无限的种类。也就是说，首先根据条件将行向上移动，然后将相同的行向下移动到相同的位置。我在结尾处添加了另一个条件，明确地确定了行的顺序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|717517|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In my case, it was an infinite sort.
That is, at first the line moved up according to the condition, and then the same line moved down to the same place.
I added one more condition at the end that unambiguously established the order of the lines.

blocks|key|717575|text|我遇到了同样的问题，我解决了它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|717576|//This+this+your+code

private+int+compareParents(Foo+s1,+Foo+s2)+{
++++if+(s1.getParent()+==+s2)+return+-1;
++++if+(s2.getParent()+==+s1)+return+1;
++++return+0;
}|code-block|syntax|javascript|717577|违规是将不同的事物相互比较。|717578|//acceptable
compare+between+s1.getParent()+and+s2.getParent()|717579|//acceptable
compare+between+s1+and+s2|717580|//NOT+acceptable
compare+between+s1+and+s2.getParent()|717581|//NOT+acceptable
compare+between+s1.getParent()+and+s2|717582|在我的代码中，我希望通过它们的协调对地址进行排序。在比较器中，我比较了X和Y(错误地)，而不是X和X。|717583|//My+code:
++++private+void+sortBasedOnX(){
++++++++//addresses+is+a+list+of+addresses+where+each+address+has+X+and+Y
++++++++addresses.sort((o1,+o2)+->+{

++++++++++++String+a+=+o1.getAddress().getX();+
++++++++++++String+b+=+o2.getAddress().getY();+//<--+this+is+supposed+to+be+getX

++++++++++++return+Integer.parseInt(a)-Integer.parseInt(b);
++++++++});
++++}|717584|//acceptable
compare+between+o1.getAddress().getX()+and+o1.getAddress().getX()|717585|//acceptable
compare+between+o1.getAddress().getY()+and+o1.getAddress().getY()|717586|//NOT+acceptable
compare+between+o1.getAddress().getX()+and+o1.getAddress().getY()|717587|//NOT+acceptable
compare+between+o1.getAddress().getX()+and+o1.getAddress()|717588|//NOT+acceptable
compare+between+o1.getAddress().getX()+and+o1|717589|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|D|7|1I|8|@]|9|@]|A|$E|F]]|$1|12|3|13|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|14|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|15|$]]

I faced the same issue and I solved it.
<pre><code>//This this your code

private int compareParents(Foo s1, Foo s2) {
 if (s1.getParent() == s2) return -1;
 if (s2.getParent() == s1) return 1;
 return 0;
}
</code></pre>
The violation is comparing different things with each other.
<pre><code>//acceptable
compare between s1.getParent() and s2.getParent()
</code></pre>
<pre><code>//acceptable
compare between s1 and s2
</code></pre>
<pre><code>//NOT acceptable
compare between s1 and s2.getParent()
</code></pre>
<pre><code>//NOT acceptable
compare between s1.getParent() and s2
</code></pre>
In my code, I wanted to sort addresses by their coordination. In the comparator, I compared between X and Y (by mistake), instead of X and X.
<pre><code>//My code:
 private void sortBasedOnX(){
 //addresses is a list of addresses where each address has X and Y
 addresses.sort((o1, o2) -&gt; {

 String a = o1.getAddress().getX(); 
 String b = o2.getAddress().getY(); //&lt;-- this is supposed to be getX

 return Integer.parseInt(a)-Integer.parseInt(b);
 });
 }
</code></pre>
<pre><code>//acceptable
compare between o1.getAddress().getX() and o1.getAddress().getX()
</code></pre>
<pre><code>//acceptable
compare between o1.getAddress().getY() and o1.getAddress().getY()
</code></pre>
<pre><code>//NOT acceptable
compare between o1.getAddress().getX() and o1.getAddress().getY()
</code></pre>
<pre><code>//NOT acceptable
compare between o1.getAddress().getX() and o1.getAddress()
</code></pre>
<pre><code>//NOT acceptable
compare between o1.getAddress().getX() and o1
</code></pre>

Can someone explain me in simple terms, why does this code throw an exception, "Comparison method violates its general contract!", and how do I fix it?

<pre><code>private int compareParents(Foo s1, Foo s2) {
 if (s1.getParent() == s2) return -1;
 if (s2.getParent() == s1) return 1;
 return 0;
}
</code></pre>

"Comparison method violates its general contract!"

虚拟机

Java

有没有人能简单地解释一下，为什么这段代码会抛出一个异常，“比较方法违反了它的常规契约！”，我该如何修复它？private int compareParents(Foo s1, Foo s2) {    if (s1.getParent() == s2) return -1;    if (s2.getParent() ...

问“比较法违反了它的总合同！”
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问“比较法违反了它的总合同！”EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问“比较法违反了它的总合同！”
EN