Collezioni in Giava

Cos'è la raccolta in Java?

Una collezione in Java è rappresentata come un contenitore che raggruppa tutti gli elementi in un'unica unità. Ad esempio , una cartella di posta (gruppo di email), una rubrica telefonica (mappatura dei nomi sui numeri di telefono).

Cos'è un quadro?

Un framework è una base o un layout di base su cui inizi a lavorare utilizzando le diverse classi e interfacce fornite. Ad esempio , Laravel è uno dei framework PHP più famosi che fornisce uno scheletro di base per la tua applicazione.

Cos'è il framework delle raccolte in Java?

Tutti gli oggetti sono raggruppati in un singolo oggetto insieme a un'architettura che rappresenta e fornisce diversi metodi per manipolare le raccolte. Quindi il framework Collections in Java fornisce diverse strutture dati già implementate per archiviare dati e metodi, per manipolarli con funzionalità come l' ordinamento, la ricerca, la cancellazione e l'inserimento . Ad esempio , desideri implementare un sistema per alcune aziende a caso per migliorare il servizio per i propri clienti, in base al principio "primo arrivato, primo servito". Questa è anche nota come implementazione FIFO (first in first out). Ora dobbiamo implementare questa struttura dati e quindi utilizzarla per raggiungere il nostro obiettivo. Il framework Collections ci fornisce un'interfaccia Queue che dobbiamo solo importare anziché implementare, quindi utilizzarla e il gioco è fatto. Implementazione : puoi importare tutte le raccolte utilizzando la seguente riga:

import java.util.*;

Se desideri importare una raccolta specifica, utilizza il nome esatto del pacchetto, ad esempio:

import java.util.LinkedList;

Vantaggi del framework delle raccolte in Java

Presenta i seguenti vantaggi.

1. Già implementato (risparmio di tempo).
2. Efficienza prestazionale (velocità e qualità).
3. Riduce lo sforzo per apprendere e utilizzare nuove API.

Qual è la gerarchia del framework di raccolta?

Vediamo ora la gerarchia delle collezioni, ma prima dobbiamo conoscere i componenti essenziali di questo framework.

1. Interfacce
2. Classi (implementazione)
3. Algoritmi

Gerarchia del quadro di raccolta

Per la tua comprensione:

1. Collection, Set, Queue ed List sono tutte interfacce. Set, Queue e List vengono estesi dall'interfaccia Collection.
2. PriorityQueue, HashSet, LinkedList e Stack sono tutte classi o l'implementazione di queste interfacce.
3. Non è obbligatorio che una classe implementi una sola interfaccia. LinkedList implementa ad esempio anche l'interfaccia Deque.

Tipi di collezioni

Il framework delle raccolte Java contiene molti tipi di raccolte per ridurre i nostri sforzi. Ecco un elenco di alcune delle collezioni:

1. Classe ArrayList
2. Classe Lista collegata
3. Elenco interfaccia
4. Imposta l'interfaccia
5. Interfaccia della coda
6. Interfaccia della mappa
7. Classe PriorityQueue
8. Classe HashMap
9. Interfaccia comparabile
10. Classe HashMap collegata
11. Classe TreeMap
12. HashTable

Interfacce di raccolta

Qui discuteremo alcune interfacce di raccolta comuni e poi alcuni metodi implementati dalle classi.

Interfaccia di raccolta

Questa è una base di base per il framework Collections poiché fornisce tutti i metodi necessari per l'implementazione. La Mappa è l'unica struttura dati che non la implementa ma le restanti tutte ne implementano i metodi. Questa interfaccia dispone di metodi per conoscere la dimensione della raccolta e se esiste un oggetto nella raccolta, aggiungendo o rimuovendo oggetti dalla raccolta.

Interfaccia iterabile

È l'interfaccia root per il framework Collections poiché è estesa dall'interfaccia Collection che è implementata da tutte le classi. Restituisce un iteratore per la raccolta specifica per scorrere su di essa.

Interfaccia della coda

La coda viene utilizzata per contenere gli elementi ma non possono essere elaborati. Implementando le operazioni di raccolta di base, fornisce anche ulteriori metodi di inserimento ed estrazione.

Imposta l'interfaccia

Set viene utilizzato per contenere elementi univoci al suo interno. Non contiene mai elementi duplicati e modella l'astrazione matematica dell'insieme per rappresentare gli insiemi come i processi in esecuzione su una macchina.

Elenco interfaccia

La lista è una raccolta ordinata a volte chiamata sequenza che può contenere elementi duplicati al suo interno. Fornisce il controllo all'utente per l'aggiornamento o la rimozione di un elemento specifico, inserendo un elemento in un punto specifico utilizzando il suo valore di indice intero. LinkedList e ArrayList sono classi di implementazione dell'interfaccia List.

Interfaccia decodifica

Deque sta per coda a doppia estremità, il che significa che possiamo eseguire operazioni su entrambe le estremità. Possiamo inserire e rimuovere elementi da entrambe le estremità. L'interfaccia Deque estende l'interfaccia della coda. ArrayDeque e LinkedList implementano entrambi l'interfaccia Deque. Fornisce metodi per l'inserimento, l'eliminazione e l'esame dell'istanza da entrambe le estremità.

Interfaccia della mappa

Anche l'interfaccia della mappa fa parte del framework Collections ma non estende l'interfaccia Collection. Viene utilizzato per memorizzare coppie chiave-valore. Le sue principali implementazioni sono HashMap, TreeMap e LinkesHashMap che sono simili per certi aspetti a HashSet, TreeSet e LinkedHashSet. Contiene sempre chiavi univoche ma i valori possono essere duplicati. È utile quando è necessario aggiungere, eliminare o cercare un elemento in base a una chiave. Ci fornisce metodi di base come put , get , delete , size , empty e così via.

Metodi comuni di queste interfacce

Ora esamineremo alcuni metodi comuni forniti per l'implementazione di diverse classi in questo framework ad eccezione dell'interfaccia Map.

Classi di raccolta

Come sappiamo il framework ha diverse interfacce implementate da molte classi al suo interno. Ora diamo un'occhiata ad alcune classi comunemente utilizzate.

Lista collegata

È la struttura dati più comunemente utilizzata che implementa un elenco doppiamente collegato per memorizzare gli elementi al suo interno. Può memorizzare elementi duplicati. Implementa l'interfaccia Dequeue estesa dall'interfaccia Queue e dall'interfaccia List. Non è sincronizzato. Vediamo ora come risolvere il nostro problema discusso sopra (il concetto FIFO) utilizzando LinkedList. Il problema è servire i clienti in modo che arrivino, ovvero first in first out .

Esempio

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

Produzione

Lista di array

Implementa semplicemente l'interfaccia List. Mantiene l'ordine di inserimento e utilizza un array dinamico per memorizzare elementi di diversi tipi di dati. Gli elementi possono essere duplicati. Inoltre non è sincronizzato e può memorizzare valori nulli. Vediamo ora i suoi diversi metodi... Sono utili quando non sappiamo quanti record o elementi dobbiamo inserire. Facciamo l'esempio di una biblioteca in cui non sappiamo quanti libri dobbiamo conservare. Quindi ogni volta che abbiamo un libro, dobbiamo inserirlo in ArrayList.

Esempio

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

Produzione

HashSet

Implementa l'interfaccia Set e non contiene mai valori duplicati. Implementa la tabella hash per la memorizzazione dei valori. Consente anche valori nulli. Non mantiene mai l'ordine di inserimento ma fornisce prestazioni costanti nel tempo per i metodi add , delete , size e contiene . È ideale per le operazioni di ricerca e non è sincronizzato.

Esempio

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

Produzione

Come puoi vedere non mantiene l'ordine di inserzione.

ArrayDeque

Implementa l'interfaccia Deque in modo da consentire operazioni da entrambe le estremità. Non consente valori nulli. È più veloce di Stack e LinkedList se implementato come Stack e LinkedList. ArrayDeque non ha limiti di dimensione man mano che cresce e si restringe secondo i requisiti. Non è sincronizzato, il che significa che non è thread-safe. Per mantenerlo thread-safe dobbiamo implementare una logica esterna.

Esempio

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

Produzione

HashMap

È l'implementazione dell'interfaccia Map supportata dalla tabella hash. Memorizza le coppie chiave-valore. Non consente valori nulli. Non è sincronizzato. Non garantisce mai l'ordine di inserzione. Fornisce prestazioni costanti nel tempo per metodi come get e put . Le sue prestazioni dipendono da due fattori: capacità iniziale e fattore di carico . La capacità è il numero di bucket nella tabella hash, quindi la capacità iniziale è il numero di bucket allocati al momento della creazione. Il fattore di carico è la misura di quanto una tabella hash può essere popolata prima che la sua capacità venga aumentata. Il metodo Rehash viene utilizzato per aumentare la capacità e raddoppia principalmente il numero di contenitori.

Esempio

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

Produzione

Algoritmi

Il framework Collections ci fornisce diversi algoritmi per diverse operazioni da applicare alle raccolte. Qui vedremo quali operazioni principali sono coperte da questi algoritmi. Contiene algoritmi relativi a:

1. Ordinamento
2. Ricerca
3. Mescolamento
4. Manipolazione di dati di routine
5. Composizione
6. Trovare valori estremi

Per una migliore comprensione discuteremo l'algoritmo di ordinamento.

Ordinamento

L'algoritmo di ordinamento riordina un elenco in base a una relazione di ordinamento. Sono previste due forme di relazione.

1. Ordinamento naturale
2. Ordinamento di confronto

Ordinamento naturale

Nell'ordinamento naturale una lista viene ordinata in base ai suoi elementi.

Ordinamento di confronto

In questa forma di ordinamento, insieme all'elenco viene passato un parametro aggiuntivo, che è un comparatore. Per l'ordinamento viene utilizzato un algoritmo di merge sort leggermente ottimizzato che è veloce e stabile poiché garantisce il tempo di esecuzione n log(n) e non riordina elementi uguali. Utilizzeremo lo stesso esempio di ArrayList per dimostrare l'ordinamento.

Esempio

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

Produzione

Conclusione

Ci auguriamo che a questo punto tu abbia capito cos'è il framework delle raccolte Java, quali sono le sue interfacce e classi e come implementare le sue diverse classi. Puoi sempre utilizzare questo framework per ridurre i tuoi sforzi in Java. Sentiti libero di esercitarti e di tornare qui ogni volta che hai bisogno di ulteriore assistenza. Buon apprendimento!