Pausa caffè #185. Una guida completa al Java Collection Framework

Fonte: Medium Questo tutorial ti aiuterà a comprendere meglio il funzionamento delle varie classi e interfacce incluse nel Java Collection Framework. Java Collection è un framework che fornisce un'architettura unificata per l'archiviazione e la gestione di un gruppo di oggetti. Fondamentalmente, è un insieme di classi e interfacce che forniscono un modo standard per rappresentare e manipolare raccolte di oggetti nel linguaggio Java. Il framework aiuta anche a implementare strutture dati di uso comune come List, Set e Map. Java Collection Framework include diverse interfacce e classi. Ecco un elenco di alcuni di essi:

Interfacce

Le interfacce nel Java Collection Framework definiscono il comportamento generale e le operazioni che possono essere eseguite sulle raccolte. Ciò include l'aggiunta o la rimozione di elementi, la ripetizione di elementi in una raccolta e altro ancora.

• Collezione : l'interfaccia radice in una gerarchia di raccolte, che rappresenta un gruppo di oggetti noti come elementi.
• Elenco : raccolta ordinata di elementi che consente la duplicazione.
• Insieme : una raccolta di elementi che non consentono la duplicazione.
• Mappa : una raccolta di coppie chiave-valore, in cui ogni chiave è univoca.
• Coda : una coda è una struttura dati utilizzata per memorizzare gli elementi nell'ordine FIFO (first-in-first-out).

Questo elenco non include tutto, ma solo le interfacce più utilizzate nel Java Collection Framework. Ora diamo uno sguardo più da vicino a ciascuno di essi.

Collezione

Una Collezione è un gruppo di oggetti conosciuti come i suoi elementi. Questo è un oggetto che può contenere riferimenti ad altri oggetti. L'interfaccia Collection è la radice della gerarchia della raccolta. Questa è l'interfaccia di base per tutte le raccolte in Java Collection Framework. Definisce i metodi di base che devono essere implementati in tutte le raccolte, come add() , remove() e contiene() . Di seguito è riportato un esempio di utilizzo delle raccolte nel Java Collection Framework. Qui l'interfaccia Collezione viene utilizzata per aggiungere e rimuovere elementi da una collezione:

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());
    }
}

L'output è: Come puoi vedere, l'interfaccia Raccolta è un modo semplice e conveniente per eseguire operazioni comuni con una raccolta di oggetti. Viene spesso utilizzato come punto di partenza quando si lavora con le raccolte in Java. Java Collection Framework include diverse interfacce che definiscono il comportamento comune per diversi tipi di raccolte. Alcuni di essi fanno parte del gruppo di interfacce java.util.Collection :

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

java.util.List

La lista è una raccolta ordinata di oggetti, ciascun elemento dei quali occupa una posizione specifica nella lista. L'interfaccia Elenco estende l'interfaccia Raccolta e aggiunge diversi metodi per lavorare con gli elenchi, come metodi per accedere agli elementi in base alla loro posizione nell'elenco e metodi per cercare e ordinare gli elenchi. Una lista può contenere elementi duplicati , a questi elementi è possibile accedere in base alla loro posizione nella lista. Ecco un esempio di utilizzo dell'interfaccia Elenco per aggiungere, rimuovere e accedere agli elementi in un elenco:

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));
    }
}

Conclusione: Come mostrato sopra, l'interfaccia Elenco fornisce un modo conveniente per lavorare con raccolte ordinate di elementi. Viene in genere utilizzato quando è necessario mantenere l'ordine degli elementi in una raccolta o quando è necessario accedere agli elementi tramite il relativo indice in un elenco.

java.util.Set

Un set in Java Collection Framework è un set non ordinato di elementi univoci che non consente elementi duplicati . L'interfaccia Set estende l'interfaccia Collection e aggiunge diversi metodi, come metodi per verificare se un elemento è in un set e metodi per aggiungere e rimuovere elementi da un set. Ecco un esempio di utilizzo dell'interfaccia Set per aggiungere e rimuovere elementi da un set nel 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'");
        }
    }
}

Conclusione:

java.util.Queue

Una coda è una struttura dati utilizzata per memorizzare gli elementi nell'ordine FIFO (first-in-first-out). Ciò significa che il primo elemento aggiunto alla coda sarà il primo elemento rimosso. Ecco un esempio di come utilizzare una coda nel Java Collection Framework:

// Creation очереди
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 questo esempio, abbiamo creato una coda di stringhe e vi abbiamo aggiunto tre elementi: "mela", "banana" e "arancia". Stampiamo quindi la coda per vedere il suo stato attuale. Successivamente, rimuoviamo l'elemento dalla coda e lo stampiamo sulla console. Infine, stampiamo la coda aggiornata per garantire che l'elemento rimosso non sia più in coda.

Carta geografica

L' interfaccia java.util.Map in Java Collection Framework viene utilizzata per associare le chiavi ai valori. Consente di archiviare elementi come coppie chiave-valore e fornisce metodi per accedere, modificare ed eseguire l'iterazione sugli elementi in una mappa. Di seguito è riportato un esempio di utilizzo dell'interfaccia Mappa :

// Создаем 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);
// Получаем meaning для определенного ключа
int  value  = map.get( "banana" );
System.out.println("Value for 'banana': " + value);
// Удаляем элемент из Map
map.remove("orange");
// Печать обновленной карты
 System.out.println( "Map: " + map);

In questo esempio, creiamo una mappa di stringhe e numeri interi aggiungendovi tre elementi: la mappa "mela" su 1, la mappa "banana" su 2 e la mappa "arancione" su 3. Quindi stampiamo la mappa per vedere il suo stato attuale Senso. Successivamente, otteniamo il valore della chiave “banana” e lo stampiamo sulla console. Infine, rimuoviamo la coppia chiave-valore per "arancione" dalla mappa e stampiamo la mappa aggiornata per vedere che l'elemento rimosso non è più presente.

Classi

Una classe è un'implementazione concreta di un'interfaccia di raccolta. Fornisce implementazioni specifiche di comportamenti e operazioni comuni definiti dalle interfacce nel framework.

• ArrayList : un'implementazione dell'interfaccia List con un array ridimensionabile.
• LinkedList : una lista doppiamente collegata, un'implementazione delle interfacce List e Deque .
• HashSet : un'implementazione di Set che utilizza una tabella hash per l'archiviazione.
• TreeSet : un'implementazione di Set che utilizza un albero per l'archiviazione.
• HashMap : un'implementazione di Map che utilizza una tabella hash per l'archiviazione.

L'elenco precedente è una delle classi più comunemente utilizzate nel Java Collection Framework. Ora diamo un'occhiata alla spiegazione dettagliata di queste classi.

Lista di array

La classe java.util.ArrayList nelle raccolte Java viene utilizzata per archiviare un array ridimensionabile di elementi in un elenco. Si tratta di un'implementazione ampiamente utilizzata dell'interfaccia java.util.List che utilizza un array per memorizzare elementi e fornisce metodi efficienti per accedere, modificare e scorrere gli elementi in un elenco. La classe java.util.ArrayList fornisce un accesso casuale rapido ai suoi elementi, ma un inserimento e una rimozione lenti in posizioni casuali. Di seguito è riportato un esempio di utilizzo della classe ArrayList in 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);

Come puoi vedere, abbiamo creato un array di stringhe e vi abbiamo aggiunto tre elementi: “qa”, “devops” e “dev”. Abbiamo quindi stampato l'elenco dell'array per vedere il suo stato corrente. Successivamente, accediamo all'elemento all'indice 1 e lo stampiamo sulla console. Infine, rimuoviamo l'elemento all'indice 1 dall'elenco dell'array e stampiamo un elenco dell'array aggiornato per garantire che l'elemento rimosso non sia più nell'elenco.

Lista collegata

La classe java.util.LinkedList nel Java Collection Framework eredita dalla classe AbstractList e implementa le interfacce List e Deque . Fornisce metodi efficienti per aggiungere, rimuovere e accedere agli elementi all'inizio e alla fine di un elenco. Questa classe è anche un'implementazione dell'interfaccia List , che utilizza un elenco doppiamente collegato per memorizzare gli elementi. Fornisce inserimento ed eliminazione rapidi in posizioni arbitrarie, ma un accesso casuale lento ai suoi elementi. Ecco un esempio di come utilizzare la classe LinkedList nel 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 questo esempio, abbiamo creato un elenco collegato di stringhe e vi abbiamo aggiunto tre elementi: "selenio", "cipresso" e "drammaturgo". Stampiamo quindi l'elenco collegato per vedere il suo stato attuale. Successivamente, aggiungiamo l'elemento "webdriver.io" all'inizio dell'elenco e stampiamo l'elenco collegato aggiornato. Infine, rimuoviamo il primo elemento dall'elenco e stampiamo nuovamente l'elenco collegato aggiornato per vedere che l'elemento eliminato non è più nell'elenco.

HashSet

La classe java.util.HashSet in Java Collection Framework viene utilizzata per archiviare una raccolta di elementi univoci in un set. Fornisce un'implementazione basata su tabella hash dell'interfaccia java.util.Set . Fornisce inoltre inserimento, cancellazione e ricerca rapidi, ma non preserva l'ordine dei suoi elementi. Di seguito è riportato un esempio di utilizzo della classe HashSet nel 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);

Qui abbiamo creato un set di stringhe di hash e vi abbiamo aggiunto tre elementi: "rosa", "giglio" e "loto". Proviamo quindi ad aggiungere nuovamente l'elemento “rose”, ma poiché l'hash set non consente duplicati, non verrà aggiunto. Successivamente stampiamo l'hash impostato per vedere il suo stato attuale. Rimuoviamo quindi l'elemento "giglio" dal set e stampiamo l'hash aggiornato del set per vedere che l'elemento rimosso non è più nel set.

Set di alberi

La classe java.util.TreeSet in Java Collection Framework viene utilizzata per archiviare una raccolta di elementi univoci in un set ordinato in ordine crescente. Fornisce un'implementazione basata su albero dell'interfaccia java.util.Set per memorizzare elementi senza consentire elementi duplicati. La classe fornisce inserimento, cancellazione e ricerca rapidi e mantiene l'ordine dei suoi elementi in base al loro ordine naturale o comparatore. Ecco un esempio di come utilizzare la classe TreeSet nel 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 questo esempio, creiamo un insieme di stringhe ad albero e vi aggiungiamo tre elementi: "mela", "banana" e "arancia". Proviamo quindi ad aggiungere nuovamente l'elemento “mela”, ma poiché l'insieme dell'albero non consente duplicati, non verrà aggiunto. Successivamente stampiamo l'albero impostato per vedere il suo stato attuale. Poiché l'insieme degli alberi è ordinato in ordine crescente, gli elementi verranno stampati nell'ordine: “mela”, “banana” e “arancia”. Quindi rimuoviamo l'elemento "banana" dal set e stampiamo il set di alberi aggiornato per vedere che l'elemento rimosso non è più nel set.

HashMap

La classe java.util.HashMap nel Java Collection Framework viene utilizzata per archiviare la mappatura delle chiavi sui valori in una mappa. Fornisce un'implementazione basata su tabella hash dell'interfaccia java.util.Map e consente di archiviare gli elementi come coppie chiave-valore. La classe fornisce inserimento, cancellazione e ricerca rapidi, ma non preserva l'ordine dei suoi elementi. Ecco un esempio di come utilizzare la classe HashMap nel 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);
// Получаем meaning для определенного ключа
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 questo esempio, creiamo una mappa hash di stringhe intere e vi aggiungiamo tre elementi: "mela" corrisponde a 1, "banana" corrisponde a 2 e "arancione" corrisponde a 3. Quindi stampiamo la mappa hash per vederla Stato corrente. Successivamente, otteniamo il valore della chiave “banana” e lo stampiamo sulla console. Infine, rimuoviamo la coppia chiave-valore per "arancione" dalla mappa hash e stampiamo la mappa hash aggiornata per vedere che l'elemento rimosso non è più al suo interno.

Conclusione

Java Collection Framework è un insieme di classi e interfacce che forniscono un modo standard per rappresentare e manipolare raccolte di oggetti nel linguaggio di programmazione Java. Ciò consente agli sviluppatori/tester di lavorare con raccolte di oggetti in modo coerente ed efficiente. Il framework fornisce loro metodi per archiviare, accedere e gestire gli elementi in una raccolta e consente loro di passare facilmente tra diverse implementazioni di raccolte a seconda dei requisiti dell'applicazione.