Est-il un no-duplicate Liste de mise en œuvre là-bas?

Il n'y a pas de Java collection de la bibliothèque standard pour ce faire. LinkedHashSet<E> préserve de la commande à la façon d'un List, cependant, de sorte que si vous mettez l'ensemble dans un List lorsque vous voulez l'utiliser comme un List vous aurez la sémantique que vous voulez.

Sinon, le Commons Collections (ou commons-collections4, pour la version générique) a un List qui fait ce que vous voulez déjà: SetUniqueList /SetUniqueList<E>.

Voici donc ce que j'ai fait par la suite. J'espère que cela aide quelqu'un d'autre.

class NoDuplicatesList<E> extends LinkedList<E> {
    @Override
    public boolean add(E e) {
        if (this.contains(e)) {
            return false;
        }
        else {
            return super.add(e);
        }
    }

    @Override
    public boolean addAll(Collection<? extends E> collection) {
        Collection<E> copy = new LinkedList<E>(collection);
        copy.removeAll(this);
        return super.addAll(copy);
    }

    @Override
    public boolean addAll(int index, Collection<? extends E> collection) {
        Collection<E> copy = new LinkedList<E>(collection);
        copy.removeAll(this);
        return super.addAll(index, copy);
    }

    @Override
    public void add(int index, E element) {
        if (this.contains(element)) {
            return;
        }
        else {
            super.add(index, element);
        }
    }
}   

Pourquoi ne pas encapsuler un ensemble avec une liste, sorte comme:

new ArrayList( new LinkedHashSet() )

Ce qui laisse les autres de la mise en œuvre de quelqu'un qui est un véritable maître de Collections 😉

REMARQUE: il ne prend pas sous-liste de mise en œuvre de compte.

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
public class UniqueList<T> extends ArrayList<T> {
private static final long serialVersionUID = 1L;
/** Unique elements SET */
private final Set<T> set=new HashSet();
/** Used by addAll methods */
private Collection<T> addUnique(Collection<? extends T> col) {
Collection<T> unique=new ArrayList();
for(T e: col){
if (set.add(e)) unique.add(e);
}
return unique;
}
@Override
public boolean add(T e) {
return set.add(e) ? super.add(e) : false;
}
@Override
public boolean addAll(Collection<? extends T> col) {
return super.addAll(addUnique(col));
}
@Override
public void add(int index, T e) {
if (set.add(e)) super.add(index, e);
}
@Override
public boolean addAll(int index, Collection<? extends T> col) {
return super.addAll(index, addUnique(col));
}
}

dans add méthode, pourquoi ne pas utiliser HashSet.add() pour vérifier les doublons au lieu de HashSet.consist().
HashSet.add() sera de retour true si aucun doublon et false autrement.

Je viens de faire ma propre UniqueList dans ma petite bibliothèque comme ceci:

package com.bprog.collections;//my own little set of useful utilities and classes
import java.util.HashSet;
import java.util.ArrayList;
import java.util.List;
/**
*
* @author Jonathan
*/
public class UniqueList {
private HashSet masterSet = new HashSet();
private ArrayList growableUniques;
private Object[] returnable;
public UniqueList() {
growableUniques = new ArrayList();
}
public UniqueList(int size) {
growableUniques = new ArrayList(size);
}
public void add(Object thing) {
if (!masterSet.contains(thing)) {
masterSet.add(thing);
growableUniques.add(thing);
}
}
/**
* Casts to an ArrayList of unique values
* @return 
*/
public List getList(){
return growableUniques;
}
public Object get(int index) {
return growableUniques.get(index);
}
public Object[] toObjectArray() {
int size = growableUniques.size();
returnable = new Object[size];
for (int i = 0; i < size; i++) {
returnable[i] = growableUniques.get(i);
}
return returnable;
}
}

J'ai un TestCollections classe qui ressemble à ceci:

package com.bprog.collections;
import com.bprog.out.Out;
/**
*
* @author Jonathan
*/
public class TestCollections {
public static void main(String[] args){
UniqueList ul = new UniqueList();
ul.add("Test");
ul.add("Test");
ul.add("Not a copy");
ul.add("Test"); 
//should only contain two things
Object[] content = ul.toObjectArray();
Out.pl("Array Content",content);
}
}

Fonctionne très bien. Tout ce qu'il fait est qu'il ajoute à un ensemble si il ne l'a pas déjà, et il y a une liste de tableaux qui est consigné, ainsi que d'un tableau d'objets.