Komparator-und equals()

Während dies funktionieren könnte, es ist weit von einer best practice.

Aus der SortedSet docs:

Beachten Sie, dass die Bestellung betrieben und gepflegt wird, sortiert (unabhängig davon, ob oder nicht eine ausdrückliche Komparator vorgesehen ist) muss konsistent mit equals wenn die sorted-set ist, um richtig implementieren die Schnittstelle. (Siehe die Vergleichbar Schnittstelle oder Komparator Schnittstelle für eine präzise definition konsistent mit equals.) Dies ist so, weil es die Schnittstelle definiert ist, in Bezug auf die equals-operation, aber eine sortierte Gruppe führt alle element-Vergleiche, die mit Ihrer compareTo (oder vergleichen) - Methode, so werden zwei Elemente gelten als gleich, die von dieser Methode sind, aus der Sicht des sortierten Satzes, gleich. Das Verhalten, eine sortierte Menge ist wohldefiniert, auch wenn seine Bestellung ist inkonsistent mit equals; es schlägt fehl, um zu gehorchen dem Allgemeinen Vertrag für die Schnittstelle.

Für Objekte, die Umsetzung Comparable sollte es immer eine übereinstimmung zwischen den Methoden equals(), hashcode() und compareTo().

Ich fürchte, ich komme SortedSet ist einfach nicht das, was Sie wollen, noch eine Guave MultiSet angemessen sein (denn es wird nicht lassen Sie Sie selbständig abrufen mehrerer gleicher Artikel). Ich denke, dass das, was Sie brauchen, ist ein SortedList. Es gibt keine solche Tier, das ich kenne (vielleicht in commons-collections, aber die sind ein bisschen auf der legacy-Seite), so dass ich realisiert für Sie mit Guave - ForwardingList als Basisklasse. Kurz gesagt: diese Liste Delegierten fast alles, was zu einem ArrayList es intern verwendet, aber es verwendet Collections.binarySearch() im add() Methode, um die richtige Einfügeposition, und es wirft ein UnsupportedOperationException auf alle optionalen Methoden der List und ListIterator Schnittstellen, add-oder set-Werte an einer gegebenen position.

Die Konstruktoren sind identisch mit denen von ArrayList, aber für jeden von Ihnen gibt es auch eine zweite version mit einem custom Comparator. Wenn Sie nicht verwenden Sie eine benutzerdefinierte Komparator, Ihre Liste Elemente implementieren müssen Comparable oder RuntimeExceptions auftreten während der Sortierung.

public class SortedArrayList<E> extends ForwardingList<E> implements
    RandomAccess{

    private final class ListIteratorImpl extends ForwardingListIterator<E>{
        private final int start;
        public ListIteratorImpl(final int start){
            this.start = start;
        }

        @Override
        public void set(E element){throw new UnsupportedOperationException();}

        @Override
        public void add(E element){throw new UnsupportedOperationException();}

        @Override
        protected ListIterator<E> delegate(){return inner.listIterator(start);};

    }

    private Comparator<? super E> comparator;

    private List<E> inner;

    public SortedArrayList(){this(null, null, null);}

    @SuppressWarnings("unchecked")
    private SortedArrayList(
        final List<E> existing,
        final Collection<? extends E> values,
        final Comparator<? super E> comparator
    ){
        this.comparator =
            (Comparator<? super E>)
               (comparator == null
                   ? Ordering.natural()
                   : comparator   );
        inner = (
            existing == null
                ? (values == null
                      ? new ArrayList<E>(values)
                      : new ArrayList<E>()
                   )
                : existing;
    }

    public SortedArrayList(final Collection<? extends E> c){
        this(null, c, null);
    }

    public SortedArrayList(final Collection<? extends E> c,
        final Comparator<? super E> comparator){
        this(null, c, comparator);
    }

    public SortedArrayList(final Comparator<? super E> comparator){
        this(null, null, comparator);
    }

    public SortedArrayList(final int initialCapacity){
        this(new ArrayList<E>(initialCapacity), null, null);
    }

    public SortedArrayList(final int initialCapacity,
        final Comparator<? super E> comparator){
        this(new ArrayList<E>(initialCapacity), null, comparator);
    }

    @Override
    public boolean add(final E e){
        inner.add(
            Math.abs(
                Collections.binarySearch(inner, e, comparator)
            ) + 1,
            e
        );
        return true;
    }

    @Override
    public void add(int i, E e){throw new UnsupportedOperationException();}

    @Override
    public boolean addAll(final Collection<? extends E> collection){
        return standardAddAll(collection);
    }

    @Override
    public boolean addAll(int i,
        Collection<? extends E> es){
        throw new UnsupportedOperationException();
    }

    @Override
    protected List<E> delegate(){ return inner; }

    @Override
    public List<E> subList(final int fromIndex, final int toIndex){
        return new SortedArrayList<E>(
            inner.subList(fromIndex, toIndex),
            null,
            comparator
        );
    }

    @Override
    public ListIterator<E> listIterator(){ return new ListIteratorImpl(0); }

    @Override
    public ListIterator<E> listIterator(final int index){
        return new ListIteratorImpl(index);
    }

    @Override
    public E set(int i, E e){ throw new UnsupportedOperationException(); }

}

InformationsquelleAutor Sean Patrick Floyd

Gibt es keine Regel in Java, die sagt, dass die hash-codes der beiden Objekte müssen Verschieden sein, nur weil Sie nicht gleich (also o1.hashCode() - o2.hashCode() zurückkehren konnte 0 in Ihrem Fall).

Auch das Verhalten der equals() sollte werden im Einklang mit den Ergebnissen von compareTo(). Dies ist nicht eine muss aber wenn Sie es nicht durchhalten, es deutet darauf hin, dass Ihr design hat ein großes Manko.

Empfehle ich, einen Blick auf die anderen Felder der Objekte und verwenden Sie einige von diesen zu erweitern, Ihre-Vergleich so erhalten Sie einen Wert != 0 für Objekte waren equals() == false.

InformationsquelleAutor Aaron Digulla

Sehr interessante Frage.
Soweit ich dein problem verstanden ist doppelte Elemente zu.

Ich denke, dass, wenn o1.equals(o2) deren hash-codes könnten gleich zu. Es hängt von der Implementierung der hashCode() in der Klasse "Foo". Also, ich würde vorschlagen, Sie verwenden System.identityHashCode(x) statt.

InformationsquelleAutor AlexR

Wenn Sie keine speziellen erwartet, dass die Bestellung für zwei beliebige Elemente gegeben, aber immer noch wollen, um Sie zu betrachten, un-gleich, dann haben Sie wieder einige angegebene Bestellung sowieso.

So, wie andere geschrieben haben, hashCode() ist nicht ein guter Kandidat, weil die hashCode() Werte beider Elemente können ganz einfach gleich. System.identityHashCode() wäre die bessere Wahl, aber ist noch nicht perfekt, wie auch identityHashCode() garantiert nicht eindeutige Werte entweder

Den Guave arbitrary() Bestellung implementiert eine Comparator mit System.identityHashCode().

InformationsquelleAutor Joachim Sauer

int res = o1.compareTo(o2);

if(res == 0 || !o1.equals(o2)){
    return o1.hashCode() - o2.hashCode();
}

Kann problematisch sein, da wenn 2 Objekte gleich sind (d.h. in Ihrem res == 0) dann diese 2 Objekte wieder den gleichen hashcode. Hashcodes sind nicht einzigartig für jedes Objekt.

Bearbeiten @Stas, Die System.identityHashCode(Object x); noch nicht helfen. Der Grund ist beschrieben auf der javadoc:

Gibt die gleichen hash-code für die
ein bestimmtes Objekt wie würde zurückgegeben werden
die Standard-Methode hashCode(),
ob oder ob nicht das Objekt ist
Klasse überschreibt hashCode(). Die hash
code für die null-Referenz null ist.

InformationsquelleAutor Buhake Sindi

Zwei Punkte relevant sein könnten, und diese sind, dass die Rückkehr in eine situation dargestellt, als -1 und das hängt davon ab, ob ein negativer Wert ist, dürfen in der Funktion parameter-variable oder des betreffenden Landes von nutzen, und auch wenn die Methode, die Sie verwenden ist nicht gestattet. Es sind standard-Daten-Vermittlung-Methoden wie Auswahl oder Auswahl Sortieren und Papier Beschreibung oder code wird in der Regel von einer nationalen Behörde, wenn eine Kopie nicht an Ihrem Arbeitsplatz. Mit Vergleiche wie größer oder kleiner als die Geschwindigkeit des Codes und vermeidet die Verwendung von einem direkten Vergleich für die Gleichstellung von stillschweigenden dropthrough, um Sie später zu Skripts oder code.

InformationsquelleAutor Developer