Quel type de liste <?> va automatiquement éliminer les doublons

Question

Quel type de liste va automatiquement éliminer les doublons lorsqu'ils sont ajoutés.

par exemple. pour une liste si j'ajoute 1,2,3,4,5,1,2,3 = la liste devrait juste contenir juste 1,2,3,4,5

Answer 1

Jetez un oeil à LinkedHashSet

Answer 2

Un ensemble éliminera automatiquement les doublons, mais il est une collection plutôt qu'une liste.

Je ne pense pas qu'il existe une liste qui élimine les doublons dans la bibliothèque standard.

La page Annotated Outline of the Collections Framework de la documentation de l'API Java 6 SE indique que «les doublons sont généralement autorisés».

Answer 3

Si vous voulez éliminer les doublons, utilisez Set

Answer 4

Vous voulez un jeu peut-être, par exemple HashSet(), plutôt qu'une liste? Aucune liste n'éliminera les doublons, par définition les listes les autorisent.

Answer 5

Comme l'affiche ci-dessus a dit, il n'y a pas de liste avec manipulation unique.

Regardez List (Java Platform SE 6)

Contrairement aux jeux, listes permettent généralement des éléments en double. Plus formellement, les listes autorisent généralement des paires d'éléments e1 et e2 telles que e1.equals (e2), et elles autorisent généralement plusieurs éléments NULL s'ils permettent des éléments null du tout. Il n'est pas inconcevable que quelqu'un veuille implémenter une liste qui interdit les doublons, en lançant des exceptions d'exécution lorsque l'utilisateur tente de les insérer, mais nous nous attendons à ce que cette utilisation soit rare.

Answer 6

Vous pouvez étendre le java.util.ArrayList existant et y encapsuler un java.util.Set. Vous devez passer outre tous add(...), addAll(...) et remove méthodes et d'abord vérifier si un élément est dans l'ensemble encapsulé (dans le cas de l'ajouter à la liste):

public class ListSet<E> extends ArrayList<E> { 

    private Set<E> set; 

    public ListSet() { 
     set = new HashSet<E>(); 
    } 

    @Override 
    public boolean add(E element) { 
     if(set.add(element)) { 
      super.add(element); 
      return true; 
     } 
     return false; 
    } 

    // other add and remove methods 
} 

EDIT

Comme mentionné @Alnitak: n'oubliez pas de synchroniser votre HashSet de sauvegarde chaque fois qu'un élément est supprimé.

Answer 7

Voici une extension de ArrayList qui rejette les doublons:

public class NoDupeList<E> extends ArrayList<E>{ 

    private static final long serialVersionUID = -2682691450003022201L; 

    public NoDupeList(){ 
     super(); 
    } 

    public NoDupeList(final Collection<? extends E> c){ 
     super(c instanceof Set<?> ? c : new LinkedHashSet<E>(c)); 
    } 

    public NoDupeList(final int initialCapacity){ 
     super(initialCapacity); 
    } 

    @Override 
    public boolean add(final E e){ 
     return !this.contains(e) && super.add(e); 
    }; 

    @Override 
    public boolean addAll(final Collection<? extends E> c){ 
     final List<E> intermediate = new ArrayList<E>(c); 
     intermediate.removeAll(this); 
     return super.addAll(intermediate); 
    } 

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

    @Override 
    public E set(final int index, final E element){ 
     if(this.contains(element) && !this.get(index).equals(element)){ 
      throw new IllegalArgumentException("This would cause a duplicate"); 
     } 
     return super.set(index, element); 
    }; 

} 

La seule chose que je ne peux pas traiter est la méthode set(). Ma solution est de lancer un IllegalArgumentException si cela provoque un doublon, mais peut-être que l'on devrait généralement laisser cette méthode lancer un UnsupportedOperationException à la place.

Quoi qu'il en soit, voici une méthode d'essai:

@Test 
public void testNoDupeList() throws Exception{ 
    final List<String> list = 
     new NoDupeList<String>(Arrays.asList("abc", "def", "abc")); 
    assertEquals(list, Arrays.asList("abc", "def")); 
    list.addAll(Arrays.asList("abc", "def", "ghi")); 
    assertEquals(list, Arrays.asList("abc", "def", "ghi")); 
    try{ 
     list.set(2, "abc"); 
     fail("This should have caused an Exception"); 
    } catch(final Exception e){} 
}; 

Answer 8

Ne pas, comme quelqu'un a suggéré, mettre en œuvre votre propre liste qui fait de doublons et retourne false s'il y a un double à ajouter().

Pourquoi?Parce que vous brisera le contrat d'interface List qui dit:

public boolean add(E e) 
[...] 
Returns: 
     true (as specified by Collections.add()) 

List.add (E e) DOIT retourner true et ajoutez l'élément à la liste, ou lancer une exception. Les listes ne sont pas censées avoir des vérifications en double, c'est ce que les ensembles sont pour.

Answer 9

La meilleure façon d'obtenir une List réelle qui est triée et n'a pas de doublons serait de l'envelopper comme ceci:

List<Integer> unique = 
    new ArrayList<Integer>(new TreeSet<Integer>(Arrays.asList(1, 1, 2, 2, 3, 3))); 

Notez que lorsque vous ajoutez à cette doublons liste ne pas être éliminés si , mais peut-être que cela fonctionne pour vous.

Answer 10

Au moment où vous pouvez créer votre propre classe et @Override ajouter une méthode à votre classe. "juste voir mon code et pratiquez-le"

import java.util.ArrayList; 

import java.util.List; 

class MyList extends ArrayList<Integer> { 

    private static final long serialVersionUID = 1L; 

    @Override 
    public boolean add(Integer element) { 

     if (!found(element)) { 
      super.add(element); 
     } 
     return false; 

    } 
    public boolean found(Integer e) { 
     return equals(e); 
    } 
    public boolean equals(Integer e) { 

     for (int i = 0; i < super.size(); i++) { 
      if (super.get(i).equals(e)) 
       return true; 
     } 

     return false; 
    } 

} 

public class ListRemovingDuplicated { 

    public static void main(String[] abd) { 

     List<Integer> obj = new MyList(); 
     obj.add(10); 
     obj.add(20); 
     obj.add(10); 
     obj.add(10); 
     obj.add(30); 
     System.out.println(obj); 

    } 
}