CIAO! Nelle lezioni precedenti, abbiamo approfondito gli array e rivisto esempi comuni di utilizzo degli array. In questa lezione, esamineremo più da vicino Java ArrayList. In generale, gli array sono super utili. E, come hai già notato, puoi fare molto con loro :) Ma gli array hanno una serie di carenze.
Dimensioni limitate. Devi sapere quanti elementi deve contenere il tuo array nel momento in cui lo crei. Se sottovaluti, non avrai abbastanza spazio. Sopravvalutare e l'array rimarrà mezzo vuoto, il che è anche un male. Dopotutto, stai ancora allocando più memoria del necessario.
Un array non ha metodi per aggiungere elementi. Devi sempre indicare esplicitamente l'indice della posizione in cui vuoi aggiungere un elemento. Se specifichi accidentalmente l'indice per una posizione occupata da un valore di cui hai bisogno, verrà sovrascritto.
Non ci sono metodi per eliminare un elemento. Un valore può essere solo "azzerato".
public class Cat {
private String name;
public Cat(String name) {
this.name = name;
}
public static void main(String[] args) {
Cat[] cats = new Cat[3];
cats[0] = new Cat("Thomas");
cats[1] = new Cat("Behemoth");
cats[2] = new Cat("Lionel Messi");
cats[1] = null;
System.out.println(Arrays.toString(cats));
}
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
'}';
}
}
Output: [Cat{name='Thomas'}, null, Cat{name='Lionel Messi'}] Fortunatamente, i creatori di Java sono ben consapevoli dei vantaggi e degli svantaggi degli array e quindi hanno creato una struttura dati molto interessante chiamata Java ArrayList . Parlando nel modo più semplice possibile, un Java ArrayList è un array "truccato" con molte nuove funzionalità.
Come creare un ArrayList
È molto facile creare:
ArrayList<Cat> cats = new ArrayList<Cat>();
Ora abbiamo creato un elenco per memorizzare gli oggetti Cat . Si noti che non stiamo specificando la dimensione di ArrayList , perché può espandersi automaticamente. Com'è possibile? È abbastanza semplice, in realtà. Potrebbe sorprenderti, ma ArrayList in Java è costruito sopra un array molto ordinario :) Sì, contiene un array, ed è lì che sono memorizzati i nostri elementi. Ma ArrayList in Java ha un modo speciale di lavorare con quell'array:
Quando l'array interno è pieno, ArrayList crea un nuovo array internamente. La dimensione del nuovo array è la dimensione del vecchio array per 1,5 più 1.
Tutti i dati vengono copiati dal vecchio array in quello nuovo
Il vecchio array viene ripulito dal Garbage Collector.
Questo meccanismo consente a Java ArrayList (a differenza di un normale array) di implementare un metodo per aggiungere nuovi elementi. È il add()metodo
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<Cat>();
cats.add(new Cat("Behemoth"));
}
I nuovi elementi vengono aggiunti alla fine dell'elenco. Ora non c'è alcun rischio di traboccare l'array, quindi questo metodo è completamente sicuro. A proposito, ArrayList non solo può trovare un oggetto in base al suo indice, ma anche viceversa: può utilizzare un riferimento per trovare l'indice di un oggetto in ArrayList ! Ecco a cosa serve il metodo indexOf() : passiamo un riferimento all'oggetto che vogliamo e indexOf() restituisce il suo indice:
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
int thomasIndex = cats.indexOf(thomas);
System.out.println(thomasIndex);
}
Uscita: 0 Esatto. Il nostro oggetto thomas è effettivamente memorizzato nell'elemento 0. Gli array non hanno solo svantaggi. Hanno anche indiscutibili vantaggi. Uno di questi è la possibilità di cercare elementi per indice. Poiché puntiamo a un indice, cioè a uno specifico indirizzo di memoria, la ricerca di un array in questo modo è molto rapida. ArrayListsa anche come farlo! Il metodo get() implementa questo:
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
Cat secondCat = cats.get(1);
System.out.println(secondCat);
}
Output: Cat{name='Behemoth'} Inoltre, puoi facilmente scoprire se ArrayList contiene un particolare oggetto. Questo viene fatto usando il metodo ArrayList contains():
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
cats.remove(fluffy);
System.out.println(cats.contains(fluffy));
}
Il metodo controlla se l' array interno di ArrayList contiene l'elemento e restituisce un valore booleano (vero o falso). Output: false E un'altra cosa importante sull'inserimento. ArrayList ti consente di utilizzare un indice per inserire elementi non solo alla fine dell'array, ma ovunque. Ha due metodi per questo:
ArrayList add(indice int, elemento Cat)
ArrayList set(indice int, elemento Cat)
Come argomenti, entrambi questi metodi prendono l'indice della posizione in cui si desidera inserire e un riferimento all'oggetto stesso. La differenza è che l'inserimento usando set() sovrascrive il vecchio valore. L'inserimento utilizzando add() prima sposta di uno tutti gli elementi da [index] alla fine dell'array, quindi aggiunge l'oggetto specificato nella posizione vuota risultante.
Ecco un esempio:
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
System.out.println(cats.toString());
cats.set(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using set
System.out.println(cats.toString());
}
Output: [[Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Behemoth'}] Avevamo una lista di 2 gatti . Poi ne abbiamo inserito un altro come elemento 0 usando il metodo set() . Di conseguenza, il vecchio elemento è stato sostituito da uno nuovo.
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
System.out.println(cats.toString());
cats.add(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using add
System.out.println(cats.toString());
}
E qui vediamo che add() funziona in modo diverso. Sposta tutti gli elementi a destra e quindi scrive il nuovo valore come elemento 0. Output: [Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Thomas'}, Cat{name='Behemoth'}] Per cancellare completamente l'elenco, usiamo il metodo clear() :
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
cats.clear();
System.out.println(cats.toString());
}
Output: [] Tutto è stato rimosso dall'elenco. A proposito, si prega di notare: a differenza degli array, ArrayList sovrascrive il metodo toString() e visualizza già l'elenco in modo appropriato come stringhe. Con gli array ordinari, abbiamo dovuto usare la classe Arrays per questo. E poiché ho menzionato Arrays : Java ti consente di "passare" facilmente da un array a un ArrayList , ovvero convertirne uno in un altro. La classe Arrays ha un metodo Arrays.asList() per questo. Lo usiamo per ottenere i contenuti come un array e passarli al nostro costruttore ArrayList :
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
Cat[] catsArray = {thomas, behemoth, lionel, fluffy};
ArrayList<Cat> catsList = new ArrayList<>(Arrays.asList(catsArray));
System.out.println(catsList);
}
Output: [Cat{name='Thomas'}, Cat{name='Behemoth'}, Cat{name='Lionel Messi'}, Cat{name='Fluffy'}] Puoi anche andare nella direzione opposta: prendi un array da un oggetto ArrayList . Lo facciamo usando il metodo toArray() :
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
Cat[] catsArray = cats.toArray(new Cat[0]);
System.out.println(Arrays.toString(catsArray));
}
Nota: abbiamo passato un array vuoto al metodo toArray() . Questo non è un errore. All'interno della classe ArrayList , questo metodo è implementato in modo tale che il passaggio di un array vuoto ne aumenti le prestazioni. Tienilo a mente per il futuro (ovviamente puoi passare un array di una dimensione specifica; anche questo funzionerà). Oh, circa le dimensioni. La dimensione attuale della lista può essere trovata usando il metodo size() :
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
System.out.println(cats.size());
}
È importante comprendere che, a differenza della proprietà length di un array , il metodo ArrayList.size() restituisce il numero effettivo di elementi, non la capacità originale. Dopotutto, non abbiamo specificato una dimensione durante la creazione di ArrayList . Tuttavia, puoi specificarlo: ArrayList ha un costruttore adatto. Ma in termini di aggiunta di nuovi elementi, questo non cambia il suo comportamento:
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>(2);// create an ArrayList with an initial capacity of 2
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
System.out.println(cats.size());
}
Output della console: 4 Abbiamo creato un elenco di 2 elementi, ma si è espanso silenziosamente quando ne avevamo bisogno. Un'altra considerazione è che se creiamo inizialmente un elenco molto piccolo, dovrà espandersi più spesso, il che utilizzerà alcune risorse. In questa lezione non abbiamo quasi toccato il processo di rimozione degli elementi da un ArrayList Naturalmente, questo non è dovuto al fatto che ci sia sfuggito di mente. Abbiamo inserito questo argomento in una lezione separata che incontrerai più tardi :) Per rafforzare ciò che hai imparato, ti suggeriamo di guardare una lezione video dal nostro corso Java
GO TO FULL VERSION