Esiste un set di conservazione dell'ordine di inserzione che implementa anche List?

Sto cercando di trovare un'implementazione di java.util.Liste java.util.Setallo stesso tempo in Java. Voglio che questa classe consenta solo elementi univoci (as Set) e conservi il loro ordine (come List). Esiste in JDK 6?

È importante averlo in List<T>#add(int, T)modo da poter inserire in una posizione specifica.

TreeSetè ordinato in base all'ordine degli elementi; LinkedHashSetmantiene l'ordine di inserzione. Spero che uno di questi sia quello che stavi cercando.

Hai specificato che vuoi essere in grado di inserire in una posizione arbitraria , sospetto che dovrai scriverne uno tuo - crea semplicemente una classe contenente a HashSet<T>e an ArrayList<T>; quando si aggiunge un elemento, verificare se è presente o meno nel set prima di aggiungerlo all'elenco.

In alternativa, le commons-collections4 di Apache offrono ListOrderedSete SetUniqueList, che si comportano in modo simile e dovrebbero soddisfare i requisiti dati.

LinkedHashSet è la risposta.

Ordinamento e unicità delle iterazioni.

http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashSet.html

Intendi come LinkedHashSet? Ciò preserva l'ordine di immissione, ma non consente duplicati.

IMHO, è un requisito insolito ma puoi scrivere un elenco senza duplicati.

class SetList<T> extends ArrayList<T> {
    @Override
    public boolean add(T t) {
        return !super.contains(t) && super.add(t);
    }

    @Override
    public void add(int index, T element) {
        if (!super.contains(element)) super.add(index, element);
    }

    @Override
    public boolean addAll(Collection<? extends T> c) {
        boolean added = false;
        for (T t : c)
            added |= add(t);
        return added;
    }

    @Override
    public boolean addAll(int index, Collection<? extends T> c) {
        boolean added = false;
        for (T t : c)
            if (!super.contains(t)) {
                super.add(index++, t);
                added = true;
            }
        return added;
    }
}

Non è possibile implementare Liste Setsubito senza violazione del contratto. Vedi, ad esempio, il Set.hashCodecontratto:

Il codice hash di un set è definito come la somma dei codici hash degli elementi nel set, dove il codice hash di un elemento null è definito come zero.

D'altra parte ecco il contratto di List.hashCode:

Il codice hash di una lista è definito come il risultato del seguente calcolo:

int hashCode = 1;
for (E e : list)
    hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());

Quindi è impossibile implementare un'unica classe che garantisca l'adempimento di entrambi i contratti. Lo stesso problema per l' equalsimplementazione.

Se non ti limiti a JDK 6, puoi utilizzare la libreria di raccolte comuni di Apache che offre la corrispondenza esatta per le tue esigenze: ListOrderedSet . È come Liste Setcombinato insieme :)

Ho avuto un problema simile, quindi ho scritto il mio. Vedi qui . Si IndexedArraySetestende ArrayListe implementa Set, quindi dovrebbe supportare tutte le operazioni di cui hai bisogno. Nota che l'inserimento di elementi in posizioni nel mezzo di un ArrayListpuò essere lento per elenchi di grandi dimensioni perché tutti gli elementi seguenti devono essere spostati. Il mio IndexedArraySetnon cambia questo.

Un'altra opzione (meno il Listrequisito dell'interfaccia) è Guava's ImmutableSet, che conserva l'ordine di inserimento. Dalla loro pagina wiki :

Fatta eccezione per le raccolte ordinate, l' ordine viene mantenuto dal momento della costruzione. Per esempio,

ImmutableSet.of("a", "b", "c", "a", "d", "b")

itererà sui suoi elementi nell'ordine "a", "b", "c", "d".