"Il metodo di confronto viola il suo contratto generale!"

Qualcuno può spiegarmi in termini semplici, perché questo codice genera un'eccezione, "Il metodo di confronto viola il suo contratto generale!" E come posso risolverlo?

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

Il tuo comparatore non è transitivo.

Lascia che Asia il genitore Be Bil genitore di C. Da A > Be B > C, allora deve essere il caso che A > C. Tuttavia, se il tuo comparatore è invocato su Ae C, restituirebbe zero, il che significa A == C. Ciò viola il contratto e quindi genera l'eccezione.

È piuttosto carino che la biblioteca lo rilevi e ti faccia sapere, piuttosto che comportarsi in modo irregolare.

Un modo per soddisfare il requisito di transitività compareParents()è attraversare la getParent()catena invece di guardare solo l'antenato immediato.

Solo perché questo è quello che ho ottenuto quando ho cercato su Google questo errore, il mio problema era che avevo

if (value < other.value)
  return -1;
else if (value >= other.value)
  return 1;
else
  return 0;

il value >= other.valuedovrebbe (ovviamente) effettivamente essere in value > other.valuemodo che tu possa effettivamente restituire 0 con oggetti uguali.

La violazione del contratto spesso significa che il comparatore non fornisce il valore corretto o coerente durante il confronto di oggetti. Ad esempio, potresti voler eseguire un confronto tra stringhe e forzare le stringhe vuote per ordinare fino alla fine con:

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

Ma questo trascura il caso in cui SIA uno e due sono vuoti - e in quel caso, viene restituito il valore errato (1 invece di 0 per mostrare una corrispondenza), e il comparatore lo segnala come una violazione. Avrebbe dovuto essere scritto come:

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 );

Anche se il tuo confrontoTo trattiene la transitività in teoria, a volte i bug sottili rovinano le cose ... come l'errore aritmetico in virgola mobile. È successo a me. questo era il mio codice:

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;

}   

La proprietà transitiva è chiaramente valida, ma per qualche motivo stavo ottenendo IllegalArgumentException. E si scopre che a causa di piccoli errori nell'aritmetica in virgola mobile, gli errori di arrotondamento causano la rottura della proprietà transitiva dove non dovrebbero! Quindi ho riscritto il codice per considerare 0 differenze davvero minuscole, e ha funzionato:

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;
}   

Nel nostro caso stavano ottenendo questo errore perché avevamo capovolto accidentalmente l'ordine di confronto di s1 e s2. Quindi stai attento. Era ovviamente molto più complicato del seguente ma questa è un'illustrazione:

s1 == s2   
    return 0;
s2 > s1 
    return 1;
s1 < s2 
    return -1;

Java non controlla la coerenza in senso stretto, ti avvisa solo se incontra seri problemi. Inoltre non ti dà molte informazioni dall'errore.

Sono rimasto perplesso su ciò che sta accadendo nel mio selezionatore e ho fatto una verifica costante della coerenza, forse questo ti aiuterà:

/**
 * @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 + "  cannot be smaller than " + o1 + " 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++) {
    for (int innerIndex = outerIndex + 1; innerIndex < list.size(); innerIndex++) {
      callback.pair(list.get(outerIndex), list.get(innerIndex));
    }
  }
}

Nel mio caso stavo facendo qualcosa di simile al seguente:

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);

Quello che ho dimenticato di controllare era quando sia a.someField che b.someField sono nulli.

Ho visto questo accadere in un pezzo di codice in cui è stato eseguito il controllo spesso ricorrente per valori null:

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

Se compareParents(s1, s2) == -1allora compareParents(s2, s1) == 1è previsto. Con il tuo codice non è sempre vero.

In particolare se s1.getParent() == s2 && s2.getParent() == s1. È solo uno dei possibili problemi.

La modifica della configurazione della VM ha funzionato per me.

-Djava.util.Arrays.useLegacyMergeSort=true

Non puoi confrontare i dati degli oggetti in questo modo: s1.getParent() == s2- questo confronterà i riferimenti agli oggetti. Dovresti eseguire l'override equals functionper la classe Foo e confrontarli in questo modos1.getParent().equals(s2)