Sammlungen in Java

Was ist Sammlung in Java?

Eine Sammlung in Java wird als Container dargestellt, der alle Elemente in einer einzigen Einheit gruppiert. Zum Beispiel ein E-Mail-Ordner (Gruppe von E-Mails), ein Telefonverzeichnis (Zuordnung von Namen zu Telefonnummern).

Was ist ein Framework?

Ein Framework ist eine grundlegende Grundlage oder ein Layout, an dem Sie mit der Arbeit beginnen, indem Sie die verschiedenen bereitgestellten Klassen und Schnittstellen verwenden. Laravel ist beispielsweise eines der bekanntesten PHP-Frameworks, das ein Grundgerüst für Ihre Anwendung bereitstellt.

Was ist das Collections Framework in Java?

Alle Objekte werden in einem einzigen Objekt zusammen mit einer Architektur gruppiert, die verschiedene Methoden zur Bearbeitung von Sammlungen darstellt und bereitstellt. Daher bietet das Collections-Framework in Java verschiedene Datenstrukturen, die bereits zum Speichern von Daten und Methoden implementiert sind, um sie mit Funktionen wie Sortieren, Suchen, Löschen und Einfügen zu manipulieren . Beispielsweise möchten Sie für ein beliebiges Unternehmen ein System implementieren, um den Service für seine Kunden nach dem Prinzip „Wer zuerst kommt, mahlt zuerst“ zu verbessern. Dies wird auch als FIFO-Implementierung (First In First Out) bezeichnet. Jetzt müssen wir diese Datenstruktur implementieren und sie dann verwenden, um unser Ziel zu erreichen. Das Collections-Framework stellt uns eine Queue-Schnittstelle zur Verfügung, die wir nur importieren und nicht implementieren, dann verwenden müssen, und schon sind wir fertig. Implementierung : Sie können alle Sammlungen importieren, indem Sie die folgende Zeile verwenden:

import java.util.*;

Wenn Sie eine bestimmte Sammlung importieren möchten, verwenden Sie den genauen Paketnamen, z. B.:

import java.util.LinkedList;

Vorteile des Collections Framework in Java

Es hat die folgenden Vorteile.

1. Bereits implementiert (zeitsparend).
2. Leistungseffizienz (Geschwindigkeit und Qualität).
3. Reduziert den Aufwand zum Erlernen und Verwenden neuer APIs.

Was ist die Hierarchie des Collection Framework?

Sehen wir uns nun die Sammlungshierarchie an, aber zuerst müssen wir die wesentlichen Komponenten dieses Frameworks kennen.

1. Schnittstellen
2. Klassen (Implementierung)
3. Algorithmen

Hierarchie des Sammlungs-Frameworks

Für dein Verständnis:

1. Collection, Set, Queue und List sind alles Schnittstellen. Set, Queue und List werden durch die Collection-Schnittstelle erweitert .
2. PriorityQueue, HashSet, LinkedList und Stack sind alle Klassen oder die Implementierung dieser Schnittstellen.
3. Es ist nicht zwingend, dass eine Klasse nur eine Schnittstelle implementiert . LinkedList implementiert beispielsweise auch die Deque-Schnittstelle.

Arten von Sammlungen

Das Java Collections Framework enthält viele Arten von Sammlungen, um unseren Aufwand zu reduzieren. Hier ist eine Liste einiger Sammlungen:

1. ArrayList-Klasse
2. LinkedList-Klasse
3. Listenschnittstelle
4. Schnittstelle festlegen
5. Warteschlangenschnittstelle
6. Kartenschnittstelle
7. PriorityQueue-Klasse
8. HashMap-Klasse
9. Vergleichbare Schnittstelle
10. LinkedHashMap-Klasse
11. TreeMap-Klasse
12. Hash-tabelle

Sammlungsschnittstellen

Hier besprechen wir einige gängige Sammlungsschnittstellen und anschließend einige von den Klassen implementierte Methoden.

Sammlungsschnittstelle

Dies ist eine grundlegende Grundlage für das Collections-Framework, da es alle notwendigen Methoden für die Implementierung bereitstellt. Die Karte ist die einzige Datenstruktur, die sie nicht implementiert, aber alle übrigen implementieren ihre Methoden. Diese Schnittstelle verfügt über Methoden zum Ermitteln der Größe der Sammlung und zum Erkennen, ob ein Objekt in der Sammlung vorhanden ist, sowie zum Hinzufügen oder Entfernen von Objekten aus der Sammlung.

Iterierbare Schnittstelle

Es ist die Root-Schnittstelle für das Collections-Framework, da sie durch die Collection-Schnittstelle erweitert wird, die von allen Klassen implementiert wird. Es gibt einen Iterator für die spezifische Sammlung zurück, um darüber zu iterieren.

Warteschlangenschnittstelle

Die Warteschlange wird zum Speichern der Elemente verwendet, sie können jedoch nicht verarbeitet werden. Durch die Implementierung der grundlegenden Erfassungsvorgänge werden auch zusätzliche Einfüge- und Extraktionsmethoden bereitgestellt.

Schnittstelle festlegen

Das Set wird verwendet, um einzigartige Elemente darin aufzubewahren. Es enthält niemals doppelte Elemente und modelliert die mathematische Mengenabstraktion, um die Mengen darzustellen, z. B. Prozesse, die auf einer Maschine ausgeführt werden.

Listenschnittstelle

Eine Liste ist eine geordnete Sammlung, manchmal auch Sequenz genannt, die doppelte Elemente enthalten kann. Es bietet dem Benutzer die Möglichkeit, ein bestimmtes Element zu aktualisieren oder zu entfernen und ein Element an einer bestimmten Stelle mithilfe seines ganzzahligen Indexwerts einzufügen. LinkedList und ArrayList sind Implementierungsklassen der List-Schnittstelle.

Deque-Schnittstelle

Deque steht für die doppelendige Warteschlange, was bedeutet, dass wir Operationen an beiden Enden ausführen können. Wir können Elemente an beiden Enden einfügen und entfernen. Die Deque-Schnittstelle erweitert die Warteschlangenschnittstelle. ArrayDeque und LinkedList implementieren beide die Deque-Schnittstelle. Es bietet Methoden zum Einfügen, Löschen und Untersuchen der Instanz von beiden Seiten.

Kartenschnittstelle

Die Kartenschnittstelle ist ebenfalls Teil des Collections-Frameworks, erweitert die Collection-Schnittstelle jedoch nicht. Es wird zum Speichern von Schlüssel-Wert-Paaren verwendet. Seine Hauptimplementierungen sind HashMap, TreeMap und LinkesHashMap, die in bestimmten Aspekten HashSet, TreeSet und LinkedHashSet ähneln. Es enthält immer eindeutige Schlüssel, die Werte können jedoch dupliziert werden. Dies ist nützlich, wenn Sie ein Element basierend auf einem Schlüssel hinzufügen, löschen oder suchen müssen. Es stellt uns grundlegende Methoden wie Put , Get , Remove , Size , Empty usw. zur Verfügung.

Gemeinsame Methoden dieser Schnittstellen

Jetzt werden wir uns einige gängige Methoden ansehen, die für die Implementierung verschiedener Klassen in diesem Framework bereitgestellt werden, mit Ausnahme der Map-Schnittstelle.

Sammlungsklassen

Wie wir wissen, verfügt das Framework über verschiedene Schnittstellen, die von vielen darin enthaltenen Klassen implementiert werden. Schauen wir uns nun einige häufig verwendete Klassen an.

LinkedList

Es ist die am häufigsten verwendete Datenstruktur, die eine doppelt verknüpfte Liste implementiert, um die darin enthaltenen Elemente zu speichern. Es kann doppelte Elemente speichern. Es implementiert die Dequeue-Schnittstelle, erweitert um die Queue-Schnittstelle und die List-Schnittstelle. Es ist nicht synchronisiert. Sehen wir uns nun an, wie wir unser oben besprochenes Problem (das FIFO-Konzept) mithilfe von LinkedList lösen können. Das Problem besteht darin, die Kunden so zu bedienen, wie sie ankommen, dh wer zuerst reinkommt, mahlt zuerst raus .

Beispiel

import java.util.*;

public class LinkedListExample {
    public static void main(String[] args) {
        Queue<String> customerQueue = new LinkedList<String>();
        //Adding customers to the Queue as they arrived
        customerQueue.add("John");
        customerQueue.add("Angelina");
        customerQueue.add("Brooke");
        customerQueue.add("Maxwell");

        System.out.println("Customers in Queue:"+customerQueue);
        //element() => returns head of the queue
        //we will see our first customer and serve him
        System.out.println("Head of the queue i.e first customer: "+customerQueue.element());
        //remove () method =>removes first element(customer) from the queue i.e the customer is served so remove him to see next
        System.out.println("Element removed from the queue: "+customerQueue.remove());
        //poll () => removes and returns the head
        System.out.println("Poll():Returned Head of the queue: "+customerQueue.poll());
        //print the remaining customers in the Queue
        System.out.println("Final Queue:"+customerQueue);
    }
}

Ausgabe

Anordnungsliste

Es implementiert einfach die List-Schnittstelle. Es behält die Einfügereihenfolge bei und verwendet ein dynamisches Array zum Speichern von Elementen unterschiedlicher Datentypen. Elemente können dupliziert werden. Es ist außerdem nicht synchronisiert und kann Nullwerte speichern. Sehen wir uns nun die verschiedenen Methoden an ... Diese sind nützlich, wenn wir nicht wissen, wie viele Datensätze oder Elemente wir einfügen müssen. Nehmen wir als Beispiel eine Bibliothek, in der wir nicht wissen, wie viele Bücher wir aufbewahren müssen. Wenn wir also ein Buch haben, müssen wir es in ArrayList einfügen.

Beispiel

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

		// Creating the ArrayList
		ArrayList<String> books = new ArrayList<String>();

		// Adding a book to the list
		books.add("Absalom, Absalom!");
		// Adding a book in array list
		books.add("A Time to Kill");
		// Adding a book to the list
		books.add("The House of Mirth");
		// Adding a book to the list
		books.add("East of Eden");
		// Traversing the list through Iterator
		Iterator<String> itr = books.iterator();
		while (itr.hasNext()) {
			System.out.println(itr.next());
		}
	}
}

Ausgabe

HashSet

Es implementiert die Set-Schnittstelle und enthält niemals doppelte Werte. Es implementiert die Hash-Tabelle zum Speichern der Werte. Es erlaubt auch Nullwerte. Die Einfügereihenfolge wird nie beibehalten, sondern die konstante Zeitleistung für die Methoden add , remove , size und contains bereitgestellt . Es eignet sich am besten für Suchvorgänge und ist nicht synchronisiert.

Beispiel

import java.util.*;
class HashSetExample{
    public static void main(String args[]){
        //creating HashSet and adding elements to it
        HashSet<Integer> hashSet=new HashSet();
        hashSet.add(1);
        hashSet.add(5);
        hashSet.add(4);
        hashSet.add(3);
        hashSet.add(2);
        //getting an iterator for the collection
        Iterator<Integer> i=hashSet.iterator();
        //iterating over the value
        while(i.hasNext())  {
            System.out.println(i.next());
        }
    }
}

Ausgabe

Wie Sie sehen, wird die Einfügereihenfolge nicht beibehalten.

ArrayDeque

Es implementiert die Deque-Schnittstelle und ermöglicht so Operationen von beiden Seiten. Es sind keine Nullwerte zulässig. Es ist schneller als Stack und LinkedList, wenn es als Stack und LinkedList implementiert wird. Für ArrayDeque gibt es keine Größenbeschränkungen, da es je nach Anforderungen wächst und schrumpft. Es ist unsynchronisiert, was bedeutet, dass es nicht threadsicher ist. Um die Thread-Sicherheit zu gewährleisten, müssen wir eine externe Logik implementieren.

Beispiel

import java.util.*;
public class ArrayDequeExample {
   public static void main(String[] args) {
       //creating Deque and adding elements
       Deque<String> deque = new ArrayDeque<String>();
       //adding an element
       deque.add("One");
       //adding an element at the start
       deque.addFirst("Two");
       //adding an element at the end
       deque.addLast("Three");
       //traversing elements of the collection
       for (String str : deque) {
            System.out.println(str);
       }
   }
}

Ausgabe

HashMap

Es handelt sich um die Implementierung der Map-Schnittstelle, die durch die Hash-Tabelle unterstützt wird. Es speichert die Schlüssel-Wert-Paare. Es sind keine Nullwerte zulässig. Es ist nicht synchronisiert. Es garantiert niemals die Einfügungsreihenfolge. Es bietet eine konstante Zeitleistung für Methoden wie get und put . Seine Leistung hängt von zwei Faktoren ab – der Anfangskapazität und dem Auslastungsfaktor . Die Kapazität ist die Anzahl der Buckets in der Hash-Tabelle. Die anfängliche Kapazität ist also die Anzahl der Buckets, die zum Zeitpunkt der Erstellung zugewiesen wurden. Der Ladefaktor ist das Maß dafür, wie viel eine Hash-Tabelle gefüllt werden kann, bevor ihre Kapazität erhöht wird. Die Rehash-Methode dient zur Kapazitätserhöhung und verdoppelt im Wesentlichen die Anzahl der Eimer.

Beispiel

import java.util.*;
public class HashMapExample{
    public static void main(String args[]){
        //creating a HashMap
        HashMap<Integer,String> map=new HashMap<Integer,String>();
        //putting elements into the map
        map.put(1,"England");
        map.put(2,"USA");
        map.put(3,"China");

        //get element at index 2
        System.out.println("Value at index 2 is: "+map.get(2));
        System.out.println("iterating map");
        //iterating the map
        for(Map.Entry m : map.entrySet()){
            System.out.println(m.getKey()+" "+m.getValue());
        }
    }
}

Ausgabe

Algorithmen

Das Collections-Framework stellt uns verschiedene Algorithmen für verschiedene Vorgänge zur Verfügung, die auf die Sammlungen angewendet werden können. Hier werden wir uns ansehen, welche Hauptoperationen von diesen Algorithmen abgedeckt werden. Es enthält Algorithmen im Zusammenhang mit:

1. Sortierung
2. Suchen
3. Schlurfen
4. Routinemäßige Datenmanipulation
5. Komposition
6. Extreme Werte finden

Zum besseren Verständnis werden wir den Sortieralgorithmus diskutieren.

Sortierung

Der Sortieralgorithmus ordnet eine Liste entsprechend einer Ordnungsbeziehung neu. Es stehen zwei Formen von Beziehungen zur Verfügung.

1. Natürliche Ordnung
2. Vergleichsbestellung

Natürliche Ordnung

Bei der natürlichen Sortierung wird eine Liste nach ihren Elementen sortiert.

Vergleichsbestellung

Bei dieser Bestellform wird ein zusätzlicher Parameter, ein Komparator, zusammen mit der Liste übergeben. Für die Sortierung wird ein leicht optimierter Merge-Sort-Algorithmus verwendet, der schnell und stabil ist, da er die Laufzeit von n log(n) garantiert und gleiche Elemente nicht neu anordnet. Wir verwenden dasselbe Beispiel aus ArrayList, um die Sortierung zu demonstrieren.

Beispiel

import java.util.*;
public class SortingExample{
    public static void main(String args[]){
        //Creating arraylist
        ArrayList<String> books=new ArrayList<String>();
        //Adding a book to the arraylist
        books.add("A Time to Kill");
        //Adding a book to the arraylist
        books.add("Absalom, Absalom!");
        //Adding a book to the arraylist
        books.add("The House of Mirth");
        //Adding a book to the arraylist
        books.add("East of Eden");
        //Traversing list through Iterator before sorting
        Iterator itrBeforeSort=books.iterator();
        while(itrBeforeSort.hasNext()){
            System.out.println(itrBeforeSort.next());
        }
        //sorting the books
        Collections.sort(books);
        System.out.println("After sorting the books");
        //Traversing list through Iterator after sorting
        Iterator itr=books.iterator();
        while(itr.hasNext()){
            System.out.println(itr.next());
        }
    }
}

Ausgabe

Abschluss

Wir hoffen, dass Sie inzwischen verstehen, was das Java Collections Framework ist, welche Schnittstellen und Klassen es hat und wie die verschiedenen Klassen implementiert werden. Sie können dieses Framework jederzeit verwenden, um Ihren Aufwand in Java zu reduzieren. Fühlen Sie sich frei, zu üben und kommen Sie hierher zurück, wenn Sie weitere Hilfe benötigen. Viel Spaß beim Lernen!