Wie man prüft, ob eine Java-Sammlung Duplikate enthält

JavaJavaBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab lernen Sie, wie Sie effizient nach doppelten Elementen in einer Java-Sammlung suchen können. Wir werden die Verwendung von HashSet, einem leistungsstarken Werkzeug aus dem Java Collections Framework, untersuchen, um Duplikate zu identifizieren.

Durch praktische Schritte lernen Sie zunächst, wie Sie die Eigenschaft von HashSet, nur eindeutige Elemente zu enthalten, nutzen können, um Duplikate zu erkennen. Dann entdecken Sie eine alternative Methode, indem Sie die Größe der ursprünglichen Sammlung mit der eines daraus erstellten HashSet vergleichen. Schließlich werden wir untersuchen, wie Sie Null-Elemente behandeln können, wenn Sie nach Duplikaten suchen.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/DataStructuresGroup(["Data Structures"]) java(("Java")) -.-> java/ObjectOrientedandAdvancedConceptsGroup(["Object-Oriented and Advanced Concepts"]) java/DataStructuresGroup -.-> java/arrays("Arrays") java/DataStructuresGroup -.-> java/collections_methods("Collections Methods") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/arraylist("ArrayList") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/hashset("HashSet") subgraph Lab Skills java/arrays -.-> lab-559941{{"Wie man prüft, ob eine Java-Sammlung Duplikate enthält"}} java/collections_methods -.-> lab-559941{{"Wie man prüft, ob eine Java-Sammlung Duplikate enthält"}} java/arraylist -.-> lab-559941{{"Wie man prüft, ob eine Java-Sammlung Duplikate enthält"}} java/hashset -.-> lab-559941{{"Wie man prüft, ob eine Java-Sammlung Duplikate enthält"}} end

Verwendung von HashSet zur Duplikatprüfung

In diesem Schritt werden wir untersuchen, wie man in Java ein HashSet verwendet, um effizient nach doppelten Elementen in einer Sammlung zu suchen. HashSet ist Teil des Java Collections Frameworks und besonders nützlich, da es nur eindeutige Elemente speichert und sehr schnelle Suchvorgänge ermöglicht.

Zunächst erstellen wir eine neue Java-Datei namens DuplicateCheck.java in Ihrem ~/project-Verzeichnis. Sie können dies direkt im WebIDE-Dateiexplorer tun, indem Sie mit der rechten Maustaste in der Dateiliste klicken und "Neue Datei" auswählen, dann DuplicateCheck.java eingeben.

Öffnen Sie nun die Datei DuplicateCheck.java im Code-Editor und fügen Sie folgenden Code hinzu:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class DuplicateCheck {

    public static void main(String[] args) {
        // Create a list with some duplicate elements
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Alice"); // Duplicate
        names.add("Charlie");
        names.add("Bob"); // Duplicate

        System.out.println("Original List: " + names);

        // Use a HashSet to find duplicates
        Set<String> uniqueNames = new HashSet<>();
        Set<String> duplicates = new HashSet<>();

        for (String name : names) {
            if (!uniqueNames.add(name)) {
                // If add returns false, the element is already in the set
                duplicates.add(name);
            }
        }

        System.out.println("Duplicates found: " + duplicates);
    }
}

Lassen Sie uns die neuen Teile dieses Codes analysieren:

  • import java.util.ArrayList;, import java.util.HashSet;, import java.util.List;, import java.util.Set;: Diese Zeilen importieren die erforderlichen Klassen aus der Java-Utility-Bibliothek, um mit Listen und Sets zu arbeiten.
  • List<String> names = new ArrayList<>();: Dies erstellt eine List namens names, die String-Objekte enthalten kann. Wir verwenden ArrayList als spezifische Implementierung des List-Interfaces.
  • names.add(...): Dies fügt Elemente zur names-Liste hinzu. Beachten Sie, dass "Alice" und "Bob" zweimal hinzugefügt werden.
  • Set<String> uniqueNames = new HashSet<>();: Dies erstellt ein Set namens uniqueNames unter Verwendung der HashSet-Implementierung. Ein Set garantiert, dass es nur eindeutige Elemente enthält.
  • Set<String> duplicates = new HashSet<>();: Dies erstellt ein weiteres Set, um die gefundenen doppelten Elemente zu speichern.
  • for (String name : names): Dies ist eine for-each-Schleife, die durch jedes name-Element in der names-Liste iteriert.
  • if (!uniqueNames.add(name)): Die add()-Methode eines HashSet gibt true zurück, wenn das Element erfolgreich hinzugefügt wurde (d.h., es war noch nicht im Set enthalten), und false, wenn das Element bereits vorhanden war. Das ! negiert das Ergebnis, sodass der Code im if-Block nur ausgeführt wird, wenn add() false zurückgibt, was auf ein Duplikat hinweist.
  • duplicates.add(name);: Wenn ein Duplikat gefunden wird, fügen wir es unserem duplicates-Set hinzu.

Speichern Sie die Datei DuplicateCheck.java (Strg+S oder Cmd+S).

Öffnen Sie nun das Terminal unten im WebIDE. Stellen Sie sicher, dass Sie sich im ~/project-Verzeichnis befinden. Sie können dies bestätigen, indem Sie pwd eingeben und Enter drücken. Die Ausgabe sollte /home/labex/project sein.

Kompilieren Sie das Java-Programm mit dem javac-Befehl:

javac DuplicateCheck.java

Wenn keine Fehler auftreten, sollte keine Ausgabe angezeigt werden. Dies bedeutet, dass die Kompilierung erfolgreich war und eine DuplicateCheck.class-Datei im ~/project-Verzeichnis erstellt wurde. Sie können dies überprüfen, indem Sie den ls-Befehl ausführen.

Führen Sie schließlich das kompilierte Java-Programm mit dem java-Befehl aus:

java DuplicateCheck

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Original List: [Alice, Bob, Alice, Charlie, Bob]
Duplicates found: [Alice, Bob]

Die Reihenfolge der Elemente in der Ausgabe "Duplicates found" kann variieren, da HashSet die Einfügereihenfolge nicht beibehält.

Sie haben erfolgreich ein HashSet verwendet, um doppelte Elemente in einer Liste zu identifizieren!

Vergleich der Größen von Sammlung und Set

Im vorherigen Schritt haben wir ein HashSet verwendet, um doppelte Elemente zu finden. Ein wesentliches Merkmal eines Set ist, dass es nur eindeutige Elemente speichert. Das bedeutet, dass wenn Sie doppelte Elemente einem Set hinzufügen, nur eine Instanz jedes Elements beibehalten wird. Diese Eigenschaft ist sehr nützlich für Aufgaben wie das Entfernen von Duplikaten aus einer Liste.

In diesem Schritt werden wir unser DuplicateCheck.java-Programm ändern, um diese Eigenschaft zu demonstrieren, indem wir die Größe der ursprünglichen Liste (die Duplikate enthalten kann) mit der Größe eines aus dieser Liste erstellten HashSet (das nur eindeutige Elemente enthalten wird) vergleichen.

Öffnen Sie die Datei DuplicateCheck.java im WebIDE-Code-Editor.

Ändern Sie die main-Methode wie folgt:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class DuplicateCheck {

    public static void main(String[] args) {
        // Create a list with some duplicate elements
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Alice"); // Duplicate
        names.add("Charlie");
        names.add("Bob"); // Duplicate
        names.add("David");

        System.out.println("Original List: " + names);
        System.out.println("Size of Original List: " + names.size());

        // Create a HashSet from the list
        Set<String> uniqueNamesSet = new HashSet<>(names);

        System.out.println("Set created from List: " + uniqueNamesSet);
        System.out.println("Size of Set: " + uniqueNamesSet.size());

        // The difference in size tells us how many duplicates were removed
        int duplicatesCount = names.size() - uniqueNamesSet.size();
        System.out.println("Number of duplicates (excluding first occurrence): " + duplicatesCount);
    }
}

Hier ist, was wir hinzugefügt oder geändert haben:

  • Wir haben einen weiteren Namen, "David", zur names-Liste hinzugefügt, um eine etwas größere Liste zu haben.
  • System.out.println("Size of Original List: " + names.size());: Wir geben die Größe der ursprünglichen Liste mit der size()-Methode aus.
  • Set<String> uniqueNamesSet = new HashSet<>(names);: Dies ist eine bequeme Möglichkeit, ein HashSet direkt aus einer anderen Collection (wie unserer ArrayList) zu erstellen. Wenn Sie dies tun, fügt das HashSet automatisch alle Elemente aus der Liste hinzu, und da es ein Set ist, werden alle Duplikate verworfen.
  • System.out.println("Size of Set: " + uniqueNamesSet.size());: Wir geben die Größe des HashSet aus. Diese Größe repräsentiert die Anzahl der eindeutigen Elemente.
  • int duplicatesCount = names.size() - uniqueNamesSet.size();: Wir berechnen die Differenz zwischen der Listengröße und der Set-Größe. Diese Differenz zeigt uns, wie viele Elemente Duplikate waren (abgesehen von ihrer ersten Erscheinung).

Speichern Sie die geänderte Datei DuplicateCheck.java.

Jetzt kompilieren Sie das Programm erneut im Terminal:

javac DuplicateCheck.java

Wenn die Kompilierung erfolgreich ist, führen Sie das Programm aus:

java DuplicateCheck

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Original List: [Alice, Bob, Alice, Charlie, Bob, David]
Size of Original List: 6
Set created from List: [Alice, Bob, Charlie, David]
Size of Set: 4
Number of duplicates (excluding first occurrence): 2

Beachten Sie, dass die Größe der ursprünglichen Liste 6 beträgt, aber die Größe des daraus erstellten HashSet 4 ist. Die Differenz (6 - 4 = 2) zeigt korrekt an, dass es zwei doppelte Namen gab ("Alice" und "Bob" erschienen jeweils einmal nach ihrer ersten Erscheinung).

Dies zeigt, wie einfach Sie ein HashSet verwenden können, um die Anzahl der eindeutigen Elemente oder die Anzahl der Duplikate in einer Sammlung zu ermitteln.

Test mit Null-Elementen

In den vorherigen Schritten haben wir gesehen, wie HashSet doppelte Nicht-Null-Elemente behandelt. Jetzt wollen wir untersuchen, wie sich HashSet verhält, wenn wir versuchen, null-Elemente hinzuzufügen. Das Verständnis, wie Sammlungen null behandeln, ist wichtig, da es sonst manchmal zu unerwartetem Verhalten oder Fehlern führen kann, wenn dies nicht sorgfältig behandelt wird.

Ein HashSet erlaubt ein null-Element. Wenn Sie versuchen, null mehrmals hinzuzufügen, wird nur das erste null gespeichert.

Lassen Sie uns unser DuplicateCheck.java-Programm noch einmal ändern, um dies zu testen.

Öffnen Sie die Datei DuplicateCheck.java im WebIDE-Code-Editor.

Ändern Sie die main-Methode, um null-Werte in die Liste aufzunehmen:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class DuplicateCheck {

    public static void main(String[] args) {
        // Create a list with some duplicate and null elements
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add(null); // Add null
        names.add("Alice"); // Duplicate
        names.add("Charlie");
        names.add(null); // Add null again
        names.add("Bob"); // Duplicate
        names.add("David");
        names.add(null); // Add null a third time

        System.out.println("Original List: " + names);
        System.out.println("Size of Original List: " + names.size());

        // Create a HashSet from the list
        Set<String> uniqueNamesSet = new HashSet<>(names);

        System.out.println("Set created from List: " + uniqueNamesSet);
        System.out.println("Size of Set: " + uniqueNamesSet.size());

        // The difference in size tells us how many duplicates were removed
        // Note: This calculation is less straightforward with nulls and duplicates combined
        // int duplicatesCount = names.size() - uniqueNamesSet.size();
        // System.out.println("Number of duplicates (excluding first occurrence): " + duplicatesCount);
    }
}

Hier haben wir null mehrmals zur names-Liste hinzugefügt. Wir haben auch die Berechnung der Anzahl der Duplikate auskommentiert, da diese weniger sinnvoll wird, wenn null beteiligt ist und wir uns auf das Verhalten des Sets mit null konzentrieren.

Speichern Sie die geänderte Datei DuplicateCheck.java.

Kompilieren Sie das Programm im Terminal:

javac DuplicateCheck.java

Wenn die Kompilierung erfolgreich ist, führen Sie das Programm aus:

java DuplicateCheck

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Original List: [Alice, Bob, null, Alice, Charlie, null, Bob, David, null]
Size of Original List: 9
Set created from List: [null, Alice, Bob, Charlie, David]
Size of Set: 5

Beobachten Sie die Ausgabe:

  • Die Original List zeigt alle Elemente, einschließlich der mehreren null-Werte. Ihre Größe beträgt 9.
  • Das Set created from List enthält nur eindeutige Elemente. Beachten Sie, dass null nur einmal im Set erscheint, obwohl es mehrmals zur Liste hinzugefügt wurde. Die Größe des Sets beträgt 5 (Alice, Bob, Charlie, David und null).

Dies bestätigt, dass HashSet ein null-Element erlaubt und nachfolgende null-Hinzufügungen wie alle anderen Elemente als Duplikate behandelt.

Sie haben nun erfolgreich getestet, wie HashSet null-Elemente behandelt. Dies beendet unsere Untersuchung zur Verwendung von HashSet zur Duplikatprüfung und zum Verständnis seines Verhaltens mit eindeutigen und null-Elementen.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man effizient Duplikate in einer Java-Sammlung mithilfe eines HashSet prüft. Wir haben eine List mit doppelten Elementen erstellt und dann durch diese iteriert, indem wir jedes Element versucht haben, einem HashSet hinzuzufügen. Indem wir den Rückgabewert der add()-Methode überprüft haben, die false zurückgibt, wenn das Element bereits vorhanden ist, konnten wir die doppelten Elemente identifizieren und in ein separates HashSet sammeln. Diese Methode nutzt die Eigenschaft des HashSet, nur eindeutige Elemente zu speichern, sowie seine schnellen Suchfunktionen, um Duplikate effektiv zu erkennen.