Classe ArrayList in Java

Ciao! Nelle lezioni precedenti, abbiamo esaminato in dettaglio una struttura di dati come un array e abbiamo esaminato esempi comuni di lavoro con essi. Ma questa struttura dei dati presenta una serie di svantaggi. La risposta a loro in Java è stata l'apparizione di ArrayList. Per dirla nel modo più semplice possibile, un ArrayList in Java è un array "aggiornato" con molte nuove funzionalità.

In che modo Java Arraylist è diverso dagli array normali?

In generale, gli array sono abbastanza convenienti e, come hai già notato, puoi fare molte cose con loro :) Tuttavia, gli array presentano anche una serie di svantaggi.

• Dimensioni limitate. Devi sapere già nella fase di creazione dell'array quante celle dovrebbe contenere. Se sottovaluti l'importo richiesto, non ci sarà abbastanza spazio. Se lo sopravvaluti, l’array rimarrà mezzo vuoto, e non è poi così male. Dopotutto, si scopre che gli assegnerai anche più memoria del necessario.
• Un array non ha metodi per aggiungere elementi. Devi sempre specificare esplicitamente l'indice della cella in cui vuoi aggiungere l'elemento. Se specifichi accidentalmente una cella già occupata con un valore desiderato, verrà sovrascritta.
• Non esistono metodi per rimuovere un elemento. Il 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("Hippopotamus");
       cats[2] = new Cat("Philip Markovich");

       cats[1] = null;



       System.out.println(Arrays.toString(cats));
   }

   @Override
   public String toString() {
       return "Cat{" +
               "name='" + name + '\'' +
               '}';
   }
}

Conclusione:

[Cat{name='Томас'}, null, Cat{name='Фorпп Маркович'}]

Tutte queste carenze possono essere eliminate utilizzando ArrayList. È creato in modo molto semplice:

ArrayList<Cat> cats = new ArrayList<Cat>();

Ora abbiamo creato un elenco per archiviare gli oggetti Cat. Fai attenzione:non specifichiamo la dimensione dell'ArrayList perché è automaticamente espandibile. Com'è possibile? Facilmente. Rimarrai sorpreso, ma ArrayList si basa su un array normale :) Sì, al suo interno c'è un array in cui sono memorizzati i nostri elementi. Ma ArrayList ha un meccanismo speciale per lavorarci:

• Quando questo array interno è pieno, ArrayList crea un nuovo array al suo interno. La sua dimensione = (dimensione del vecchio array * 1,5) +1.
• Tutti i dati vengono copiati dal vecchio array a quello nuovo
• Il vecchio array viene rimosso dal Garbage Collector.

Grazie a questo meccanismo, un ArrayList (al contrario di un array) implementa un metodo per aggiungere un nuovo elemento. Questo è un metodo add().

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<Cat>();
   cats.add(new Cat("Hippopotamus"));
}

Il nuovo elemento viene aggiunto alla fine dell'elenco. Ora non c'è rischio di traboccamento, quindi questo meccanismo è completamente sicuro. A proposito, ArrayList non solo può cercare un oggetto tramite indice, ma anche viceversa: può trovare l'indice di un oggetto nell'ArrayList facendo riferimento all'oggetto! Per fare ciò, implementa il metodo indexOf(): Gli passiamo un collegamento all'oggetto desiderato e indexOf()ci restituisce il suo indice:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   int thomasIndex = cats.indexOf(thomas);
   System.out.println(thomasIndex);
}

Conclusione:

0

Esatto, l'oggetto thomasè effettivamente memorizzato nella cella 0. Gli array non presentano solo svantaggi, ma anche indubbi vantaggi. Uno di questi sta cercando un elemento per indice. Poiché puntiamo a un indice, cioè a un indirizzo specifico in memoria, la ricerca nell'array è molto veloce. Anche ArrayList in Java può fare questo! Per fare ciò, implementa un metodo get():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   Cat secondCat = cats.get(1);

   System.out.println(secondCat);
}

Conclusione:

Cat{name='Бегемот'}

Inoltre, puoi facilmente scoprire se un ArrayList contiene o meno un oggetto particolare. Questo viene fatto utilizzando il metodo contains():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   cats.remove(pushok);
   System.out.println(cats.contains(pushok));
}

Il metodo controlla se l'elemento è contenuto nell'array interno di ArrayList e restituisce il risultato nel formato boolean- trueo false. Conclusione:

false

E un'altra cosa importante sull'inserimento. ArrayList ti consente di inserire dati non solo alla fine dell'array, ma anche in qualsiasi cella tramite indice. Ha due metodi per questo:

• add(int index, Cat element)
• set(int index, Cat element)

Ad entrambi si passa l'indice della cella in cui si desidera inserire e un collegamento all'oggetto stesso. La differenza è che incollare set()sovrascrive il vecchio valore memorizzato nella cella. E inserendo per add()primo si spostano tutti gli elementi a partire [index]dalla fine dell'array e si aggiunge l'oggetto necessario alla cella 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("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.set(0, philipp);//Now we have a list of 2 cats. We add the 3rd via set:

   System.out.println(cats.toString());
}

Conclusione:

[[Cat{name='Томас'}, Cat{name='Бегемот'}]
[Cat{name='Фorпп Маркович'}, Cat{name='Бегемот'}]

Avevamo una lista di 2 gatti, ne abbiamo inserito un altro tramite il metodo set()nella cella 0. Di conseguenza, il vecchio valore memorizzato in questa cella è stato sostituito con uno nuovo.

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.add(0, philipp);//Now we have a list of 2 cats. Add the 3rd via add

   System.out.println(cats.toString());
}

Ma ha add()funzionato diversamente. Ha spostato tutti gli elementi a destra e poi ha scritto il nuovo valore nella cella 0. Conclusione:

[Cat{name='Томас'}, Cat{name='Бегемот'}]
[Cat{name='Фorпп Маркович'}, Cat{name='Томас'}, Cat{name='Бегемот'}]

Per cancellare completamente l'elenco, utilizzare il metodo clear():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   cats.clear();

   System.out.println(cats.toString());
}

Conclusione:

[]

Tutti i contenuti sono stati rimossi dall'elenco. A proposito, fai attenzione: a differenza degli array, in ArrayList il metodo toString() viene sovrascritto e visualizza immediatamente la lista in formato stringa. Nel caso degli array abbiamo dovuto utilizzare la classe Arrays. E poiché ci siamo ricordati degli Array: in Java puoi facilmente “scambiare” tra un array e un ArrayList, cioè convertire l'uno nell'altro. La classe Arrays ha un metodo per questo, Arrays.asList(). Con il suo aiuto, otteniamo il contenuto dell'array come elenco e lo passiamo al costruttore del nostro ArrayList:

public static void main(String[] args) {

   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   Cat[] catsArray = {thomas, behemoth, philipp, pushok};

   ArrayList<Cat> catsList = new ArrayList<>(Arrays.asList(catsArray));
   System.out.println(catsList);
}

Conclusione:

[Cat{name='Томас'}, Cat{name='Бегемот'}, Cat{name='Фorпп Маркович'}, Cat{name='Пушок'}]

Puoi fare il contrario: ottenere un array da un oggetto ArrayList. Per fare ciò, utilizzare il metodo toArray():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();

   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   Cat[] catsArray = cats.toArray(new Cat[0]);

   System.out.println(Arrays.toString(catsArray));
}

Nota: abbiamo passato un array vuoto al metodo toArray(). 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. Per ora, ricordalo per il futuro (ma puoi anche trasferire una dimensione specifica, funzionerà). Parlando di dimensioni. La dimensione corrente dell'elenco può essere trovata utilizzando il metodo size():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   System.out.println(cats.size());
}

È importante capire qui che, a differenza della lengthproprietà array, il metodo ArrayList.size() restituisce esattamente il numero di elementi e non la capacità iniziale, perché non lo specifichiamo durante la creazione dell'ArrayList. A proposito, generalmente è possibile indicarlo. ArrayList ha un costruttore corrispondente. Ma il suo comportamento in termini di aggiunta di nuovi elementi non cambierà:

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("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   System.out.println(cats.size());
}

Uscita console:

4

Abbiamo creato una lista con 2 elementi, ma quando ne avevamo bisogno si espandeva facilmente. Un'altra cosa è che se inizialmente creassimo una lista molto piccola, bisognerà effettuare l'operazione di espansione più spesso, e questo consumerà una certa quantità di risorse. In questa lezione abbiamo appena accennato al processo di rimozione degli elementi da un ArrayList. Naturalmente ciò non è dovuto a dimenticanza. Questo argomento è stato separato in una lezione separata, che puoi leggere più avanti :)