Was ist das Java Collection Framework?

Ans Java Collection Framework ist eine leistungsstarke integrierte Bibliothek, die eine Reihe von optimierten Implementierungen der am häufigsten verwendeten Datenstrukturen und Algorithmen bereitstellt. Es wird häufig beim Erstellen von Java-Anwendungen und bei der Lösung realer Softwareentwicklung eingesetzt Herausforderungen.

Welche Vorteile bietet das Java Collection Framework?

Antworten Einige der Vorteile des Java Collection Frameworks sind

1. Einheitliche Architektur: Jede Datenstruktur wird von Schnittstellen wie iterierbaren Schnittstellen und Sammlungsschnittstellen abgeleitet, die einen Eindruck von gemeinsamen Implementierungen vermitteln.
2. Benutzerfreundlichkeit: Es vereinfacht den Entwicklungsprozess durch die Bereitstellung vorgefertigter Datenstrukturen und Algorithmen. Der Entwickler kann sich mehr auf die Geschäftslogik konzentrieren, anstatt häufig verwendete Datenstrukturen und Standardalgorithmen manuell zu implementieren und zu optimieren.
3. Flexibilität: Wenn wir zugrunde liegende Datenstrukturen ändern möchten, können wir dies problemlos tun, ohne befürchten zu müssen, dass sich durch die Änderung der Datenstruktur (meistens) die Datenabruf- und Zugriffsmuster ändern.
4. Thread-Sicherheit: Da Java eine Möglichkeit bietet, Prozesse in verschiedenen Threads einzeln auszuführen, stellt das Java Collection Framework verschiedene Klassen zur Ausführung in Multithread-Umgebungen und Single-Thread-Anwendungen bereit.

JAVA-SAMMLUNGSRAHMENHIERARCHIE

ITERABLE-SCHNITTSTELLE
Die Iterable-Schnittstelle in Java ist eine Schlüsselkomponente des Collection Framework. Es ist die Root-Schnittstelle für alle Sammlungstypen, über die iteriert werden kann. Durch die Implementierung der Iterable-Schnittstelle kann ein Objekt das Ziel einer „for-each-Schleife“ (auch als erweiterte for-Schleife bezeichnet) sein.
Außerdem stellt es ein Iteratorobjekt bereit, das für die Vorwärtsiteration aller Datenstrukturen verwendet werden kann, die diese iterierbare Schnittstelle implementieren.

Beispiel für die Verwendung von FOR EACH LOOP (ENHANCED FOR LOOP)

Intern implementiert ArrayList List und List Interface erweitert Collection Interface und Collection Interface erweitert Iterable Interface.

List list = new ArrayList();//Deklarieren einer Datenstruktur
list.add("Java");//Element hinzufügen
list.add("Collections");//Element hinzufügen
list.add("Framework");//Element hinzufügen
for (String-Element: Liste) {//Iterieren mit erweiterter for-Schleife
System.out.println(element);
}

Beispiel mit dem ITERABLE-Objekt

Iterator iterator = list.iterator();
while (iterator.hasNext()) {
String-Element = iterator.next();
System.out.println(element);
}

So können wir eine benutzerdefinierte iterierbare Schnittstelle erstellen, die eine iterierbare Schnittstelle implementiert und die Methoden „next“, „hasNext“ und „remove“ überschreibt. Hier ist ein Beispiel dafür.

import java.util.Iterator;
class CustomIterable implements Iterable {
    private final int[] numbers = {1, 2, 3, 4, 5};

    @Override
    public Iterator iterator() {
        return new Iterator() {
            private int index = 0;
            private int lastReturnedIndex = -1;

            @Override
            public boolean hasNext() {
                return index 



Notiz :

Iteratoren in Java sind ausfallsicher. Das bedeutet, dass, wenn die Sammlung während der Iteration geändert wird (außer durch die eigene Methode „remove()“ des Iterators), eine ConcurrentModificationException ausgelöst wird.
Die Methode „remove()“ kann nur Elemente entfernen und sollte nur einmal pro Aufruf von next() aufgerufen werden. Andernfalls wird eine IllegalStateException ausgelöst.

  
  
  Sammlungsschnittstelle


Dies ist die Schnittstelle, über die die Datenstrukturen und inneren Implementierungen flexibel werden. Fast alle Klassen implementieren diese Schnittstelle indirekt und ermöglichen so eine Änderung der Implementierung, indem einfach das der Sammlungsreferenz zugewiesene Objekt geändert wird.


//ArrayList
Collection c = new ArrayList():
c.add(1);
c.add(2);
c.contains(1);

Collection c1 = new LinkedList():
c1.addAll(c);//Array added to a linked list

/*What if i dont want arraylist but now i want a priority queue for applying efficient algorithms such as findmax and find min*/
//Just Change Object - SIMPLE!
Collection c = new **PriorityQueue**():
c.add(1);
c.add(2);
c.contains(1);




Methoden der Sammlungsschnittstelle


int size: Gibt die Größe der Sammlung zurück.

boolean isEmpty: Gibt true zurück, wenn die Sammlung leer ist.

boolean contains(Object o) : Gibt true zurück, wenn Object o in der Sammlung vorhanden ist.

Iterator iterator() : Gibt einen Iterator zurück, der auf eine Sammlung zeigt.

Object[] toArray(): Wandelt eine Sammlung in ein Array vom Typ „Objekt“ um.

 T[] toArray(T[] a) : Gibt ein Array zurück, das alle Elemente der Sammlung enthält; Der Laufzeittyp des zurückgegebenen Arrays ist der des angegebenen Arrays.

boolean add(E e) : Fügt Element e zur Sammlung hinzu. Gibt „true“ zurück, wenn der Vorgang erfolgreich ist.

boolean remove(Object o) : Entfernt ein Objekt o aus der Sammlung. Gibt „true“ zurück, wenn der Vorgang erfolgreich ist.

boolean containsAll(Collection> c) ​​: Gibt true zurück, wenn alle Elemente in beiden Sammlungen gleich sind. Gibt „true“ zurück, wenn der Vorgang erfolgreich ist.
10.boolean addAll(Collection erweitert E> c): Fügt alle Elemente beider Sammlungen hinzu. Gibt „true“ zurück, wenn der Vorgang erfolgreich ist.

boolean removeAll(Collection> c) ​​: Entfernt Element der Sammlung c aus der Aufrufer-Sammlung. Gibt „true“ zurück, wenn der Vorgang erfolgreich ist.

boolean retainAll(Collection> c) ​​: Behält nur die in Sammlung c vorhandenen Elemente.

void clear() : Löscht alle Elemente aus der Sammlung.
Durch die Implementierung der Sammlungsklasse können wir die oben genannten Methoden überschreiben, um eine benutzerdefinierte Sammlung zu erstellen. Unten finden Sie ein Beispiel dafür.


import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class CustomCollection implements Collection {
    private final ArrayList list = new ArrayList();

    @Override
    public int size() {
        return list.size();
    }

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public boolean contains(Object o) {
        return list.contains(o);
    }

    @Override
    public Iterator iterator() {
        return new Iterator() {
            private int index = 0;

            @Override
            public boolean hasNext() {
                return index  T[] toArray(T[] a) {
        return list.toArray(a);
    }

    @Override
    public boolean add(E e) {
        return list.add(e);
    }

    @Override
    public boolean remove(Object o) {
        return list.remove(o);
    }

    @Override
    public boolean containsAll(Collection> c) {
        return list.containsAll(c);
    }

    @Override
    public boolean addAll(Collection extends E> c) {
        return list.addAll(c);
    }

    @Override
    public boolean removeAll(Collection> c) {
        return list.removeAll(c);
    }

    @Override
    public boolean retainAll(Collection> c) {
        return list.retainAll(c);
    }

    @Override
    public void clear() {
        list.clear();
    }
}







  
  
  Listenschnittstelle


Die List-Schnittstelle in Java ist Teil des Java Collections Framework und erweitert die Collection-Schnittstelle. Es stellt eine geordnete Sammlung (auch als Sequenz bezeichnet) dar, die den Positionszugriff, das Duplizieren von Elementen und die Iteration über ihre Elemente ermöglicht. Die List-Schnittstelle wird von mehreren Klassen implementiert, z. B. ArrayList, LinkedList, Vector und Stack.

Hauptmerkmale der Listenschnittstelle:

Geordnete Sammlung: Eine Liste behält die Einfügereihenfolge von Elementen bei, was bedeutet, dass auf Elemente über ihren Index zugegriffen werden kann.
Erlaubt Duplikate: Eine Liste kann doppelte Elemente enthalten, im Gegensatz zu Sets, die keine Duplikate zulassen.
Positionszugriff: Auf Elemente in einer Liste kann über ihren Index zugegriffen, sie hinzugefügt oder entfernt werden.
Iteration: Die List-Schnittstelle ermöglicht erweiterte for-Schleifen sowie Iteration mit Iterator oder ListIterator.
Häufig verwendete Methoden der Listenschnittstelle:
Alle Methoden der Sammlungsschnittstelle werden auch von der Listenschnittstelle implementiert, da die Listenschnittstelle die Sammlungsschnittstelle erweitert.

void add(int index, E element): Fügt das angegebene Element E am angegebenen Index in dieser Liste ein.
E get(int index): Gibt das Element an der angegebenen Position in dieser Liste zurück.
E remove(int index): Entfernt das Element an der angegebenen Position in dieser Liste.
E set(int index, E element): Ersetzt das Element an der angegebenen Position in dieser Liste durch das angegebene Element.
int indexOf(Object o): Gibt den Index des ersten Vorkommens des angegebenen Elements zurück, oder -1, wenn die Liste das Element nicht enthält.
int lastIndexOf(Object o): Gibt den Index des letzten Vorkommens des angegebenen Elements zurück, oder -1, wenn die Liste das Element nicht enthält.
List subList(int fromIndex, int toIndex): Gibt eine Ansicht des Teils dieser Liste zwischen dem angegebenen fromIndex (inklusive) und toIndex (exklusiv) zurück.

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

public class ListExample {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("Java");
        list.add("Collections");
        list.add("Framework");

        // Accessing elements by index
        System.out.println("First Element: "   list.get(0));

        // Removing an element by index
        list.remove(1);
        System.out.println("After Removal: "   list);

        // Updating an element
        list.set(1, "Updated Element");
        System.out.println("Updated List: "   list);

        // Using a sublist
        List sublist = list.subList(0, 1);
        System.out.println("Sublist: "   sublist);
    }
}