Rimozione di valori duplicati da ArrayList

Ho un Arraylist di String e ho aggiunto qualche valore duplicato in questo. e voglio solo rimuovere quel valore Duplicato Quindi come rimuoverlo.

Qui esempio ho ottenuto un’idea.

List list = new ArrayList(); list.add("Krishna"); list.add("Krishna"); list.add("Kishan"); list.add("Krishn"); list.add("Aryan"); list.add("Harm"); System.out.println("List"+list); for (int i = 1; i < list.size(); i++) { String a1 = list.get(i); String a2 = list.get(i-1); if (a1.equals(a2)) { list.remove(a1); } } System.out.println("List after short"+list); 

Ma esiste un modo sufficiente per rimuovere quella lista di moduli duplicati. senza usare il ciclo For? E posso farlo usando HashSet o in un altro modo, ma usando solo la lista di array. vorrei avere il tuo suggerimento per questo. grazie per la risposta in anticipo

È ansible creare un LinkedHashSet dall’elenco. Il LinkedHashSet conterrà ciascun elemento solo una volta e nello stesso ordine List . Quindi creare una nuova List da questo LinkedHashSet . In modo efficace, è un one-liner:

 list = new ArrayList(new LinkedHashSet(list)) 

Qualsiasi approccio che coinvolga List#contains o List#remove probabilmente ridurrà il tempo di esecuzione asintotico da O (n) (come nell’esempio precedente) a O (n ^ 2).


MODIFICA Per il requisito menzionato nel commento: Se vuoi rimuovere elementi duplicati, ma considera le stringhe come uguali ignorando il caso, allora potresti fare qualcosa del genere:

 Set toRetain = new TreeSet(String.CASE_INSENSITIVE_ORDER); toRetain.addAll(list); Set set = new LinkedHashSet(list); set.retainAll(new LinkedHashSet(toRetain)); list = new ArrayList(set); 

Avrà un tempo di esecuzione di O (n * logn), che è ancora migliore di molte altre opzioni. Si noti che questo sembra un po ‘più complicato di quanto dovrebbe essere: ho assunto che l’ ordine degli elementi nell’elenco non possa essere modificato. Se l’ordine degli elementi nell’elenco non ha importanza, puoi semplicemente farlo

 Set set = new TreeSet(String.CASE_INSENSITIVE_ORDER); set.addAll(list); list = new ArrayList(set); 

se vuoi usare solo arraylist, allora sono preoccupato che non esiste un modo migliore che creerà un enorme vantaggio in termini di prestazioni. Ma usando solo l’arraylist lo controllerei prima di aggiungerlo alla lista come segue

 void addToList(String s){ if(!yourList.contains(s)) yourList.add(s); } 

In questo caso l’uso di un Set è adatto.

Puoi utilizzare le utilità di Google Guava, come mostrato di seguito

  list = ImmutableSet.copyOf(list).asList(); 

Questo è probabilmente il modo più efficace per eliminare i duplicati dalla lista e, cosa interessante, mantiene anche l’ordine di ripetizione.

AGGIORNARE

Ma, nel caso in cui tu non voglia coinvolgere Guava, i duplicati possono essere rimossi come mostrato di seguito.

 ArrayList list = new ArrayList(); list.add("Krishna"); list.add("Krishna"); list.add("Kishan"); list.add("Krishn"); list.add("Aryan"); list.add("Harm"); System.out.println("List"+list); HashSet hs = new HashSet(); hs.addAll(list); list.clear(); list.addAll(hs); 

Ma, naturalmente, questo distruggerà l’ordine di iterazione degli elementi in ArrayList.

Shishir

Funzione streaming Java 8

Puoi usare la funzione distinta come sopra per ottenere gli elementi distinti della lista,

 stringList.stream().distinct(); 

Dalla documentazione,

Restituisce un stream costituito da elementi distinti (in base a Object.equals (Object)) di questo stream.


Un altro modo, se non si desidera utilizzare il metodo di uguale è utilizzando la funzione di raccolta come questo,

 stringList.stream() .collect(Collectors.toCollection(() -> new TreeSet((p1, p2) -> p1.compareTo(p2)) )); 

Dalla documentazione,

Esegue un’operazione di riduzione mutabile sugli elementi di questo stream utilizzando un servizio di raccolta.

Spero possa aiutare.

 List list = new ArrayList(); list.add("Krishna"); list.add("Krishna"); list.add("Kishan"); list.add("Krishn"); list.add("Aryan"); list.add("Harm"); HashSet hs=new HashSet<>(list); System.out.println("=========With Duplicate Element========"); System.out.println(list); System.out.println("=========Removed Duplicate Element========"); System.out.println(hs); 

Non penso che la list = new ArrayList(new LinkedHashSet(list)) non sia il modo migliore, visto che stiamo usando LinkedHashset (Potremmo usare direttamente LinkedHashset invece di ArrayList ),

Soluzione:

 import java.util.ArrayList; public class Arrays extends ArrayList{ @Override public boolean add(Object e) { if(!contains(e)){ return super.add(e); }else{ return false; } } public static void main(String[] args) { Arrays element=new Arrays(); element.add(1); element.add(2); element.add(2); element.add(3); System.out.println(element); } } 

Uscita: [1, 2, 3]

Qui sto estendendo ArrayList , dato che sto usando questo con alcune modifiche sovrascrivendo il metodo add .

Semplice funzione per rimuovere i duplicati dalla lista

 private void removeDuplicates(List list) { int count = list.size(); for (int i = 0; i < count; i++) { for (int j = i + 1; j < count; j++) { if (list.get(i).equals(list.get(j))) { list.remove(j--); count--; } } } } 

Esempio:
Input: [1, 2, 2, 3, 1, 3, 3, 2, 3, 1, 2, 3, 3, 4, 4, 4, 1]
Uscita: [1, 2, 3, 4]

Questo sarà il modo migliore

  List list = new ArrayList(); list.add("Krishna"); list.add("Krishna"); list.add("Kishan"); list.add("Krishn"); list.add("Aryan"); list.add("Harm"); Set set=new HashSet<>(list); 

È meglio usare HastSet

1-a) Un HashSet contiene un insieme di oggetti, ma in un modo che consente di determinare facilmente e rapidamente se un object è già presente nell’insieme o meno. Lo fa gestendo internamente un array e memorizzando l’object utilizzando un indice calcolato dall’hashcode dell’object. Dai un’occhiata qui

1-b) HashSet è una raccolta non ordinata contenente elementi unici. Ha le operazioni di raccolta standard Aggiungi, Rimuovi, Contiene, ma poiché utilizza un’implementazione basata su hash, queste operazioni sono O (1). (Al contrario di List, ad esempio, che è O (n) per Contains and Remove.) HashSet fornisce anche operazioni set standard come unione, intersezione e differenza simmetrica. Dai un’occhiata qui

2) Esistono diverse implementazioni di insiemi. Alcuni rendono le operazioni di inserimento e ricerca super veloci dagli elementi di hashing. Tuttavia ciò significa che l’ordine in cui sono stati aggiunti gli elementi è stato perso. Altre implementazioni preservano l’ordine aggiunto al costo di tempi di esecuzione più lenti.

La class HashSet in C # vale per il primo approccio, quindi non conserva l’ordine degli elementi. È molto più veloce di una lista normale. Alcuni benchmark di base hanno mostrato che HashSet è decentemente più veloce quando si tratta di tipi primari (int, double, bool, ecc.). È molto più veloce quando si lavora con oggetti di class. Quindi quel punto è che HashSet è veloce.

L’unica presa di HashSet è che non vi è alcun accesso da parte degli indici. Per accedere agli elementi è ansible utilizzare un enumeratore o utilizzare la funzione incorporata per convertire HashSet in un elenco e scorrere iterate. Fare clic qui

Senza un ciclo, No ! Poiché ArrayList è indicizzato per ordine anziché per chiave, non è ansible trovare l’elemento di destinazione senza eseguire iterare l’intera lista.

Una buona pratica di programmazione è scegliere una struttura dati adeguata per adattarsi al proprio scenario. Quindi, se Set adatta meglio al tuo scenario, la discussione sull’implementazione di List e il tentativo di trovare il modo più veloce di utilizzare una struttura dati impropria non ha senso.

  public List removeDuplicates(List list) { // Set set1 = new LinkedHashSet(list); Set set = new TreeSet(new Comparator() { @Override public int compare(Object o1, Object o2) { if(((Contact)o1).getId().equalsIgnoreCase(((Contact)2).getId()) ) { return 0; } return 1; } }); set.addAll(list); final List newList = new ArrayList(set); return newList; } 
 public static void main(String[] args) { @SuppressWarnings("serial") List lst = new ArrayList() { @Override public boolean add(Object e) { if(!contains(e)) return super.add(e); else return false; } }; lst.add("ABC"); lst.add("ABC"); lst.add("ABCD"); lst.add("ABCD"); lst.add("ABCE"); System.out.println(lst); } 

Questo è il modo migliore

list = list.stream().distinct().collect(Collectors.toList());
Questa potrebbe essere una delle soluzioni che utilizzano l’API Java8 Stream. Spero che questo ti aiuti.

Utilizzando java 8:

 public static  List removeDuplicates(List list) { return list.stream().collect(Collectors.toSet()).stream().collect(Collectors.toList()); } 

Nel caso in cui hai solo bisogno di rimuovere i duplicati usando solo ArrayList, nessun’altra class Collection, quindi: –

 //list is the original arraylist containing the duplicates as well List uniqueList = new ArrayList(); for(int i=0;i 

Spero che questo ti aiuti!

 private static void removeDuplicates(List list) { Collections.sort(list); int count = list.size(); for (int i = 0; i < count; i++) { if(i+1 
 public static List removeDuplicateElements(List array){ List temp = new ArrayList(); List count = new ArrayList(); for (int i=0; i0;i--) { array.remove(i); } return array; } }