Wie entferne ich wiederholte Elemente aus ArrayList?

504

Ich habe eine ArrayList<String>, und ich möchte wiederholte Zeichenfolgen daraus entfernen. Wie kann ich das machen?

user25778
quelle

Antworten:

991

Wenn Sie keine Duplikate in a möchten Collection, sollten Sie überlegen, warum Sie ein CollectionDuplikat verwenden , das Duplikate zulässt. Der einfachste Weg, wiederholte Elemente zu entfernen, besteht darin, den Inhalt zu a hinzuzufügen Set(was keine Duplikate zulässt) und dann die SetRückseite zu ArrayList:

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

Dies zerstört natürlich die Reihenfolge der Elemente in der ArrayList.

Jonathan-Stafford
quelle
260
Siehe auch LinkedHashSet, wenn Sie die Bestellung behalten möchten.
Volley
3
@Chetan findet alle Duplikate von ArrayList in O (n), es ist wichtig, eine korrekt definierte Gleichheitsmethode für Objekte zu haben, die Sie in der Liste haben (kein Problem für Zahlen): 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; }
Ondrej Bozek
4
Eine gute Vorgehensweise wäre, Variablen mithilfe der Schnittstellentypen Listund Set(anstelle der Implementierungstypen ArrayListund HashSetwie in Ihrem Beispiel) zu definieren.
Jonik
33
Sie können dies bereinigen, indem Sie es verwenden, new HashSet(al)anstatt es zu leeren und aufzurufen addAll.
Asche999
1
Kann ich Regeln hinzufügen, um festzulegen, was für mich doppelt vorhanden ist? Zum Beispiel: Wenn mein ObjectWert mehrere Werte hat, wenn sich zwei davon wiederholen, betrachte ich sie als doppelt (andere Werte können unterschiedlich sein) und verwende Set?
Jean d'arme
290

Wenn Sie die Einfügereihenfolge beibehalten möchten, sollten Sie diese Variante verwenden, obwohl beim Konvertieren ArrayListin eine HashSetDuplikate effektiv entfernt werden

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

Wenn Sie dann eine ListReferenz zurückerhalten müssen , können Sie den Konvertierungskonstruktor erneut verwenden.

abahgat
quelle
10
Gibt LinkedHashSet eine Garantie dafür, welche von mehreren Duplikaten von der Liste gestrichen werden? Wenn beispielsweise Position 1, 3 und 5 Duplikate in der ursprünglichen Liste sind, können wir dann davon ausgehen, dass durch diesen Prozess 3 und 5 entfernt werden? Oder vielleicht 1 und 3 entfernen? Vielen Dank.
Matt Briançon
16
@ Matt: Ja, das garantiert es. In den Dokumenten heißt es: "Diese verknüpfte Liste definiert die Iterationsreihenfolge, dh die Reihenfolge, in der Elemente in die Menge eingefügt wurden (Einfügereihenfolge). Beachten Sie, dass die Einfügereihenfolge nicht beeinflusst wird, wenn ein Element erneut in die Menge eingefügt wird."
Abahgat
Sehr interessant. Ich habe hier eine andere Situation. Ich versuche nicht, String zu sortieren, sondern ein anderes Objekt namens AwardYearSource. Diese Klasse hat ein int-Attribut namens year. Daher möchte ich Duplikate basierend auf dem Jahr entfernen. Wenn also das Jahr 2010 mehr als einmal erwähnt wird, möchte ich dieses AwardYearSource-Objekt entfernen. Wie kann ich das machen?
WowBow
@WowBow Sie können beispielsweise ein Wrapper-Objekt definieren, das AwardYearSource enthält. Und definieren Sie diese Wrapper-Objekte als Methode, die auf dem Jahr des AwardYearSources-Jahres basiert. Dann können Sie Set mit diesen Wrapper-Objekten verwenden.
Ondrej Bozek
@ WowBow oder implementieren Comparable / Comparator
shrini1000
134

In Java 8:

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

Bitte beachten Sie, dass der hashCode-equals- Vertrag für Listenmitglieder eingehalten werden sollte, damit die Filterung ordnungsgemäß funktioniert.

Vitalii Fedorenko
quelle
1
Wie mache ich das für Groß- und Kleinschreibung?
StackFlowed
@StackFlowed Wenn Sie nicht brauchen , um die Reihenfolge der Liste erhalten Sie können addAllzu new TreeSet<String>(String.CASE_INSENSITIVE_ORDER). Das erste hinzugefügte Element bleibt im Set. Wenn Ihre Liste "Hund" und "Hund" (in dieser Reihenfolge) enthält, enthält die Liste TreeSet"Hund". Wenn die Reihenfolge erhalten bleiben muss, dann vor der Zeile in der Antwort setzen list.replaceAll(String::toUpperCase);.
Paul
1
Ich erhalte die folgende Fehlermeldung: Inkompatible Typen: Liste <Objekt> kann nicht in Liste <String> konvertiert werden
Samir
Dies ist im Allgemeinen eine einfache Lösung, aber wie entfernen Sie die Duplikate aus einer Arrayliste von int []?
Nooby Programmer
56

Angenommen, wir haben eine Liste von Stringwie:

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

Dann können wir doppelte Elemente auf verschiedene Arten entfernen.

Vor Java 8

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

Hinweis: Wenn wir die Einfügereihenfolge beibehalten möchten, müssen wir LinkedHashSetanstelle von verwendenHashSet

Guave benutzen

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

Verwenden von Java 8

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

Hinweis: Wenn wir das Ergebnis in einer bestimmten Listenimplementierung erfassen möchten, z. B. LinkedListkönnen wir das obige Beispiel wie folgt ändern:

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

Wir können parallelStreamden obigen Code auch verwenden, er bietet jedoch möglicherweise keine erwarteten Leistungsvorteile. Überprüfen Sie diese Frage für mehr.

akhil_mittal
quelle
Yah, als ich meine vorherigen Kommentare getippt habe, war ich in einem Eindruck, der parallel streamsimmer eine bessere Leistung bringen wird. Aber es ist ein Mythos. Ich habe später erfahren, dass es bestimmte Szenarien gibt, in denen parallele Streams verwendet werden sollten. In diesem Szenario bieten parallele Streams keine bessere Leistung. und ja, parallele Streams liefern in einigen Fällen möglicherweise nicht die gewünschten Ergebnisse. List<String> deDupStringList3 = stringList.stream().map(String::toLowerCase).distinct().collect(Collectors.toList());sollte in diesem Fall die geeignete Lösung sein
Diablo
53

Wenn Sie keine Duplikate möchten, verwenden Sie ein Set anstelle von a List. Um a Listin a umzuwandeln , Setkönnen Sie den folgenden Code verwenden:

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

Wenn es wirklich nötig ist, können Sie dieselbe Konstruktion verwenden, um einen SetRücken in einen umzuwandeln List.

Benno Richters
quelle
In ähnlicher Weise habe ich am Ende des Threads eine Antwort gegeben, in der ich Set for Custom Object verwende. In einem Fall, in dem jemand ein benutzerdefiniertes Objekt wie "Kontakt" oder "Schüler" hat, kann diese Antwort verwendet werden, die für mich gut funktioniert.
Muhammad Adil
Das Problem tritt auf, wenn Sie speziell auf ein Element zugreifen müssen. Wenn Sie beispielsweise ein Objekt an eine Listenelementansicht in Android binden, erhalten Sie dessen Index. So Setkann hier nicht verwendet werden.
TheRealChx101
Wie kann ich das angehen, wenn die Liste eine Objektliste ist
jvargas
28

Sie können dies auch auf diese Weise tun und die Ordnung bewahren:

// delete duplicates (if any) from 'myArrayList'
myArrayList = new ArrayList<String>(new LinkedHashSet<String>(myArrayList));
Nenad Bulatovic
quelle
Ich denke, dies ist der beste Weg, um Duplikate in einer ArrayList zu entfernen. Auf jeden Fall zu empfehlen. Vielen Dank an @Nenad für die Antwort.
ByWaleed
25

Java 8-Streams bieten eine sehr einfache Möglichkeit, doppelte Elemente aus einer Liste zu entfernen. Mit der eindeutigen Methode. Wenn wir eine Liste von Städten haben und Duplikate aus dieser Liste entfernen möchten, kann dies in einer einzigen Zeile erfolgen -

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

So entfernen Sie doppelte Elemente aus einer Arrayliste

infoj
quelle
25

Hier ist ein Weg, der Ihre Listenreihenfolge nicht beeinflusst:

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, dass YourClass die Methode equals hat, je nachdem, was Sie für Gleichheit stehen möchten.)

stbn
quelle
Dieser Antwort fehlen zwei Dinge: 1) Es werden keine Generika verwendet, sondern Rohtypen ( ArrayList<T>sollten anstelle von verwendet werden ArrayList). 2) Das explizite Erstellen von Iteratoren kann durch Verwendung von a vermieden werden for (T current : l1) { ... }. Auch wenn Sie eine Iteratorexplizit verwenden wollten , iteradorist falsch geschrieben.
RAnders00
4
Diese Implementierung wird in quadratischer Zeit ausgeführt, verglichen mit der Implementierung der verknüpften Hash-Menge, die in linearer Zeit ausgeführt wird. (dh dies dauert 10-mal länger auf einer Liste mit 10 Elementen, 10.000-mal länger auf einer Liste mit 10.000 Elementen. Die JDK 6-Implementierung für ArrayList.contains , JDK8 impl ist dieselbe.)
Patrick M
21

Es ist möglich, Duplikate aus der Arrayliste zu entfernen, ohne HashSet oder eine weitere Arrayliste zu verwenden .

Versuchen Sie diesen Code ..

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

Ausgabe ist

Duplicates List [ABC, ABC, ABCD, ABCD, ABCE]
Distinct List [ABC, ABCD, ABCE]
CarlJohn
quelle
Es ist langsam und Sie erhalten möglicherweise eine ConcurrentModificationException.
Maaartinus
@maaartinus Hast du diesen Code ausprobiert? Es werden keine Ausnahmen erzeugt. Außerdem ist es ziemlich schnell. Ich habe den Code vor dem Posten ausprobiert.
CarlJohn
4
Sie haben Recht, es passiert nicht, wenn Sie das Array anstelle der Liste iterieren. Es ist jedoch höllisch langsam. Versuchen Sie es mit ein paar Millionen Elementen. Vergleichen Sie es mit ImmutableSet.copyOf(lst).toList().
Maaartinus
beantwortet die Frage, die mir im Interview gestellt wurde. So entfernen Sie wiederholte Werte aus einer ArrayList, ohne Sets zu verwenden. Vielen Dank
Aniket Paul
Intern indexOfiteriert die lstVerwendung einer for-Schleife.
Patrick M
21

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

ImmutableSet.copyOf(list);
Timofey Gorshkov
quelle
1
Beachten Sie, dass es eine ImmutableSet.asList()Methode gibt, die eine ImmutableListzurückgibt, wenn Sie sie als benötigen List.
Andy Turner
19

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;
}
user2868724
quelle
1
Diese Lösung hat mir besser gefallen.
Tushar Gogna
12

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

Dieser Code verwendet einen temporären Satz (für die Eindeutigkeitsprüfung), entfernt jedoch Elemente direkt in der ursprünglichen Liste. Da das Entfernen von Elementen in einer ArrayList eine große Menge an Array-Kopieren verursachen kann, wird die Methode remove (int) 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();
        }
    }
}

Verwenden Sie die Markierungsschnittstelle, um eine einheitliche Lösung für List zu 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-Zeug bringt hier keinen wirklichen Mehrwert. Na ja. :) :)

Volley
quelle
1
Warum ArrayList im Parameter verwenden? Warum nicht einfach auflisten? Wird das nicht funktionieren?
Shervin Asgari
Eine Liste funktioniert absolut als In-Parameter für die erste aufgeführte Methode. Die Methode ist jedoch für die Verwendung mit einer Direktzugriffsliste wie ArrayList optimiert. Wenn also stattdessen eine LinkedList übergeben wird, erhalten Sie eine schlechte Leistung. Das Festlegen des n: ten Elements in einer LinkedList dauert beispielsweise O (n), während das Festlegen des n: ten Elements in einer Direktzugriffsliste (z. B. ArrayList) O (1) Zeit benötigt. Auch dies ist wahrscheinlich übertrieben ... Wenn Sie diese Art von spezialisiertem Code benötigen, befindet er sich hoffentlich in einer isolierten Situation.
Volley
10
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);
}
Manash Ranjan Dakua
quelle
Diese Implementierung gibt kein Element in der Liste wegen des letzten j--
neo7
1
Diese Implementierungsarbeit ist sehr gut. Es gibt kein Problem dahinter und für diese Aufgabe verwende ich nur eine Arrayliste. Daher ist diese Antwort völlig gut. Bevor Sie negatives Feedback geben, sollten Sie auch einen Testfall hinzufügen, damit jeder das Ergebnis verstehen kann. Danke Manash
Manash Ranjan Dakua
5

Wenn Sie bereit sind, eine Bibliothek eines Drittanbieters zu verwenden, können Sie die Methode distinct()in Eclipse Collections (ehemals GS Collections) verwenden.

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

Der Vorteil der Verwendung distinct()anstelle der Konvertierung in eine Menge und dann zurück in eine Liste besteht darin, dass distinct()die Reihenfolge der ursprünglichen Liste beibehalten wird und das erste Vorkommen jedes Elements beibehalten wird. Es wird mithilfe eines Sets und einer Liste implementiert.

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 Ihre ursprüngliche Liste nicht in einen Eclipse-Sammlungstyp konvertieren können, können Sie ListAdapter verwenden, um dieselbe API abzurufen.

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

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

Craig P. Motlin
quelle
3

Diese drei Codezeilen können das duplizierte Element aus ArrayList oder einer beliebigen Sammlung entfernen.

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

Set<Entity> s = new LinkedHashSet<Entity>(entities);
entities.clear();
entities.addAll(s);
M Kaweepatt Churcharoen
quelle
2

Verwenden Sie beim Füllen der ArrayList eine Bedingung für jedes Element. 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 erhalten ein Array {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Harpyie
quelle
2

Wenn Sie Ihre Bestellung erhalten möchten, verwenden Sie am besten LinkedHashSet . Wenn Sie diese Liste durch Iterieren an eine Einfügeabfrage übergeben möchten, bleibt die Reihenfolge erhalten.

Versuche dies

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

Diese Konvertierung ist sehr hilfreich, wenn Sie eine Liste, aber keinen Satz zurückgeben möchten.

RAM
quelle
2

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 entsteht Speicheraufwand.

Sambhu
quelle
2
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();
Hardip
quelle
1

LinkedHashSet erledigt 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

user1912383
quelle
1
        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]
Siva
quelle
1

Dies wird für Ihre Liste der benutzerdefinierten Objekte verwendet

   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;
}
Gujjula Ramesh Reddy
quelle
1

Sie können die verschachtelte Schleife wie folgt 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);
        }
HamidReza
quelle
1

Wie bereits erwähnt, sollten Sie anstelle von List eine Klasse verwenden, die die Set-Schnittstelle implementiert, um die Einheitlichkeit der Elemente zu gewährleisten. Wenn Sie die Reihenfolge der Elemente beibehalten müssen, kann die SortedSet-Schnittstelle verwendet werden. Die TreeSet-Klasse implementiert diese Schnittstelle.

Vinze
quelle
1

Wenn Sie den Modelltyp List <T> / ArrayList <T> verwenden. Hoffe, es hilft dir.

Hier ist mein Code ohne Verwendung einer anderen Datenstruktur wie Set oder 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--;
  }
 }
}
Saurabh Gaddelpalliwar
quelle
0
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--;
            }
        }
}
Ghyour
quelle
0
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);
        }


    }
}
reddy
quelle
0
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;
        }
Harsha
quelle
0
    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);
SparkOn
quelle
0

Wenn Sie Duplikate aus ArrayList entfernen möchten, finden Sie die folgende 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;
}
Thananjayan N.
quelle
1
Warum sollten Sie eine quadratische Lösung für eine Frage veröffentlichen, die bereits 2 Jahre alte lineare und logarithmische lineare Lösungen enthält, die auch einfacher sind?
Abarnert