Wie kann ich wiederholte Elemente aus Arraylist entfernen?

Question

Ich habe eine ArrayList<String>, und ich möchte wiederholt Strings von ihm entfernen. Wie kann ich das tun?

Answer 1

Wenn Sie nicht in einem Collection Duplikate wollen, sollten Sie darüber nachdenken, warum Sie eine Collection verwenden, die Duplikate erlaubt. Der einfachste Weg, sich wiederholende Elemente zu entfernen, ist der Inhalt zu einem Set hinzuzufügen (die Duplikate werden nicht zulassen) und dann die Set zum ArrayList hinzufügen zurück:

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

Natürlich ist dies zerstört die Reihenfolge der Elemente in der ArrayList.

Answer 2

Obwohl Umwandlung des ArrayList auf einen HashSet effektiv Duplikate entfernt, wenn Sie benötigen Auftrag zu erhalten, würde ich eher empfehlen Ihnen, diese Variante zu verwenden,

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

Wenn Sie dann einen List Bezug zurück zu bekommen, dann können Sie den Konvertierungskonstruktor wieder verwenden.

Answer 3

In Java 8:

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

Bitte beachten Sie, dass die hashCode-ist gleich für die Filterung respektiert richtig sein sollte Vertrag für Listenmitglieder zu arbeiten.

Answer 4

Wenn Sie Duplikate nicht wollen, verwenden Sie einen Set anstelle eines List. Um eine List zu einem Set konvertieren Sie den folgenden Code verwenden:

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

Wenn wirklich nötig können Sie den gleichen Aufbau verwenden, um einen Set zurück in eine List zu konvertieren.

Answer 5

Angenommen, wir eine Liste von String haben wie:

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

Dann können wir doppelte Elemente in vielfältiger Weise entfernen.

Vor Java 8

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

Hinweis: Wenn wir den Anzeigenauftrag erhalten wollen, dann müssen wir LinkedHashSet anstelle von HashSet verwenden

Mit Guava

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

Mit Java 8

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

Hinweis: Im Fall, dass wir das Ergebnis in einer spezifischen Liste Implementierung zum Beispiel sammeln

: LinkedList dann können wir das obige Beispiel als modifizieren

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

Wir können parallelStream auch in dem obigen Code verwenden, aber es kann nicht zu erwarten Performace Vorteile. Sehen Sie sich diese Frage für mehr.

Answer 6

Sie können auch tun es auf diese Weise, und zu erhalten, um:

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

Answer 7

Hier ist ein Weg, der nicht wirkt sich Ihre Liste Reihenfolge:

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 ist die ursprüngliche Liste, und l2 ist die Liste ohne wiederholte Elemente (Stellen Sie sicher, Yourclass die Methode equals hat nach dem, was Sie für die Gleichstellung stehen wollen)

Answer 8

Java 8-Streams bietet eine sehr einfache Art und Weise doppelte Elemente aus einer Liste zu entfernen. Mit der deutlichen Methode. Wenn wir eine Liste der Städte, und wir wollen Duplikate entfernen aus dieser Liste kann in einer einzigen Zeile durchgeführt werden -

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

Wie entfernen doppelte Elemente aus einer Arraylist

Answer 9

Es gibt auch ImmutableSet von Guava als Option ( hier ist die Dokumentation):

ImmutableSet.copyOf(list);

Answer 10

Es ist möglich, Duplikate von Arraylist zu entfernen, ohne die Verwendung von HashSet oder einer weiteren Arraylist .

Mit diesem Code Versuche ..

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

Die Ausgabe ist

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

Answer 11

Dies kann das Problem lösen:

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

Wahrscheinlich ein bisschen übertrieben, aber ich genieße diese Art von isoliertem Problem. :)

Dieser Code verwendet eine temporäre Set (für die Einzigartigkeit Prüfung), sondern Elemente direkt in der ursprünglichen Liste entfernt. Da das Element Entfernung innerhalb eines Array eine große Menge an Kopier Array induzieren kann, wird die remove (int) -Methode vermieden.

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

Während wir gerade dabei sind, ist hier eine Version für LinkedList (viel schöner!):

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

Mit der Marker-Schnittstelle eine einheitliche Lösung für die Liste präsentieren:

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

EDIT: Ich denke, das Generika-Material addiere nicht wirklich irgendeinen Wert hier .. Oh gut. :)

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

Wenn Sie bereit sind, eine Drittanbieter-Bibliothek zu verwenden, können Sie die Methode distinct() in Eclipse-Sammlungen verwenden (vormals GS Sammlungen).

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

Der Vorteil von distinct(), statt eine Reihe von Umwandlung und dann zurück in eine Liste ist, dass distinct() die Reihenfolge der ursprünglichen Liste bewahrt, das erste Vorkommen jedes Elements beibehalten wird. Es ist implementiert, indem sowohl ein Set und eine Liste mit.

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;

Wenn Sie nicht Ihre ursprüngliche Liste in einer Eclipse-Kollektionen Typ konvertieren kann, können Sie ListAdapter verwenden die gleiche API zu erhalten.

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

. Hinweis: Ich bin ein Committer für Eclipse Sammlungen

Answer 15

Diese drei Zeilen Code können das duplizierte Element von Arraylist oder einer Sammlung entfernen.

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

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

Answer 16

Wenn Sie die Arraylist füllen, für jedes Element eine Bedingung verwenden. Zum Beispiel:

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

Wir werden ein Array erhalten {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Answer 17

Wenn Sie Ihren Auftrag erhalten wollen, dann ist es am besten zu nutzen LinkedHashSet . Denn wenn Sie diese Liste auf eine INSERT-Abfrage übergeben wollen durch Iterieren sie würde die Reihenfolge beibehalten werden.

Versuchen Sie, diese

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

Diese Umwandlung wird sehr hilfreich sein, wenn Sie eine Liste zurückkehren mögen, aber keinen Satz.

Answer 18

Code:

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

. Hinweis: Auf jeden Fall wird es Speicher-Overhead sein

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

Wenn Sie Modelltyp Liste verwenden / Arraylist . Hoffe, es ist Ihnen helfen.

---

Hier ist mein Code ohne andere Datenstruktur wie Set oder hashmap mit

  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 den Trick.

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

// Ausgabe: 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

Dies wird verwendet für Ihre benutzerdefinierten Objekte Liste

   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

Sie können verschachtelte Schleife in Folge verwenden:

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

Wie bereits erwähnt, sollten Sie eine Klasse verwenden, um die Set-Schnittstelle statt Liste Umsetzung der Einzigkeit von Elementen sicher sein. Wenn Sie die Reihenfolge der Elemente zu halten, kann der SortedSet Schnittstelle dann verwendet werden; die TreeSet Klasse implementiert diese Schnittstelle.

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

Wenn Sie möchten, um Duplikate entfernen von Arraylist bedeutet die unten stehende Logik finden,

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