¿Cómo elimino los elementos repetidos de ArrayList?

Tengo una ArrayList of Strings , y quiero eliminar cadenas repetidas de ella. ¿Cómo puedo hacer esto?

Si no desea duplicados en una Collection , debe considerar por qué está utilizando una Collection que permite duplicados. La forma más fácil de eliminar elementos repetidos es agregar el contenido a un Set (que no permitirá duplicados) y luego agregar el Set nuevo a ArrayList :

 List al = new ArrayList<>(); // add elements to al, including duplicates Set hs = new HashSet<>(); hs.addAll(al); al.clear(); al.addAll(hs); 

Por supuesto, esto destruye el orden de los elementos en ArrayList .

Si bien la conversión de ArrayList a HashSet elimina efectivamente los duplicados, si necesita conservar el orden de inserción, le sugiero que use esta variante.

 // list is some List of Strings Set s = new LinkedHashSet<>(list); 

Luego, si necesita recuperar una referencia de List , puede usar nuevamente el constructor de conversión.

En Java 8:

 List deduped = list.stream().distinct().collect(Collectors.toList()); 

Tenga en cuenta que se debe respetar el contrato hashCode-igual para los miembros de la lista para que el filtrado funcione correctamente.

Si no quiere duplicados, use un conjunto en lugar de una List . Para convertir una List en un Set , puede usar el siguiente código:

 // list is some List of Strings Set s = new HashSet(list); 

Si es realmente necesario, puede usar la misma construcción para convertir un Set nuevamente en una List .

Supongamos que tenemos una lista de String como:

 List strList = new ArrayList<>(5); // insert up to five items to list. 

Entonces podemos eliminar elementos duplicados de múltiples maneras.

Antes de Java 8

 List deDupStringList = new ArrayList<>(new HashSet<>(strList)); 

Usando guayaba

 List deDupStringList2 = Lists.newArrayList(Sets.newHashSet(strList)); 

Usando Java 8

 List deDupStringList3 = strList.stream().distinct().collect(Collectors.toList()); 

Nota: Si queremos mantener el orden de inserción, entonces necesitamos usar LinkedHashSet en lugar de HashSet .

Esta es una forma que no afecta el orden de su lista:

 ArrayList l1 = new ArrayList(); ArrayList l2 = new ArrayList(); Iterator iterator = l1.iterator(); while (iterator.hasNext()) { YourClass o = (YourClass) iterator.next(); if(!l2.contains(o)) l2.add(o); } 

l1 es la lista original, y l2 es la lista sin elementos repetidos (asegúrese de que YourClass tenga el mismo método de acuerdo con lo que desea para la igualdad)

Las secuencias Java 8 proporcionan una manera muy simple de eliminar elementos duplicados de una lista. Usando el método distinto. Si tenemos una lista de ciudades y queremos eliminar duplicados de esa lista, se puede hacer en una sola línea:

  List cityList = new ArrayList<>(); cityList.add("Delhi"); cityList.add("Mumbai"); cityList.add("Bangalore"); cityList.add("Chennai"); cityList.add("Kolkata"); cityList.add("Mumbai"); cityList = cityList.stream().distinct().collect(Collectors.toList()); 

Cómo eliminar elementos duplicados de una lista de arrays

También hay ImmutableSet de Guava como opción ( aquí está la documentación):

 ImmutableSet.copyOf(list); 

Es posible eliminar duplicados de la lista de arrays sin usar HashSet o una lista de arrays más .

Prueba este código …

  ArrayList lst = new ArrayList(); lst.add("ABC"); lst.add("ABC"); lst.add("ABCD"); lst.add("ABCD"); lst.add("ABCE"); System.out.println("Duplicates List "+lst); Object[] st = lst.toArray(); for (Object s : st) { if (lst.indexOf(s) != lst.lastIndexOf(s)) { lst.remove(lst.lastIndexOf(s)); } } System.out.println("Distinct List "+lst); 

La salida es

 Duplicates List [ABC, ABC, ABCD, ABCD, ABCE] Distinct List [ABC, ABCD, ABCE] 

También puede hacerlo de esta manera y conservar el orden:

 // delete duplicates (if any) from 'myArrayList' myArrayList = new ArrayList(new LinkedHashSet(myArrayList)); 

Probablemente sea un poco exagerado, pero disfruto este tipo de problema aislado. 🙂

Este código usa un conjunto temporal (para la verificación de unicidad) pero elimina elementos directamente dentro de la lista original. Como la eliminación de elementos dentro de una ArrayList puede inducir una gran cantidad de copia de matriz, se evita el método remove (int).

 public static  void removeDuplicates(ArrayList list) { int size = list.size(); int out = 0; { final Set encountered = new HashSet(); for (int in = 0; in < size; in++) { final T t = list.get(in); final boolean first = encountered.add(t); if (first) { list.set(out++, t); } } } while (out < size) { list.remove(--size); } } 

Mientras estamos en esto, aquí hay una versión para LinkedList (¡mucho más bonita!):

 public static  void removeDuplicates(LinkedList list) { final Set encountered = new HashSet(); for (Iterator iter = list.iterator(); iter.hasNext(); ) { final T t = iter.next(); final boolean first = encountered.add(t); if (!first) { iter.remove(); } } } 

Use la interfaz de marcador para presentar una solución unificada para List:

 public static  void removeDuplicates(List list) { if (list instanceof RandomAccess) { // use first version here } else { // use other version here } } 

EDITAR: Creo que los generics-cosas realmente no agregan ningún valor aquí ... Oh, bueno. 🙂

esto puede resolver el problema:

 private List clearListFromDuplicateFirstName(List list1) { Map cleanMap = new LinkedHashMap(); for (int i = 0; i < list1.size(); i++) { cleanMap.put(list1.get(i).getFirstName(), list1.get(i)); } List list = new ArrayList(cleanMap.values()); return list; } 
 public static void main(String[] args){ ArrayList al = new ArrayList(); al.add("abc"); al.add('a'); al.add('b'); al.add('a'); al.add("abc"); al.add(10.3); al.add('c'); al.add(10); al.add("abc"); al.add(10); System.out.println("Before Duplicate Remove:"+al); for(int i=0;i 


Si está dispuesto a usar una biblioteca de terceros, puede usar el método distinct() en Eclipse Collections (anteriormente GS Collections).

 ListIterable integers = FastList.newListWith(1, 3, 1, 2, 2, 1); Assert.assertEquals( FastList.newListWith(1, 3, 2), integers.distinct()); 

La ventaja de utilizar distinct() lugar de convertir a un conjunto y luego volver a una lista es que distinct() conserva el orden de la lista original, conservando la primera aparición de cada elemento. Se implementa mediante el uso de un conjunto y una lista.

 MutableSet seenSoFar = UnifiedSet.newSet(); int size = list.size(); for (int i = 0; i < size; i++) { T item = list.get(i); if (seenSoFar.add(item)) { targetCollection.add(item); } } return targetCollection; 

Si no puede convertir su Lista original en un tipo de Colecciones de Eclipse, puede usar ListAdapter para obtener la misma API.

 MutableList distinct = ListAdapter.adapt(integers).distinct(); 

Nota: soy un committer para las colecciones de Eclipse.

Estas tres líneas de código pueden eliminar el elemento duplicado de ArrayList o cualquier colección.

 List entities = repository.findByUserId(userId); Set s = new LinkedHashSet(entities); entities.clear(); entities.addAll(s); 

Cuando rellene ArrayList, use una condición para cada elemento. Por ejemplo:

  ArrayList< Integer > al = new ArrayList< Integer >(); // fill 1 for ( int i = 0; i <= 5; i++ ) if ( !al.contains( i ) ) al.add( i ); // fill 2 for (int i = 0; i <= 10; i++ ) if ( !al.contains( i ) ) al.add( i ); for( Integer i: al ) { System.out.print( i + " "); } 

Obtendremos una matriz {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Si desea conservar su pedido, entonces es mejor utilizar LinkedHashSet . Porque si desea pasar esta lista a una consulta de inserción al iterarla, se conservará la orden.

Prueba esto

 LinkedHashSet link=new LinkedHashSet(); List listOfValues=new ArrayList(); listOfValues.add(link); 

Esta conversión será de gran ayuda cuando desee devolver una Lista, pero no un Conjunto.

Código:

 List duplicatList = new ArrayList(); duplicatList = Arrays.asList("AA","BB","CC","DD","DD","EE","AA","FF"); //above AA and DD are duplicate Set uniqueList = new HashSet(duplicatList); duplicatList = new ArrayList(uniqueList); //let GC will doing free memory System.out.println("Removed Duplicate : "+duplicatList); 

Nota: Definitivamente, habrá una sobrecarga de memoria.

 ArrayList city=new ArrayList(); city.add("rajkot"); city.add("gondal"); city.add("rajkot"); city.add("gova"); city.add("baroda"); city.add("morbi"); city.add("gova"); HashSet hashSet = new HashSet(); hashSet.addAll(city); city.clear(); city.addAll(hashSet); Toast.makeText(getActivity(),"" + city.toString(),Toast.LENGTH_SHORT).show(); 

LinkedHashSet hará el truco.

 String[] arr2 = {"5","1","2","3","3","4","1","2"}; Set set = new LinkedHashSet(Arrays.asList(arr2)); for(String s1 : set) System.out.println(s1); System.out.println( "------------------------" ); String[] arr3 = set.toArray(new String[0]); for(int i = 0; i < arr3.length; i++) System.out.println(arr3[i].toString()); 

// salida: 5,1,2,3,4

  List result = new ArrayList(); Set set = new LinkedHashSet(); String s = "ravi is a good!boy. But ravi is very nasty fellow."; StringTokenizer st = new StringTokenizer(s, " ,. ,!"); while (st.hasMoreTokens()) { result.add(st.nextToken()); } System.out.println(result); set.addAll(result); result.clear(); result.addAll(set); System.out.println(result); output: [ravi, is, a, good, boy, But, ravi, is, very, nasty, fellow] [ravi, is, a, good, boy, But, very, nasty, fellow] 

puedes usar un bucle nested en el siguiente:

 ArrayList l1 = new ArrayList(); ArrayList l2 = new ArrayList(); Iterator iterator1 = l1.iterator(); boolean repeated = false; while (iterator1.hasNext()) { Class1 c1 = (Class1) iterator1.next(); for (Class1 _c: l2) { if(_c.getId() == c1.getId()) repeated = true; } if(!repeated) l2.add(c1); } 

Si está utilizando el tipo de modelo List / ArrayList . Espero que te ayude


Aquí está mi código sin usar ninguna otra estructura de datos como set o hashmap

 for(int i = 0; i < Models.size(); i++) { for(int j = i + 1; j < Models.size(); j++) { if(Models.get(i).getName().equals(Models.get(j).getName())){ Models.remove(j); j--; } } } 

Como se dijo antes, debe usar una clase que implemente la interfaz Set en lugar de List para asegurarse de la unicidad de los elementos. Si tiene que mantener el orden de los elementos, se puede usar la interfaz SortedSet; la clase TreeSet implementa esa interfaz.

 for(int a=0;a 
 import java.util.*; class RemoveDupFrmString { public static void main(String[] args) { String s="appsc"; Set unique = new LinkedHashSet (); for(char c : s.toCharArray()) { System.out.println(unique.add(c)); } for(char dis:unique){ System.out.println(dis); } } } 
 public Set findDuplicates(List list) { Set items = new HashSet(); Set duplicates = new HashSet(); for (Object item : list) { if (items.contains(item)) { duplicates.add(item); } else { items.add(item); } } return duplicates; } 
  ArrayList list = new ArrayList(); HashSet unique = new LinkedHashSet(); HashSet dup = new LinkedHashSet(); boolean b = false; list.add("Hello"); list.add("Hello"); list.add("how"); list.add("are"); list.add("u"); list.add("u"); for(Iterator iterator= list.iterator();iterator.hasNext();) { String value = (String)iterator.next(); System.out.println(value); if(b==unique.add(value)) dup.add(value); else unique.add(value); } System.out.println(unique); System.out.println(dup); 

Si desea eliminar duplicados de ArrayList, busque la siguiente lógica:

 public static Object[] removeDuplicate(Object[] inputArray) { long startTime = System.nanoTime(); int totalSize = inputArray.length; Object[] resultArray = new Object[totalSize]; int newSize = 0; for(int i=0; i 

La solución @ jonathan-stafford está bien. Pero esto no conserva el orden de la lista.

Si desea conservar el orden de la lista, debe usar esto:

 public static  void removeDuplicate(List  list) { Set  set = new HashSet (); List  newList = new ArrayList (); for (Iterator iter = list.iterator(); iter.hasNext(); ) { Object element = iter.next(); if (set.add((T) element)) newList.add((T) element); } list.clear(); list.addAll(newList); } 

Solo para completar la respuesta. ¡Muy bien!