Kaffeepause Nr. 185. Ein umfassender Leitfaden zum Java Collection Framework

Quelle: Medium Dieses Tutorial wird Ihnen helfen, die Funktionsweise der verschiedenen im Java Collection Framework enthaltenen Klassen und Schnittstellen besser zu verstehen. Java Collection ist ein Framework, das eine einheitliche Architektur zum Speichern und Verwalten einer Gruppe von Objekten bereitstellt. Im Kern handelt es sich um eine Reihe von Klassen und Schnittstellen, die eine Standardmethode zur Darstellung und Bearbeitung von Objektsammlungen in der Java-Sprache bieten. Das Framework hilft auch bei der Implementierung häufig verwendeter Datenstrukturen wie List, Set und Map. Das Java Collection Framework umfasst mehrere Schnittstellen und Klassen. Hier ist eine Liste einiger davon:

Schnittstellen

Schnittstellen im Java Collection Framework definieren das allgemeine Verhalten und die Vorgänge, die für Sammlungen ausgeführt werden können. Dazu gehören das Hinzufügen oder Entfernen von Elementen, das Wiederholen von Elementen in einer Sammlung und mehr.

• Sammlung : Die Stammschnittstelle in einer Sammlungshierarchie, die eine Gruppe von Objekten darstellt, die als Elemente bezeichnet werden.
• Liste : Eine geordnete Sammlung von Elementen, die eine Duplizierung ermöglicht.
• Set : eine Sammlung von Elementen, die keine Duplizierung zulassen.
• Karte : eine Sammlung von Schlüssel-Wert-Paaren, wobei jeder Schlüssel eindeutig ist.
• Warteschlange : Eine Warteschlange ist eine Datenstruktur, die zum Speichern von Elementen im First-In-First-Out (FIFO) verwendet wird.

Diese Liste umfasst nicht alles, sondern nur die am häufigsten verwendeten Schnittstellen im Java Collection Framework. Schauen wir uns nun jeden von ihnen genauer an.

Sammlung

Eine Sammlung ist eine Gruppe von Objekten, die als Elemente bezeichnet werden. Dies ist ein Objekt, das Verweise auf andere Objekte enthalten kann. Die Collection-Schnittstelle ist die Wurzel der Collection-Hierarchie. Dies ist die Basisschnittstelle für alle Sammlungen im Java Collection Framework. Es definiert die grundlegenden Methoden, die in allen Sammlungen implementiert werden müssen, wie zum Beispiel add() , remove() und contains() . Hier ist ein Beispiel für die Verwendung von Sammlungen im Java Collection Framework. Hier wird die Collection-Schnittstelle verwendet, um Elemente zu einer Sammlung hinzuzufügen und daraus zu entfernen:

import java.util.Collection;
import java.util.ArrayList;

public class CollectionExample {
    public static void main(String[] args) {
        // Создаем новую коллекцию
        Collection<String> stringCollection = new ArrayList<>();

        // Добавляем несколько элементов в коллекцию
        stringCollection.add("hello");
        stringCollection.add("world");
        stringCollection.add("foo");
        stringCollection.add("bar");

        // Печатаем число элементов в коллекции
        System.out.println("Number of elements: " + stringCollection.size());

        // Удаляем элемент из коллекции
        stringCollection.remove("foo");

        // Опять печатаем число элементов в коллекции
        System.out.println("Number of elements: " + stringCollection.size());
    }
}

Die Ausgabe ist: Wie Sie sehen, ist die Collection-Schnittstelle eine einfache und bequeme Möglichkeit, allgemeine Vorgänge mit einer Sammlung von Objekten durchzuführen. Es wird häufig als Ausgangspunkt für die Arbeit mit Sammlungen in Java verwendet. Das Java Collection Framework umfasst mehrere Schnittstellen, die gemeinsames Verhalten für verschiedene Arten von Sammlungen definieren. Einige davon sind Teil der Schnittstellengruppe java.util.Collection :

• java.util.List
• java.util.set
• java.util.Queue

java.util.List

Eine Liste ist eine geordnete Sammlung von Objekten, von denen jedes Element eine bestimmte Position in der Liste einnimmt. Die List-Schnittstelle erweitert die Collection-Schnittstelle und fügt mehrere Methoden zum Arbeiten mit Listen hinzu, z. B. Methoden zum Zugriff auf Elemente anhand ihrer Position in der Liste und Methoden zum Suchen und Sortieren von Listen. Eine Liste kann doppelte Elemente enthalten . Auf diese Elemente kann über ihre Position in der Liste zugegriffen werden. Hier ist ein Beispiel für die Verwendung der List-Schnittstelle zum Hinzufügen, Entfernen und Zugreifen auf Elemente in einer Liste:

import java.util.List;
import java.util.ArrayList;

public class ListExample {
    public static void main(String[] args) {
        // Создаем новый список
        List<String> stringList = new ArrayList<>();

        // Добавляем несколько элементов в список
        stringList.add("India");
        stringList.add("UAE");
        stringList.add("London");
        stringList.add("US");

        // Печатаем первый элемент в списке
        System.out.println("First element: " + stringList.get(0));

        // Удаляем второй элемент из списка
        stringList.remove(1);

        // Печатаем второй элемент в списке
        System.out.println("Second element: " + stringList.get(1));
    }
}

Abschluss: Wie oben gezeigt, bietet die List-Schnittstelle eine bequeme Möglichkeit, mit geordneten Elementsammlungen zu arbeiten. Es wird normalerweise verwendet, wenn Sie die Reihenfolge der Elemente in einer Sammlung beibehalten müssen oder wenn Sie in einer Liste auf Elemente über ihren Index zugreifen müssen.

java.util.Set

Ein Satz im Java Collection Framework ist ein ungeordneter Satz eindeutiger Elemente , der keine doppelten Elemente zulässt . Die Set-Schnittstelle erweitert die Collection-Schnittstelle und fügt mehrere Methoden hinzu, z. B. Methoden zum Überprüfen, ob sich ein Element in einer Menge befindet, und Methoden zum Hinzufügen und Entfernen von Elementen zu einer Menge. Hier ist ein Beispiel für die Verwendung der Set-Schnittstelle zum Hinzufügen und Entfernen von Elementen zu einem Set im Java Collection Framework:

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

public class SetExample {
    public static void main(String[] args) {
        // Создаем новый set
        Set<String> stringSet = new HashSet<>();

        // Добавляем несколько элементов в set
        stringSet.add("Jan");
        stringSet.add("Feb");
        stringSet.add("March");
        stringSet.add("April");

        // Проверяем наличие в set Element "March"
        if (stringSet.contains("March")) {
            System.out.println("The set contains the element 'March'");
        }

        // Удаляем элемент "April" из set
        stringSet.remove("April");

        // Опять проверяем наличие Element "April" в set
        if (!stringSet.contains("April")) {
            System.out.println("The set no longer contains the element 'April'");
        }
    }
}

Abschluss:

java.util.Queue

Eine Warteschlange ist eine Datenstruktur, die zum Speichern von Elementen in der FIFO-Reihenfolge (First-In-First-Out) verwendet wird. Dies bedeutet, dass das erste zur Warteschlange hinzugefügte Element auch das erste entfernte Element ist. Hier ist ein Beispiel für die Verwendung einer Warteschlange im Java Collection Framework:

// Schaffung очереди
Queue<String> queue = new LinkedList<>();

// Добавление элементов в очередь
queue.add("apple");
queue.add("banana");
queue.add("orange");
// Печатаем очередь
System.out.println("Queue: " + queue);
// Удаляем элемент из очереди
String element = queue.remove();
System.out.println("Removed element: " + element);
// Печатаем обновленную очередь
System.out.println("Queue: " + queue);

In diesem Beispiel haben wir eine Zeichenfolgenwarteschlange erstellt und ihr drei Elemente hinzugefügt: „Apfel“, „Banane“ und „Orange“. Anschließend drucken wir die Warteschlange aus, um ihren aktuellen Status anzuzeigen. Als nächstes entfernen wir das Element aus der Warteschlange und geben es auf der Konsole aus. Abschließend drucken wir die aktualisierte Warteschlange aus, um sicherzustellen, dass sich das entfernte Element nicht mehr in der Warteschlange befindet.

Karte

Die java.util.Map- Schnittstelle im Java Collection Framework wird zum Zuordnen von Schlüsseln zu Werten verwendet. Es ermöglicht Ihnen, Elemente als Schlüssel-Wert-Paare zu speichern und bietet Methoden für den Zugriff auf, die Änderung und die Iteration von Elementen in einer Karte. Nachfolgend finden Sie ein Beispiel für die Verwendung der Kartenschnittstelle :

// Создаем Map
 Map<String, Integer> map = new  HashMap <>();
// Добавляем элементы в Map
map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);
// Печать Map
 System.out.println("Map: " + map);
// Получаем Bedeutung для определенного ключа
int  value  = map.get( "banana" );
System.out.println("Value for 'banana': " + value);
// Удаляем элемент из Map
map.remove("orange");
// Печать обновленной карты
 System.out.println( "Map: " + map);

In diesem Beispiel erstellen wir eine Karte aus Zeichenfolgen und Ganzzahlen, indem wir ihr drei Elemente hinzufügen: „Apfel“ entspricht 1, „Banane“ entspricht 2 und „Orange“ entspricht 3. Anschließend drucken wir die Karte aus, um ihre aktuelle Bedeutung anzuzeigen. Danach erhalten wir den Wert des „Banana“-Schlüssels und geben ihn auf der Konsole aus. Schließlich entfernen wir das Schlüssel-Wert-Paar für „Orange“ aus der Karte und drucken die aktualisierte Karte aus, um zu sehen, dass das entfernte Element nicht mehr vorhanden ist.

Klassen

Eine Klasse ist eine konkrete Implementierung einer Sammlungsschnittstelle. Es bietet spezifische Implementierungen allgemeiner Verhaltensweisen und Vorgänge, die durch Schnittstellen im Framework definiert werden.

• ArrayList : Eine Implementierung der List- Schnittstelle mit einem skalierbaren Array.
• LinkedList : eine doppelt verknüpfte Liste, eine Implementierung der List- und Deque- Schnittstellen .
• HashSet : Eine Implementierung von Set , die eine Hash-Tabelle zur Speicherung verwendet.
• TreeSet : Eine Implementierung von Set , die einen Baum zur Speicherung verwendet.
• HashMap : Eine Implementierung von Map , die eine Hash-Tabelle zur Speicherung verwendet.

Die obige Liste ist eine der am häufigsten verwendeten Klassen im Java Collection Framework. Schauen wir uns nun die detaillierte Erklärung dieser Klassen an.

Anordnungsliste

Die Klasse java.util.ArrayList in Java-Sammlungen wird zum Speichern eines skalierbaren Arrays von Elementen in einer Liste verwendet. Es handelt sich um eine weit verbreitete Implementierung der java.util.List- Schnittstelle , die ein Array zum Speichern von Elementen verwendet und effiziente Methoden für den Zugriff, die Änderung und das Durchlaufen von Elementen in einer Liste bereitstellt. Die Klasse java.util.ArrayList bietet schnellen Direktzugriff auf ihre Elemente, aber langsames Einfügen und Entfernen an zufälligen Positionen. Unten finden Sie ein Beispiel für die Verwendung der ArrayList- Klasse im Java Collection Framework:

// Создаем array list
List<String> list = new ArrayList<>();
// Добавляем элементы в array list
list.add("qa");
list.add("devops");
list.add("dev");
// Печатаем array list
System.out.println("Array list: " + list);
// Доступ к элементу по определенному индексу
String element = list.get(1);
System.out.println("Element at index 1: " + element);
// Удаление Element из the array list
list.remove(1);
// Print the updated array list
System.out.println("Array list: " + list);

Wie Sie sehen, haben wir ein Array aus Strings erstellt und ihm drei Elemente hinzugefügt: „qa“, „devops“ und „dev“. Anschließend haben wir die Array-Liste ausgedruckt, um ihren aktuellen Status anzuzeigen. Danach greifen wir auf das Element bei Index 1 zu und geben es auf der Konsole aus. Schließlich entfernen wir das Element an Index 1 aus der Array-Liste und drucken eine aktualisierte Array-Liste, um sicherzustellen, dass das entfernte Element nicht mehr in der Liste enthalten ist.

LinkedList

Die Klasse java.util.LinkedList im Java Collection Framework erbt von der Klasse AbstractList und implementiert die Schnittstellen List und Deque . Es bietet effiziente Methoden zum Hinzufügen, Entfernen und Zugreifen auf Elemente am Anfang und Ende einer Liste. Diese Klasse ist auch eine Implementierung der List- Schnittstelle , die eine doppelt verknüpfte Liste zum Speichern von Elementen verwendet. Es ermöglicht schnelles Einfügen und Löschen an beliebigen Positionen, aber langsamen Direktzugriff auf seine Elemente. Hier ist ein Beispiel für die Verwendung der LinkedList- Klasse im Java Collection Framework:

// Создаем linked list
List<String> list = new LinkedList<>();
// Добавляем элементы в linked list
list.add("selenium");
list.add("cypress");
list.add("playwright");
// Печатаем linked list
System.out.println("Linked list: " + list);
// Добавляем элемент в начало списка
list.add(0, "webdriver.io");
// Печатаем обновленный linked list
System.out.println("Linked list: " + list);
// Удаляем первый элемент в списке
list.remove(0);
// Еще раз печатаем обновленный linked list
System.out.println("Linked list: " + list);

In diesem Beispiel haben wir eine verknüpfte Liste von Zeichenfolgen erstellt und ihr drei Elemente hinzugefügt: „Selenium“, „Cypress“ und „Playwright“. Anschließend drucken wir die verknüpfte Liste aus, um ihren aktuellen Status anzuzeigen. Als nächstes fügen wir das Element „webdriver.io“ am Anfang der Liste hinzu und drucken die aktualisierte verknüpfte Liste aus. Schließlich entfernen wir das erste Element aus der Liste und drucken die aktualisierte verknüpfte Liste erneut aus, um festzustellen, dass das gelöschte Element nicht mehr in der Liste enthalten ist.

HashSet

Die Klasse java.util.HashSet im Java Collection Framework wird zum Speichern einer Sammlung eindeutiger Elemente in einem Satz verwendet. Es bietet eine Hash-Tabellen-basierte Implementierung der java.util.Set- Schnittstelle. Es ermöglicht außerdem schnelles Einfügen, Löschen und Suchen, behält jedoch nicht die Reihenfolge seiner Elemente bei. Nachfolgend finden Sie ein Beispiel für die Verwendung der HashSet- Klasse im Java Collection Framework:

// Создаем hash set
Set<String> set = new HashSet<>();

// Добавляем элементы в hash set
set.add("rose");
set.add("lily");
set.add("lotus");
// Попытка добавить повторяющийся элемент
set.add("rose");
// Печатаем hash set
System.out.println("Hash set: " + set);
// Удаляем элемент из hash set
set.remove("lily");
// Печать обновленного hash set
System.out.println("Hash set: " + set);

Hier haben wir einen Hash-Satz von Zeichenfolgen erstellt und ihm drei Elemente hinzugefügt: „Rose“, „Lilie“ und „Lotus“. Wir versuchen dann erneut, das Element „Rose“ hinzuzufügen, aber da das Hash-Set keine Duplikate zulässt, wird es nicht hinzugefügt. Danach drucken wir den Hash-Satz aus, um seinen aktuellen Status anzuzeigen. Anschließend entfernen wir das Element „lily“ aus der Menge und drucken den aktualisierten Hash der Menge, um zu sehen, dass das entfernte Element nicht mehr in der Menge enthalten ist.

TreeSet

Die Klasse java.util.TreeSet im Java Collection Framework wird verwendet, um eine Sammlung eindeutiger Elemente in einer aufsteigend sortierten Menge zu speichern. Es bietet eine baumbasierte Implementierung der java.util.Set- Schnittstelle zum Speichern von Elementen, ohne doppelte Elemente zuzulassen. Die Klasse ermöglicht schnelles Einfügen, Löschen und Suchen und behält die Reihenfolge ihrer Elemente entsprechend ihrer natürlichen Reihenfolge oder ihrem Komparator bei. Hier ist ein Beispiel für die Verwendung der TreeSet- Klasse im Java Collection Framework:

// Создаем tree set
Set<String> set = new TreeSet<>();

// Добавляем элементы в tree set
set.add("apple");
set.add("banana");
set.add("orange");
// Попытка добавить повторяющийся элемент
set.add("apple");
// Печатаем tree set
System.out.println("Tree set: " + set);
// Удаляем элемент из tree set
set.remove("banana");
// Печатаем обновленный tree set
System.out.println("Tree set: " + set);

In diesem Beispiel erstellen wir einen Baumsatz aus Zeichenfolgen und fügen ihm drei Elemente hinzu: „Apfel“, „Banane“ und „Orange“. Wir versuchen dann erneut, das Element „Apfel“ hinzuzufügen, aber da der Baumsatz keine Duplikate zulässt, wird es nicht hinzugefügt. Danach drucken wir den Baumsatz aus, um seinen aktuellen Zustand anzuzeigen. Da der Baumsatz in aufsteigender Reihenfolge sortiert ist, werden die Elemente in der Reihenfolge „Apfel“, „Banane“ und „Orange“ gedruckt. Anschließend entfernen wir das Element „Banane“ aus der Menge und drucken das aktualisierte Baumset aus, um festzustellen, dass das entfernte Element nicht mehr in der Menge enthalten ist.

HashMap

Die Klasse java.util.HashMap im Java Collection Framework wird zum Speichern der Zuordnung von Schlüsseln zu Werten in einer Karte verwendet. Es bietet eine Hash-Tabellen-basierte Implementierung der java.util.Map- Schnittstelle und ermöglicht die Speicherung von Elementen als Schlüssel-Wert-Paare. Die Klasse ermöglicht schnelles Einfügen, Löschen und Suchen, behält jedoch nicht die Reihenfolge ihrer Elemente bei. Hier ist ein Beispiel für die Verwendung der HashMap- Klasse im Java Collection Framework:

// Создаем hash map
Map<String, Integer> map = new HashMap<>();

// Добавляем элементы в hash map
map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);
// Печатаем hash map
System.out.println("Hash map: " + map);
// Получаем Bedeutung для определенного ключа
int value = map.get("banana");
System.out.println("Value for 'banana': " + value);
// Удаляем элемент из hash map
map.remove("orange");
// Печатаем обновленный hash map
System.out.println("Hash map: " + map);

In diesem Beispiel erstellen wir eine Hash-Map aus ganzzahligen Zeichenfolgen und fügen ihr drei Elemente hinzu: „Apfel“ entspricht 1, „Banane“ entspricht 2 und „Orange“ entspricht 3. Anschließend drucken wir die Hash-Map aus, um den aktuellen Status anzuzeigen. Danach erhalten wir den Wert des „Banana“-Schlüssels und geben ihn auf der Konsole aus. Schließlich entfernen wir das Schlüssel-Wert-Paar für „Orange“ aus der Hash-Map und drucken die aktualisierte Hash-Map aus, um zu sehen, dass das entfernte Element nicht mehr darin enthalten ist.

Abschluss

Das Java Collection Framework besteht aus einer Reihe von Klassen und Schnittstellen, die eine Standardmethode zur Darstellung und Bearbeitung von Objektsammlungen in der Programmiersprache Java bieten. Dadurch können Entwickler/Tester konsistent und effizient mit Objektsammlungen arbeiten. Das Framework bietet ihnen Methoden zum Speichern, Zugreifen auf und Verwalten von Elementen in einer Sammlung und ermöglicht ihnen den einfachen Wechsel zwischen verschiedenen Sammlungsimplementierungen je nach den Anforderungen der Anwendung.