Come rimuovo gli elementi ripetuti da ArrayList?

Question

Ho un ArrayList<String> e desidero rimuovere da esso stringhe ripetute. Come posso farlo?

Answer 1

Se non si desidera duplicati in Collection, è necessario considerare il motivo per cui si sta utilizzando un Set che consente i duplicati. Il modo più semplice per rimuovere elementi ripetuti è aggiungere il contenuto a un ArrayList (che non consentirà duplicati) e quindi aggiungere <=> di nuovo a <=>:

Set<String> set = new HashSet<>(yourList);
yourList.clear();
yourList.addAll(set);

Naturalmente, questo distrugge l'ordinamento degli elementi in <=>.

Answer 2

Sebbene la conversione di ArrayList in HashSet rimuova efficacemente i duplicati, se è necessario preservare l'ordine di inserzione, preferirei suggerire di utilizzare questa variante

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

Quindi, se è necessario recuperare un riferimento List, è possibile utilizzare nuovamente il costruttore di conversione.

Answer 3

In Java 8:

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

Nota che deve essere rispettato il contratto hashCode-uguale per i membri dell'elenco affinché il filtro funzioni correttamente.

Answer 4

Se non si desidera duplicati, utilizzare un Imposta invece di List. Per convertire un Set in <=> puoi usare il seguente codice:

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

Se veramente necessario, puoi usare la stessa costruzione per convertire un <=> in <=>.

Answer 5

Supponiamo di avere un elenco di String come:

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

Quindi possiamo rimuovere gli elementi duplicati in più modi.

Prima di Java 8

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

Nota: se vogliamo mantenere l'ordine di inserimento, dobbiamo usare LinkedHashSet al posto di HashSet

Uso di Guava

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

Uso di Java 8

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

Nota: nel caso in cui desideriamo raccogliere il risultato in una implementazione di un elenco specifico ad es. LinkedList quindi possiamo modificare l'esempio sopra come:

List<String> deDupStringList3 = strList.stream().distinct()
                 .collect(Collectors.toCollection(LinkedList::new));

Possiamo usare parallelStream anche nel codice sopra, ma potrebbe non dare benefici prestazionali previsti. Controlla questa domanda per ulteriori informazioni

Answer 6

Puoi anche farlo in questo modo e preservare l'ordine:

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

Answer 7

Ecco un modo che non influisce sull'ordinamento della tua 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 è l'elenco originale e l2 è l'elenco senza elementi ripetuti (Assicurati che YourClass abbia il metodo equals in base a ciò che vuoi rappresentare per l'uguaglianza)

Answer 8

I flussi Java 8 forniscono un modo molto semplice per rimuovere elementi duplicati da un elenco. Utilizzando il metodo distinto. Se abbiamo un elenco di città e vogliamo rimuovere i duplicati da tale elenco, è possibile farlo in una sola riga -

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

Come rimuovere i duplicati elementi di un arraylist

Answer 9

Vi è anche < code> ImmutableSet da Guava come opzione ( qui è la documentazione):

ImmutableSet.copyOf(list);

Answer 10

È possibile rimuovere i duplicati dall'arraylist senza utilizzare HashSet o un altro arraylist .

Prova questo codice ..

    ArrayList<String> lst = new ArrayList<String>();
    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);

L'output è

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

Answer 11

questo può risolvere il problema:

private List<SomeClass> clearListFromDuplicateFirstName(List<SomeClass> list1) {

     Map<String, SomeClass> cleanMap = new LinkedHashMap<String, SomeClass>();
     for (int i = 0; i < list1.size(); i++) {
         cleanMap.put(list1.get(i).getFirstName(), list1.get(i));
     }
     List<SomeClass> list = new ArrayList<SomeClass>(cleanMap.values());
     return list;
}

Answer 12

Probabilmente un po 'eccessivo, ma mi piace questo tipo di problema isolato. :)

Questo codice utilizza un set temporaneo (per il controllo dell'unicità) ma rimuove gli elementi direttamente all'interno dell'elenco originale. Poiché la rimozione di elementi all'interno di un ArrayList può indurre un'enorme quantità di copie degli array, il metodo remove (int) viene evitato.

public static <T> void removeDuplicates(ArrayList<T> list) {
    int size = list.size();
    int out = 0;
    {
        final Set<T> encountered = new HashSet<T>();
        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);
    }
}

Mentre ci siamo, ecco una versione per LinkedList (molto più bella!):

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

Utilizza l'interfaccia marker per presentare una soluzione unificata per List:

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

EDIT: immagino che la roba generica non aggiunga davvero alcun valore qui ... Oh bene. :)

Answer 13

public static void main(String[] args){
    ArrayList<Object> al = new ArrayList<Object>();
    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<al.size();i++){
        for(int j=i+1;j<al.size();j++){
            if(al.get(i).equals(al.get(j))){
                al.remove(j);
                j--;
            }
        }
    }
    System.out.println("After Removing duplicate:"+al);
}

Answer 14

Se sei disposto a utilizzare una libreria di terze parti, puoi utilizzare il metodo distinct () in Collezioni Eclipse (precedentemente GS Collezioni).

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

Il vantaggio di usare distinto () invece di convertirlo in un set e poi tornare in un elenco è che distinto () conserva l'ordine dell'elenco originale, mantenendo la prima occorrenza di ciascun elemento. È implementato utilizzando sia un set che un elenco.

MutableSet<T> 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 non riesci a convertire il tuo Elenco originale in un tipo di raccolte Eclipse, puoi utilizzare ListAdapter per ottenere la stessa API.

MutableList<Integer> distinct = ListAdapter.adapt(integers).distinct();

Nota: sono un committer per le raccolte Eclipse.

Answer 15

Queste tre righe di codice possono rimuovere l'elemento duplicato da ArrayList o da qualsiasi raccolta.

List<Entity> entities = repository.findByUserId(userId);

Set<Entity> s = new LinkedHashSet<Entity>(entities);
entities.clear();
entities.addAll(s);

Answer 16

Quando si riempie l'ArrayList, utilizzare una condizione per ciascun elemento. Ad esempio:

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

Otterremo un array {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Answer 17

Se vuoi conservare il tuo Ordine, allora è meglio usare LinkedHashSet . Perché se si desidera passare questo elenco a una query di inserimento mediante iterazione, l'ordine verrà conservato.

Prova questo

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

Questa conversione sarà molto utile quando si desidera restituire un Elenco ma non un Set.

Answer 18

Codice:

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

Nota: Sicuramente, ci sarà un sovraccarico di memoria.

Answer 19

ArrayList<String> city=new ArrayList<String>();
city.add("rajkot");
city.add("gondal");
city.add("rajkot");
city.add("gova");
city.add("baroda");
city.add("morbi");
city.add("gova");

HashSet<String> hashSet = new HashSet<String>();
hashSet.addAll(city);
city.clear();
city.addAll(hashSet);
Toast.makeText(getActivity(),"" + city.toString(),Toast.LENGTH_SHORT).show();

Answer 20

Se stai usando il tipo di modello Elenco < T > / ArrayList < T > . Spero ti sia d'aiuto.

---

Ecco il mio codice senza usare altre strutture di dati come 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--;
                            }
                        }
                    }

Answer 21

LinkedHashSet farà il trucco.

String[] arr2 = {"5","1","2","3","3","4","1","2"};
Set<String> set = new LinkedHashSet<String>(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

Answer 22

        List<String> result = new ArrayList<String>();
        Set<String> set = new LinkedHashSet<String>();
        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]

Answer 23

Questo è usato per il tuo elenco di oggetti personalizzati

   public List<Contact> removeDuplicates(List<Contact> 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) o2).getId()) /*&&
                    ((Contact)o1).getName().equalsIgnoreCase(((Contact)o2).getName())*/) {
                return 0;
            }
            return 1;
        }
    });
    set.addAll(list);

    final List newList = new ArrayList(set);
    return newList;
}

Answer 24

puoi usare il ciclo nidificato in follow:

ArrayList<Class1> l1 = new ArrayList<Class1>();
ArrayList<Class1> l2 = new ArrayList<Class1>();

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

Answer 25

Come detto prima, dovresti usare una classe che implementa l'interfaccia Set anziché List per essere sicuro dell'unicità degli elementi. Se è necessario mantenere l'ordine degli elementi, è possibile utilizzare l'interfaccia SortedSet; la classe TreeSet implementa tale interfaccia.

Answer 26

for(int a=0;a<myArray.size();a++){
        for(int b=a+1;b<myArray.size();b++){
            if(myArray.get(a).equalsIgnoreCase(myArray.get(b))){
                myArray.remove(b); 
                dups++;
                b--;
            }
        }
}

Answer 27

import java.util.*;
class RemoveDupFrmString
{
    public static void main(String[] args)
    {

        String s="appsc";

        Set<Character> unique = new LinkedHashSet<Character> ();

        for(char c : s.toCharArray()) {

            System.out.println(unique.add(c));
        }
        for(char dis:unique){
            System.out.println(dis);
        }


    }
}

Answer 28

public Set<Object> findDuplicates(List<Object> list) {
        Set<Object> items = new HashSet<Object>();
        Set<Object> duplicates = new HashSet<Object>();
        for (Object item : list) {
            if (items.contains(item)) {
                duplicates.add(item);
                } else { 
                    items.add(item);
                    } 
            } 
        return duplicates;
        }

Answer 29

    ArrayList<String> list = new ArrayList<String>();
    HashSet<String> unique = new LinkedHashSet<String>();
    HashSet<String> dup = new LinkedHashSet<String>();
    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);

Answer 30

Se vuoi rimuovere i duplicati da ArrayList significa trovare la logica di seguito,

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<totalSize; i++)
    {
        Object value = inputArray[i];
        if(value == null)
        {
            continue;
        }

        for(int j=i+1; j<totalSize; j++)
        {
            if(value.equals(inputArray[j]))
            {
                inputArray[j] = null;
            }
        }
        resultArray[newSize++] = value;
    }

    long endTime = System.nanoTime()-startTime;
    System.out.println("Total Time-B:"+endTime);
    return resultArray;
}