Como faço para remover elementos repetidos do ArrayList?

Eu tenho um ArrayList de Strings e desejo remover seqüências de caracteres repetidas dele. Como posso fazer isso?

Se você não quiser duplicatas em uma Collection , considere por que está usando uma Collection que permite duplicatas. A maneira mais fácil de remover elementos repetidos é adicionar o conteúdo a um Set (que não permitirá duplicatas) e, em seguida, adicionar o Set volta ao ArrayList :

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

Claro, isso destrói a ordenação dos elementos na ArrayList .

Embora a conversão do ArrayList para um HashSet elimine efetivamente duplicatas, se você precisar preservar a ordem de inserção, prefiro sugerir que você use essa variante

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

Então, se você precisar recuperar uma referência de List , poderá usar novamente o construtor de conversão.

No Java 8:

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

Observe que o contrato hashCode-equals para membros da lista deve ser respeitado para que a filtragem funcione corretamente.

Se você não quiser duplicatas, use um conjunto em vez de uma List . Para converter uma List em um Set você pode usar o seguinte código:

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

Se realmente necessário, você pode usar a mesma construção para converter um Set volta em uma List .

Suponha que tenhamos uma lista de String como:

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

Então, podemos remover elementos duplicados de várias maneiras.

Antes do Java 8

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

Usando Goiaba

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

Usando o Java 8

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

Nota: Se quisermos manter o pedido de inserção, precisamos usar o LinkedHashSet no lugar do HashSet .

Aqui está uma maneira que não afeta a ordem da sua 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 é a lista original, e l2 é a lista sem itens repetidos (Certifique-se de que YourClass tenha o método de igualdade de acordo com o que você deseja representar por igualdade)

Os streams do Java 8 fornecem uma maneira muito simples de remover elementos duplicados de uma lista. Usando o método distinto. Se temos uma lista de cidades e queremos remover duplicatas da lista, isso pode ser feito em uma única linha –

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

Como remover elementos duplicados de um arraylist

Há também o ImmutableSet da Goiaba como opção ( aqui está a documentação):

 ImmutableSet.copyOf(list); 

É possível remover duplicatas de arraylist sem usar HashSet ou mais um arraylist .

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

Saída é

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

Você também pode fazer isso e preservar a ordem:

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

Provavelmente um pouco exagerado, mas gosto desse tipo de problema isolado. 🙂

Esse código usa um conjunto temporário (para a verificação de exclusividade), mas remove elementos diretamente dentro da lista original. Como a remoção de elementos dentro de um ArrayList pode induzir uma enorme quantidade de cópias de array, o método remove (int) é evitado.

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

Enquanto estamos nisso, aqui está uma versão para LinkedList (muito melhor!):

 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 a interface do marcador para apresentar uma solução unificada para a lista:

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

EDIT: Eu acho que o material genérico realmente não adiciona qualquer valor aqui .. Oh bem. 🙂

isso pode resolver o 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 

Se você estiver disposto a usar uma biblioteca de terceiros, poderá usar o método distinct() no Eclipse Collections (anteriormente GS Collections).

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

A vantagem de usar distinct() invés de converter para um Set e depois de volta para uma List é que distinct() preserva a ordem da List original, mantendo a primeira ocorrência de cada elemento. É implementado usando um conjunto e uma 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; 

Se você não conseguir converter sua Lista original em um tipo Coleções do Eclipse, poderá usar o ListAdapter para obter a mesma API.

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

Nota: Eu sou um committer para collections do Eclipse.

Essas três linhas de código podem remover o elemento duplicado de ArrayList ou qualquer coleção.

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

Quando você estiver preenchendo o ArrayList, use uma condição para cada elemento. Por exemplo:

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

Receberemos uma matriz {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Se você quiser preservar seu pedido, é melhor usar o LinkedHashSet . Porque se você quiser passar esta lista para uma consulta de inserção por iteração, a ordem seria preservada.

Tente isso

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

Essa conversão será muito útil quando você quiser retornar uma lista, mas não um 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, haverá sobrecarga de memory.

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

O LinkedHashSet fará o truque.

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

// output: 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] 

você pode usar o loop nested em seguir:

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

Se você estiver usando o tipo de modelo List / ArrayList . Espero que te ajude.


Aqui está o meu código sem usar qualquer outra estrutura de dados como o conjunto ou 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 dito anteriormente, você deve usar uma class implementando a interface Set em vez de List para ter certeza da unicidade dos elementos. Se você tiver que manter a ordem dos elementos, a interface SortedSet poderá ser usada; a class TreeSet implementa essa interface.

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

Se você quiser remover duplicatas de ArrayList significa encontrar a lógica abaixo,

 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 

A solução @ jonathan-stafford está OK. Mas isso não preserva a ordem da lista.

Se você quiser preservar a ordem da lista, você deve usar isto:

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

É só para completar a resposta. Muito bom!