Jak usunąć powtarzające się elementy z ArrayList?

Chociaż Konwersja ArrayList na HashSet skutecznie usuwa duplikaty, jeśli chcesz zachować kolejność wstawiania, sugeruję użycie tego wariantu

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

Następnie, jeśli chcesz odzyskać referencję List, możesz ponownie użyć konstruktora konwersji.

W Javie 8:

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

Należy pamiętać, że kontrakt hashCode-equals dla członków listy powinien być przestrzegany, aby filtrowanie działało prawidłowo.

Załóżmy, że mamy listę String Jak:

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

Następnie możemy usunąć duplikaty elementów na wiele sposobów.

Przed Java 8

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

Uwaga: Jeśli chcemy utrzymać zamówienie reklamowe, musimy użyć LinkedHashSet zamiast HashSet

Używanie Guawy

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

Używanie Javy 8

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

Uwaga: w przypadku, gdy chcemy zebrać wynik w konkretnej implementacji listy np. LinkedList możemy zmodyfikować powyższe przykład jako:

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

Możemy użyć parallelStream również w powyższym kodzie, ale może to nie dać oczekiwanych korzyści performace. Sprawdź to pytanie aby dowiedzieć się więcej.

Jeśli nie chcesz duplikatów, użyj zestawu zamiast List. Aby przekonwertować List na Set możesz użyć następującego kodu:

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

Jeśli naprawdę jest to konieczne, możesz użyć tej samej konstrukcji, aby przekształcić Set z powrotem w List.

Możesz również zrobić to w ten sposób i zachować porządek:

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

Strumienie Java 8 zapewniają bardzo prosty sposób usuwania zduplikowanych elementów z listy. Za pomocą odrębnej metody. Jeśli mamy listę miast i chcemy usunąć duplikaty z tej listy, można to zrobić w jednej linii -

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

Jak usunąć zduplikowane elementy z arraylist

Oto sposób, który nie wpływa na kolejność listy:

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 jest listą oryginalną, a l2 listą bez powtarzających się elementów (Upewnij się, że YourClass ma metodę equals zgodnie z tym, co ma oznaczać równość)

Możliwe jest usunięcie duplikatów z arraylist bez użycia HashSet lub jeszcze jednej arraylist.

Spróbuj tego kodu..

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

Wyjście to

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

Jest też ImmutableSet z Guava jako opcja (TUTAJ jest dokumentacja):

ImmutableSet.copyOf(list);

To może rozwiązać problem:

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

Prawdopodobnie trochę przesada, ale lubię tego rodzaju odosobniony problem. :)

Ten kod używa tymczasowego zestawu (do sprawdzania unikalności), ale usuwa elementy bezpośrednio wewnątrz oryginalnej listy. Ponieważ usuwanie elementów wewnątrz ArrayList może wywołać ogromną ilość kopiowania tablic, metoda remove(int) jest unikana.

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

Skoro już o tym mowa, oto wersja LinkedList (o wiele ładniejsza!):

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

Użyj interfejsu znacznika, aby przedstawić zunifikowane rozwiązanie dla Lista:

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

EDIT: myślę, że rzeczy generyczne nie dodają tu żadnej wartości.. No cóż. :)

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

Jeśli chcesz użyć biblioteki innej firmy, możesz użyć metody distinct() w kolekcjach Eclipse (dawniej kolekcjach GS).

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

Zaletą użycia distinct() zamiast konwersji do zbioru i powrotu do listy jest to, że distinct() zachowuje kolejność oryginalnej listy, zachowując pierwsze wystąpienie każdego elementu. Jest zaimplementowany przy użyciu zarówno zestawu, jak i listy.

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;

Jeśli nie możesz przekonwertować oryginalnej listy na typ kolekcji Eclipse, możesz można użyć ListAdapter, aby uzyskać ten sam API.

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

Notatka: jestem committerem Dla Kolekcji Eclipse.

Jeśli chcesz zachować swoje zamówienie, najlepiej użyć LinkedHashSet. Ponieważ jeśli chcesz przekazać tę listę do zapytania Insert poprzez iterację, kolejność zostanie zachowana.

Spróbuj tego

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

Ta konwersja będzie bardzo pomocna, gdy chcesz zwrócić listę, ale nie Zestaw.

Te trzy linie kodu mogą usunąć powielony element z ArrayList lub dowolnej kolekcji.

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

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

Podczas wypełniania ArrayList, użyj warunku dla każdego elementu. Na przykład:

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

Otrzymamy tablicę {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Kod:

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

Uwaga: na pewno będzie pamięć nad głową.

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

Jeśli używasz listy typów modelu / ArrayList. Hope, to ci pomoże.

Oto Mój kod bez użycia innej struktury danych jak set lub 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--;
  }
 }
}

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

LinkedHashSet załatwi sprawę.

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

/ / wyjście: 5,1,2,3,4

        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]

To jest używane dla Twojej listy obiektów

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

Możesz użyć zagnieżdżonej pętli w 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);
        }

Jak wspomniano wcześniej, powinieneś użyć klasy implementującej interfejs Set zamiast List, aby mieć pewność co do uniczności elementów. Jeśli trzeba zachować kolejność elementów, można użyć interfejsu SortedSet; Klasa TreeSet implementuje ten interfejs.

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


    }
}

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

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

Jeśli chcesz usunąć duplikaty z ArrayList oznacza znajdź poniższą logikę,

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