¿Hay una implementación de lista sin duplicados por ahí?

Question

Sé acerca de SortedSet, pero en mi caso necesito algo que implemente List, y no Set. Entonces, ¿hay una implementación por ahí, en la API o en otro lugar?

No debería ser difícil de implementar, pero pensé por qué no preguntarle a la gente aquí primero?

Answer 1

No hay colección de Java en la biblioteca estándar para hacer esto. LinkedHashSet<E> conserva el pedido de forma similar a List, por lo que si envuelve su conjunto en List cuando desea usarlo como List obtendrá la semántica que desee.

Alternativamente, el Commons Collections (o commons-collections4, para la versión genérica) tiene un List el que hace lo que quiere ya: SetUniqueList/SetUniqueList<E>.

Answer 2

Por qué no encapsular un conjunto con una lista, más o menos como:

new ArrayList(new LinkedHashSet()) 

Esto deja a la otra aplicación para alguien que es un verdadero maestro de Colecciones ;-)

Answer 3

El documentation for collection interfaces dice:

Conjunto: una colección que no puede contener elementos duplicados.
Lista: una colección ordenada (a veces llamada secuencia). Las listas pueden contener elementos duplicados.

Así que si no quiere duplicados, probablemente no debería usar una lista.

Answer 4

En la parte superior de mi cabeza, las listas permiten duplicados. Puede implementar rápidamente un UniqueArrayList y anular todas las funciones add/insert para verificar antes de llamar a los métodos heredados. Para uso personal, solo puede implementar el método add que utiliza, y anular los demás para lanzar una excepción en caso de que los programadores futuros intenten usar la lista de una manera diferente.

Answer 5

Así que esto es lo que hice eventualmente. Espero que esto ayude a alguien más.

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

Answer 6

Usted debería considerar seriamente la respuesta de dhiller:

1. lugar de preocuparse por la adición de sus objetos a una lista de duplicados menos, agregarlos a un conjunto (cualquier aplicación), el cual por el filtro de la naturaleza cabo los duplicados
2. Cuando necesite llamar al método que requiere una lista, envuélvalo en un new ArrayList(set) (o un new LinkedList(set), lo que sea).

creo que la solución informado con la NoDuplicatesList tiene algunos problemas, sobre todo con el método , además de su clase no se ocupa de la comprobación de duplicados en la Colección pasados ​​a su método de addAll().

Answer 7

Necesitaba algo así, así que fui a las colecciones de commons y utilicé SetUniqueList, pero cuando realicé una prueba de rendimiento, encontré que no parece optimizado en comparación con el caso si quiero usar un conjunto y obtener una matriz que utiliza el método Set.toArray(), el SetUniqueTest tardó 20: 1 tiempo en completarse y luego recorrer 100.000 Strings en comparación con la otra implementación, lo cual es una gran diferencia, por lo que si te preocupa el rendimiento, te recomiendo utilice el conjunto y obtener una matriz en lugar de utilizar el SetUniqueList, a menos que realmente necesita la lógica de la SetUniqueList, entonces usted necesita para comprobar otras soluciones ...

el método principal de código de prueba:

public void main (String [] args) estáticas {

SetUniqueList pq = SetUniqueList.decorate(new ArrayList()); 
Set s = new TreeSet(); 

long t1 = 0L; 
long t2 = 0L; 
String t; 


t1 = System.nanoTime(); 
for (int i = 0; i < 200000; i++) { 
    pq.add("a" + Math.random()); 
} 
while (!pq.isEmpty()) { 
    t = (String) pq.remove(0); 
} 
t1 = System.nanoTime() - t1; 

t2 = System.nanoTime(); 
for (int i = 0; i < 200000; i++) { 
    s.add("a" + Math.random()); 
} 

s.clear(); 
String[] d = (String[]) s.toArray(new String[0]); 
s.clear(); 
for (int i = 0; i < d.length; i++) { 
    t = d[i]; 

} 
t2 = System.nanoTime() - t2; 

System.out.println((double)t1/1000/1000/1000); //seconds 
System.out.println((double)t2/1000/1000/1000); //seconds 
System.out.println(((double) t1)/t2);  //comparing results 

}

Saludos Mohammed Sleem http://abusleem.net/blog

Answer 8

acabo de hacer mi propia UniqueList en mi propia pequeña biblioteca como esta:

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

Tengo una clase TestCollections que se ve así:

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

Funciona bien. Todo lo que hace es agregar a un conjunto si no lo tiene ya y hay un Arraylist que es retornable, así como una matriz de objetos.

Answer 9

en el método add, ¿por qué no utilizar HashSet.add() para verificar duplicados en lugar de HashSet.consist(). HashSet.add() devolverá true si no hay duplicados y false en caso contrario.

Answer 10

Esto es lo que hice y funciona.

Suponiendo que tengo un ArrayList para trabajar, lo primero que hice fue crear un nuevo LinkedHashMap.

LinkedHashSet<E> hashSet = new LinkedHashSet<E>() 

Luego intento agregar mi nuevo elemento al LinkedHashSet. El método add no altera el LinkedHasSet y devuelve falso si el nuevo elemento es un duplicado. Así que esto se convierte en una condición que puedo probar antes de agregar al ArrayList.

if (hashSet.add(E)) arrayList.add(E); 

Esta es una manera simple y elegante de evitar que se agreguen duplicados a una lista de matriz. Si lo desea, puede encapsularlo y anular el método add en una clase que amplía el ArrayList. Simplemente recuerde tratar con addAll al recorrer los elementos y llamar al método add.

Answer 11

NOTA: no se necesita subList implementación.

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

}