Collezioni in Java: ArrayList

1. ArrayListclasse

Oggi esploreremo la ArrayListclasse. Questa è la prima di diverse classi note come raccolte . In Java, le collezioni sono un argomento così ampio e utile che a loro è dedicata un'intera ricerca di CodeGym.

Per comprendere appieno come sono strutturate le raccolte e tutte le loro sfumature, devi prima imparare OOP, interfacce, ereditarietà, le basi del multithreading e molto altro.

Quindi oggi faremo solo conoscenza con il tipo più semplice di raccolta. Ma a un livello abbastanza profondo da farti capire come usarlo e come funziona. Allora, incontra la ArrayListcollezione .

Il retroscena

Inizierò con un piccolo background. Ai programmatori non piaceva davvero un aspetto degli array: il fatto che la loro dimensione non può essere modificata. Cosa succede se devi memorizzare altri tre elementi in un array, ma c'è solo una cella vuota?

L'unica soluzione ai limiti di spazio di un array era creare un array molto grande per contenere tutti gli elementi che potresti aver bisogno di memorizzare. Ma questo di solito era uno spreco di memoria. Se un array di solito conteneva due o tre elementi ma c'era anche una minima possibilità che fosse necessario memorizzarne 100, allora era necessario creare un array con la capacità di memorizzarne 100.

Quindi cosa hanno escogitato i programmatori? Hanno scritto la ArrayListclasse, che ha svolto lo stesso lavoro della Arrayclasse, ma era ridimensionabile.

Classe ArrayList

Il nome della ArrayListclasse è formato da due parole: Array + List. Arrayè un array ed Listè una lista.

Ogni ArrayListoggetto contiene un normale array di elementi. Quando leggi elementi da un ArrayList, l'oggetto li recupera dal suo array interno. Quando scrivi elementi, li scrive nell'array interno.

La classe ArrayList non ha tutti gli svantaggi che hanno gli array. Sa come:

• Memorizza elementi di un tipo specifico
• Ridimensiona dinamicamente l'elenco
• Aggiungi elementi alla fine dell'elenco
• Inserisci gli elementi all'inizio o al centro dell'elenco
• Rimuovi gli elementi da qualsiasi punto dell'elenco

Per maggiori dettagli, vedere di seguito:

2. Creare un ArrayListoggetto

Per creare un ArrayListoggetto, devi scrivere un codice come questo:

ArrayList<TypeParameter> name = new ArrayList<TypeParameter>();

Dove ArrayListè il tipo/classe della raccolta, TypeParameterè il tipo degli elementi memorizzati nella ArrayListraccolta ed nameè il nome di una ArrayList<TypeParameter>variabile.

La namevariabile ha un tipo generico. Si compone di due tipi: prima viene indicato il tipo della raccolta, quindi vengono utilizzate parentesi angolari per indicare il tipo degli elementi memorizzati nella raccolta.

Esempi:

ArrayList<Integer> list = new ArrayList<Integer>();

ArrayList<String> list = new ArrayList<String>();

ArrayList<Double> list = new ArrayList<Double>();

A differenza degli array, le raccolte non possono memorizzare tipi primitivi, solo tipi di riferimento . Quindi, se hai bisogno di una raccolta di int, usa Integerinvece la classe wrapper.

3. Operazioni con anArrayList

Inizialmente, la lunghezza dell'elenco appena creato è zero, poiché contiene 0 elementi. Se aggiungi un elemento all'elenco, la sua lunghezza aumenta di 1. Se rimuovi l'elemento aggiunto, la lunghezza torna a zero.

La seguente tabella può insegnarti di più sui metodi della ArrayListclasse:

void add(Type value)

void add(int index, Type value)

Type get(int index)

void set(int index, Type value)

Type remove(int index)

Type remove(Type value)

void clear()

boolean contains(Type value)

boolean isEmpty()

int size()

Type[] toArray(Type[] array)

Questi metodi ti consentono di fare quasi tutto ciò che potresti desiderare con l'elenco: scambiare elementi, aggiungere elementi e rimuovere elementi. Puoi cancellare l'elenco con un singolo comando o persino convertire l'elenco in un array.

4. Confronto di ArrayListeArray

Non credo che possiamo evitare il confronto ArrayListe un array.

Ci sono solo 4 azioni che puoi eseguire con gli array:

• Crea una matrice
• Ottieni un elemento per indice
• Imposta un elemento per indice
• Ottieni la lunghezza dell'array

Ecco queste operazioni che si applicano a un array e a un ArrayList:

String[] array = new String[10];

ArrayList<String> list = new  ArrayList<String>();

String s = array[0];

String s = list.get(0);

array[0] = "Bye";

list.set(0, "Bye");

int count = array.length;

int count = list.size();

Confrontiamo come ArrayListfunziona un rispetto a come funziona un array. Ad esempio, implementiamo questa attività: "leggi 10 stringhe dalla tastiera e visualizzale sullo schermo in ordine inverso"

Scanner console = new Scanner(System.in);

// Read strings from the keyboard
String[] list = new String[10];

for (int i = 0; i < list.length; i++)
{
    String s = console.nextLine();
    list[i] = s;
}

// Display the contents of the array on the screen
for (int i = 0; i < list.length; i++)
{
    int j = list.length - i - 1;
    System.out.println(list[j]);
}

Scanner console = new Scanner(System.in);

// Read strings from the keyboard
ArrayList<String> list = new ArrayList<String>();

for (int i = 0; i < 10; i++)
{
    String s = console.nextLine();
    list.add(s);
}

// Display the contents of the collection on the screen
for (int i = 0; i < list.size(); i++)
{
    int j = list.size() - i - 1;
    System.out.println(list.get(j));
}

L'analogia è chiara. Tutto è in qualche modo più breve e più chiaro per gli array. Ma ArrayListnon è neanche difficile: per ottenere un elemento, usiamo il get()metodo; cambiare un elemento, il set()metodo; per ottenere la lunghezza dell'elenco, il size()metodo.

Allora perché i programmatori usano la ArrayListclasse?

Il punto centrale, ovviamente, sono tutti gli altri metodi che gli array ordinari non hanno:

• Aggiungi un elemento all'elenco
• Aggiungi un elemento al centro dell'elenco
• Trova un elemento nell'elenco
• Rimozione di un elemento da un elenco