Java-Set

Set ist eine Schnittstelle im Java Collection Framework. Mit Java Set können Sie ungeordnete Sammlungen mit eindeutigen Elementen implementieren. In diesem Artikel werden wir uns diese Schnittstelle und ihre Implementierungen in der Java-Sprache sowie Methoden für die Arbeit mit einer Menge ansehen und auch einige Beispiele geben.

Was ist Java Set?

Set ist eine Schnittstelle aus dem Java Collection Framework, aber Set ist im Gegensatz zu List keine geordnete Sammlung . Das bedeutet, dass Java- Set- Elemente ohne eine bestimmte Reihenfolge aufbewahrt werden. Es gibt also keine Kontrolle über die Position, an der Sie ein Element einfügen können. Außerdem können Sie nicht über ihren Index auf Elemente zugreifen. Mathematisch gesehen ist ein Set eine Sammlung einzigartiger Elemente. Tatsächlich handelt es sich hierbei um eine ungeordnete Sammlung (ungeordnete Sammlung), in der keine identischen Elemente gespeichert werden können. Wenn Sie einem Set absichtlich ein doppeltes Element hinzufügen , wird diese Aktion ignoriert und das Set ändert sich nicht. Es ist jedoch zulässig, darin ein Nullelement zu speichern.

Legen Sie Implementierungen fest

Java Set ist eine Schnittstelle, daher müssen Sie eine ihrer Implementierungen verwenden, um Objekte zu erstellen. Dies sind HashSet , TreeSet und LinkedHashSet . In Set s wird jedes Element nur in einer Instanz gespeichert, und verschiedene Implementierungen von Set verwenden eine unterschiedliche Reihenfolge zum Speichern von Elementen. In einem HashSet wird die Reihenfolge der Elemente durch einen komplexen Algorithmus bestimmt. Wenn Ihnen die Speicherreihenfolge wichtig ist, verwenden Sie einen TreeSet- Container, der Objekte in aufsteigender Vergleichsreihenfolge sortiert speichert, oder ein LinkedHashSet, das Elemente in zusätzlicher Reihenfolge speichert. Sets werden häufig zum Testen der Mitgliedschaft verwendet, damit Sie leicht überprüfen können, ob ein Objekt zu einem bestimmten Set gehört. Daher wird in der Praxis normalerweise eine HashSet- Implementierung gewählt, die für eine schnelle Suche optimiert ist. HashSet ist eine Sammlung, die ihre von der hashCode() -Methode zurückgegebenen Hash-Werte verwendet, um Elemente intern zu speichern. Das heißt, innerhalb des HashSet<E> wird das HashMap<E, Object> -Objekt gespeichert, das die Werte des HashSet als Schlüssel speichert. Mithilfe von Hash-Codes können Sie Elemente schnell suchen, einem Set hinzufügen und daraus entfernen . LinkedHashSet ist ein HashSetdas auch Elemente in einer verknüpften Liste speichert. Ein normales HashSet behält die Reihenfolge der Elemente nicht bei. Erstens existiert es offiziell einfach nicht und zweitens kann sich sogar die innere Ordnung dramatisch ändern, wenn nur ein Element hinzugefügt wird. Und Sie können einen Iterator von LinkedHashSet erhalten und damit alle Elemente in der genauen Reihenfolge durchgehen, in der sie dem LinkedHashSet hinzugefügt wurden . Nicht oft, aber manchmal kann es sehr notwendig sein. Ein TreeSet ist eine Sammlung, die Elemente als nach Werten geordneter Baum speichert. Innerhalb des TreeSet<E> befindet sich eine TreeMap<E, Object> , die alle diese Werte speichert. Und diese TreeMapverwendet einen rot-schwarz ausgeglichenen Binärbaum zum Speichern von Elementen. Daher verfügt es über sehr schnelle Add()- , Remove()- und Includes()- Operationen.

Erstellen Sie ein Set-Objekt

Um ein Set- Objekt zu erstellen, können Sie eines der folgenden Formulare verwenden:

Set<Integer> intSet = new HashSet<>();
Set<String> vSet = new HashSet<>();
Set mySet = new LinkedHashSet();
HashSet<String> myHashset = new HashSet<>();

Hier ist ein einfaches Beispiel, in dem wir zwei Sets erstellen , HashSet und LinkedHashSet , und jeweils 5 Elemente hinzufügen. Hierfür können wir die Methode add() verwenden .

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

public class HashSetTest {
    public static void main(String[] args) {
        Set mySet = new HashSet();
        Set mySet2 = new LinkedHashSet();
//adding some string elements
        mySet.add("Stuart");
        mySet.add("Alex");
        mySet.add("Johnny");
        mySet.add("Igor");
        mySet.add("Bel");
        System.out.println(mySet);
        mySet2.add("Stuart");
        mySet2.add("Alex");
        mySet2.add("Johnny");
        mySet2.add("Igor");
        mySet2.add("Bel");
        System.out.println(mySet2);
    }
}

Hier ist die Ausgabe des Programms: Wie oben erwähnt, behält HashSet die Reihenfolge der Elemente nicht bei, LinkedHashSet hingegen schon. Es war LinkedHashSet , das uns die Elemente in der Reihenfolge lieferte, in der wir sie in das Set geschrieben hatten.

Java-Set-Methoden

Hier sind einige wichtige Methoden von Java Set :

• boolean add(E e) . Fügt das angegebene Element zur Menge hinzu, wenn es noch nicht vorhanden ist (optionaler Vorgang).

• boolescher Wert „remove(Object o)“ . Entfernt das angegebene Element aus dieser Menge, sofern es vorhanden ist (optionaler Vorgang).

• boolescher Wert RemoveAll(Collection c) . Entfernt aus dieser Menge alle Elemente, die in der angegebenen Sammlung enthalten sind (optionaler Vorgang).

• boolean retainAll(Collection c) . Behält nur die Elemente in diesem Satz, die in der angegebenen Sammlung enthalten sind (optionaler Vorgang).

• void clear() . Entfernt alle Elemente aus der Menge.

• Iterator iterator() . Gibt einen Iterator über die Elemente in dieser Menge zurück.

• int size() . Es wird verwendet, um die Anzahl der Elemente im Set zu ermitteln.

• boolean isEmpty() . um zu überprüfen, ob Set leer ist oder nicht.

• boolescher Wert enthält(Objekt o) . Gibt true zurück, wenn dieser Satz das angegebene Element enthält.

• Iterator iterator() . Gibt einen Iterator über die Elemente in dieser Menge zurück. Die Elemente werden in keiner bestimmten Reihenfolge zurückgegeben.

• Object[] toArray() . Gibt ein Array zurück, das alle Elemente in dieser Menge enthält. Wenn dieser Satz Garantien dafür gibt, in welcher Reihenfolge seine Elemente von seinem Iterator zurückgegeben werden, muss diese Methode die Elemente in derselben Reihenfolge zurückgeben.

Die Methoden ähneln denen von ArrayList , mit der Ausnahme, dass die Methode add(Object o) nur dann ein Objekt zur Menge hinzufügt, wenn es noch nicht vorhanden ist. Der Rückgabewert der Methode ist true, wenn das Objekt hinzugefügt wurde, andernfalls false. Es gibt auch einige Methoden, die von der Schnittstelle „Collection<>“ geerbt wurden : die Methoden „parallelStream()“ , „ removeIf()“ , „stream()“ und „forEach()“, die von der Schnittstelle „java.lang.Iterable“ geerbt wurden.

Beispiel für Java Set-Hauptoperationen

In diesem Beispiel erstellen wir ein Array von Zeichenfolgen und übergeben es dann mithilfe der Operation Arrays.asList an mySet . Dann entfernen wir ein paar weitere Elemente und fügen ein paar weitere hinzu. In diesem Fall ist eines der Elemente im Satz bereits vorhanden: Es wird nicht hinzugefügt. Wir werden auch die Operationen ausprobieren, bei denen die Leerheit überprüft wird isEmpty() , die Größe der Menge size() bestimmen und die Menge aller Elemente löschen clear() .

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class HashSetTest2 {
   public static void main(String[] args) {
       //creating a string Array with some names
       String [] friends =  {"Stuart", "Ivy", "Johnny", "Alex", "Igor", "Tanya"};
       //creating a new set and adding elements from string array into it
       Set<String> mySet = new HashSet<>(Arrays.asList(friends));
       System.out.println(mySet);
       //removing two elements from the set
       mySet.remove("Igor");
       mySet.remove("Stuart");

       System.out.println(mySet);

       //adding 2 new Elements into set
       mySet.add("Dasha");
       mySet.add("Alex"); //it's second Alex, can't be added
       System.out.println(mySet);
       //cheking the size of mySet
       int size = mySet.size();
       System.out.println("The quantity of set's elements = " + size);
       //Checking if the set is empty
       System.out.println("Is mySet empty? " + mySet.isEmpty());
       //checking if some elements are in set
       System.out.println("Is Igor in set? " + mySet.contains("Igor"));
       System.out.println("Is Johnny in set? "+ mySet.contains("Johnny"));
       //deleting all elements from the set
       mySet.clear();
       System.out.println("Is mySet empty now? " + mySet.isEmpty());

   }
}

Die Ausgabe des Programms ist hier:

Beispiel mit LinkedHashSet und auf Array gesetzt

Schreiben wir ein weiteres Programm. Darin erstellen wir einen Satz basierend auf LinkedHashSet , fügen ihm Elemente hinzu und konvertieren den Satz dann in ein Array.

import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;
   public class LinkedHashSet3 {
       public static void main(String[] args) {
           Set<String> set = new LinkedHashSet<>();
           set.add("C");
           set.add("D");
           set.add("E");
           set.add("F");
           set.add("G");
           set.add("A");
           set.add("B");
           System.out.println(set);
           set.remove("F");// removing an element from our set
           set.remove("C sharp");//trying to remove element that isn't in set
           System.out.println(set.remove("C sharp"));
           System.out.println("Print our set with elements removed: ");
           System.out.println(set);

//set to array
           String strArray[] = set.toArray(new String[set.size()]);
           System.out.println("New Array from set: ");
           System.out.println(Arrays.toString(strArray));
           System.out.println(strArray[0]);

       }
   }

Hier ist die Ausgabe des Programms:

Beispiel mit Iterator festlegen

Lassen Sie uns eine Menge erstellen, diese dann mit einem Iterator ausdrucken und dann alle geraden Zahlen daraus entfernen, ebenfalls mit einem Iterator.

import java.util.*;

public class SetTest5
{
   public static void main(String[] args)
   {

       Set<Integer> mySet = new HashSe<>();
       for(int i = 0; i < 10; i++)
           mySet.add(i);

       Iterator iterator = mySet.iterator();

       //simple iteration
       while(iterator.hasNext()){
           int i = (int) iterator.next();
       }
       System.out.println(" " + mySet);

       //modification of mySet using iterator - removing all even numbers
       iterator = mySet.iterator();
       while(iterator.hasNext()){
           int x = (int) iterator.next();
           if(x%2 == 0) iterator.remove();
       }
       System.out.println(mySet);

       }
}

Die Ausgabe des Programms ist hier:

Beispiel mit TreeSet

Wenn Ihnen das Sortieren wichtig ist, verwenden Sie die TreeSet- Implementierung. In diesem kurzen Beispiel füllen wir die Menge mit den Namen von Freunden, wie in den vorherigen Beispielen. In einem sortierten TreeSet werden die Elemente jedoch sofort in sortierter Reihenfolge geschrieben. In diesem Fall werden die Namen alphabetisch angezeigt.

import java.util.Set;
import java.util.TreeSet;
public class TreeSetTest {

   public static void main(String[] args) {

       Set mySet = new TreeSet<>();
       mySet.add("Stuart");
       mySet.add("Alex");
       mySet.add("Johnny");
       mySet.add("Igor");
       mySet.add("Bel");
       System.out.println(mySet);

   }

Die Ausgabe ist:

Kurze Schlussfolgerungen

• Die Java- Set- Schnittstelle ist Teil des Java Collections Framework.

• Implementierte Klassen: AbstractSet , ConcurrentHashMap.KeySetView , ConcurrentSkipListSet , CopyOnWriteArraySet , EnumSet , HashSet , JobStateReasons , LinkedHashSet , TreeSet .

• Die beliebtesten Set- Implementierungen sind HashSet , LinkedHashSet und TreeSet .

• Die Reihenfolge der HashSet- Elemente wird durch einen komplexen Algorithmus bestimmt. Wenn Ihnen die Speicherreihenfolge wichtig ist, verwenden Sie einen TreeSet- Container, der Objekte in aufsteigender Reihenfolge in der Vergleichsreihenfolge speichert, oder einen LinkedHashSet , der Elemente in zusätzlicher Reihenfolge speichert.

• Am häufigsten werden Sets zum Testen der Mitgliedschaft verwendet. Das heißt, es wird überprüft, ob ein Objekt im mathematischen Sinne zu einer gegebenen Menge gehört. Daher wird in der Praxis am häufigsten von allen Set- Implementierungen HashSet gewählt. Diese Implementierung ist für eine schnelle Suche optimiert.

• Sie können einem Set keine doppelten Elemente hinzufügen, daher können Sie Implementierungen der Set- Schnittstelle verwenden, um eindeutige Elemente zu speichern.

• Mit Set können Sie nur ein Nullelement hinzufügen.

• Set ist keine Liste und unterstützt keine Indizes oder Positionen seiner Elemente.