Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Impara List e ArrayList in Java | Strutture Dati Fondamentali in Java
Strutture Dati Java

bookList e ArrayList in Java

Iniziamo la nostra introduzione alla struttura dati List. Di seguito è riportato un diagramma di flusso che illustra la gerarchia delle Collection e delle List. Potrebbe sembrare un diagramma ampio e complesso, ma lo analizzeremo passo dopo passo.

In questa sezione, esplorerai un tipo specifico di collection chiamato list. Esaminerai più da vicino diversi tipi di list, tra cui ArrayList, LinkedList e Stack.

Poiché tutte le list ereditano dall'interfaccia List, è possibile creare oggetti utilizzando l'interfaccia genitore. Ma approfondiremo questo aspetto più avanti.

Per ora, discutiamo il primo tipo di list: ArrayList.

Sopra, puoi vedere la sintassi per creare un ArrayList<>. C'è una parte che potrebbe non esserti familiare: il generics. Tratteremo i generics e come crearli più avanti.

Per ora, ricorda solo che quando crei un ArrayList, specifichi il tipo di dato tra parentesi angolari. Inoltre, tieni presente che le list non possono lavorare con tipi di dato primitivi. Invece, utilizziamo le wrapper class.

Ora, creiamo una list nel codice e aggiungiamo alcuni oggetti utilizzando il metodo add().

Main.java

Main.java

copy

              
1234567891011121314

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numberList = new ArrayList<>();
        numberList.add(10);
        numberList.add(15);
        numberList.add(5);
        System.out.println(numberList);
    }
}

Come puoi vedere, il metodo add() è molto semplice: aggiunge semplicemente il valore specificato alla lista.

Ricorda inoltre che è necessario importare List e ArrayList dalla libreria java.util. Tuttavia, se utilizzi IntelliJ IDEA, queste librerie vengono importate automaticamente, quindi non è necessario preoccuparsene.

Ora, vediamo un esempio di creazione di una lista con un nostro tipo di dato personalizzato:

Main.java

Main.java

copy

              
1234567891011121314151617181920212223242526272829303132333435

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        List<Dog> dogList = new ArrayList<>();
        dogList.add(bob);
        dogList.add(ben);
        dogList.add(brian);
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

Come puoi vedere, abbiamo creato una nostra classe Dog e un ArrayList utilizzando questo tipo di dato. Quando abbiamo stampato la lista, sono stati visualizzati tutti gli oggetti memorizzati al suo interno.

Cosa succede se hai un array e hai bisogno di convertirlo in una lista? Puoi farlo utilizzando il metodo asList() della classe Arrays.

Questo metodo consente di creare una lista che contiene gli stessi elementi dell'array originale. È particolarmente utile quando si desidera applicare i metodi delle liste a un array. La sintassi è semplice:

Arrays.asList(arrayName);

E puoi utilizzarlo direttamente durante l'inizializzazione di una nuova lista, ad esempio:

Main.java

Main.java

copy

              
12345678910111213141516171819202122232425262728293031323334

            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        Dog[] dogs = {bob, ben, brian};
        List<Dog> dogList = new ArrayList<>(Arrays.asList(dogs));
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

Così come è possibile convertire un array in una lista, è anche possibile convertire una lista in un array utilizzando il metodo toArray().

Metodi di ArrayList<>

Analisi dei principali metodi delle liste. Finora, le liste potevano essere facilmente sostituite dagli array, ma la differenza fondamentale risiede nei metodi.

Il metodo add() è un metodo sovraccarico, ovvero presenta più varianti. Una di queste consente di aggiungere un elemento in uno specifico indice.

Quando si inserisce un elemento nel mezzo di una lista, tutti gli elementi a destra si spostano di una posizione per fare spazio al nuovo elemento.

Ad esempio, se si aggiunge un elemento all'inizio della lista, tutti gli elementi esistenti si sposteranno di una posizione verso destra.

Ecco un esempio:

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 5; i++) { // Filling `numbers` list with 5 values
            numbers.add(i);
        }
        System.out.println("`numbers` before modifying: " + numbers);
        numbers.add(2, 10); // Adding 10 on the second index
        System.out.println("`numbers` after first modifying: " + numbers);
        numbers.add(0, 5);
        System.out.println("`numbers` after second modifying: " + numbers);
    }
}

Il modo in cui i valori si spostano durante l'inserimento di un elemento può essere visualizzato nella seguente illustrazione:

Recupero degli elementi

Ovviamente, se è possibile aggiungere oggetti a una lista in una posizione specifica, è anche possibile recuperare oggetti tramite il loro indice utilizzando il metodo get(int index).

Ecco un esempio:

Main.java

Main.java

copy

              
12345678910111213141516171819

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");
        names.add("Eva");

        // Retrieving element by index
        String element = names.get(2);  // Retrieving the 3rd element (index starts from 0)
        System.out.println("The element at index 2 is: " + element);
    }
}

Rimozione degli elementi

È possibile aggiungere, è possibile recuperare, ma si può anche eliminare? Certamente! È possibile rimuovere elementi utilizzando il metodo remove(int index).

Questo metodo è anche sovraccaricato, il che significa che esiste un altro modo per rimuovere un elemento. Si può utilizzare il metodo remove(Object obj), che elimina la prima occorrenza dell'elemento specificato.

Immaginiamo ora di avere un elenco ampio di tutti gli studenti del nostro corso. Tuttavia, uno studente si è comportato male ed è stato espulso. Non si conosce il suo indice esatto, quindi è necessario rimuoverlo per nome. Ma c'è un problema: il codice è leggermente difettoso e il suo nome potrebbe comparire più volte nell'elenco.

Scriviamo un programma per rimuovere tutte le occorrenze di questo studente dalla lista:

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        while (students.contains("Bob")) {
            students.remove("Bob");
        }
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Potresti aver notato che abbiamo utilizzato un altro metodo della lista—contains(Object obj). Questo metodo verifica se l'elemento specificato è presente nella lista e restituisce true o false.

Utilizzando contains(), impostiamo la condizione per il ciclo while, permettendoci di rimuovere tutte le occorrenze di uno studente come "Bob" dalla lista.

A proposito, è possibile semplificare notevolmente questo processo utilizzando il metodo removeAll(Collection<?> c):

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        List<String> expelledStudents = new ArrayList<>();
        expelledStudents.add("Bob");
        students.removeAll(expelledStudents);
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Il metodo removeAll() accetta una collezione come parametro, contenente i valori che verranno rimossi dalla lista su cui è stato chiamato il metodo.

In questo approccio, abbiamo creato una collezione di studenti espulsi e vi abbiamo aggiunto "Bob". Questo rende il nostro codice facilmente espandibile—basta aggiungere altri studenti problematici alla lista degli espulsi nel tempo.

Aggiornamento di un valore tramite indice

Torniamo ai metodi delle liste—ora è il momento del metodo di aggiornamento.

Poiché il metodo add() sposta semplicemente tutti gli elementi a destra quando si inserisce un nuovo valore, è necessario un metodo diverso per aggiornare un valore esistente tramite indice.

Il metodo set(int index, Object value) svolge proprio questa funzione:

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> example = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            example.add(i);
        }
        System.out.println("List before modification: " + example);
        example.set(2, 28);
        System.out.println("List after modification: " + example);
    }
}

È piuttosto semplice—abbiamo sostituito l'elemento al secondo indice con il numero 28.

Altri Metodi

Hai già esaminato i metodi più comuni, ma ce ne sono molti altri. Poiché vengono utilizzati raramente, non ci soffermeremo su ciascuno di essi.

Invece, puoi trovare tutti i metodi necessari—insieme alla documentazione completa e spiegazioni dettagliate—aprendo la classe ArrayList in IntelliJ IDEA.

Per farlo, importa semplicemente la libreria ArrayList, tieni premuto il Command key (Ctrl per Windows) e fai clic su ArrayList. Questo ti mostrerà tutti i campi e i metodi disponibili nella classe, aiutandoti a esplorare eventuali metodi che potresti aver trascurato.

1. Quale metodo possiamo utilizzare per aggiungere un elemento tramite indice?

2. Quale metodo possiamo utilizzare per recuperare un elemento tramite indice?

3. Quale metodo possiamo utilizzare per rimuovere la prima occorrenza di un elemento?

4. Quale metodo possiamo utilizzare per sostituire un elemento tramite indice?

5. Quale metodo possiamo utilizzare per verificare la presenza di un elemento?

6. Possiamo creare una lista da un array?

7. Come possiamo creare una lista da un array?

question mark

Quale metodo possiamo utilizzare per aggiungere un elemento tramite indice?

Select the correct answer

question mark

Quale metodo possiamo utilizzare per recuperare un elemento tramite indice?

Select the correct answer

question mark

Quale metodo possiamo utilizzare per rimuovere la prima occorrenza di un elemento?

Select the correct answer

question mark

Quale metodo possiamo utilizzare per sostituire un elemento tramite indice?

Select the correct answer

question mark

Quale metodo possiamo utilizzare per verificare la presenza di un elemento?

Select the correct answer

question mark

Possiamo creare una lista da un array?

Select the correct answer

question mark

Come possiamo creare una lista da un array?

Select the correct answer

Tutto è chiaro?

Come possiamo migliorarlo?

Grazie per i tuoi commenti!

Sezione 1. Capitolo 2

Chieda ad AI

expand

Chieda ad AI

ChatGPT

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Suggested prompts:

Can you explain the difference between ArrayList and LinkedList?

What are wrapper classes and why are they needed for lists?

Can you show more examples of using ArrayList methods?

bookList e ArrayList in Java

Scorri per mostrare il menu

Iniziamo la nostra introduzione alla struttura dati List. Di seguito è riportato un diagramma di flusso che illustra la gerarchia delle Collection e delle List. Potrebbe sembrare un diagramma ampio e complesso, ma lo analizzeremo passo dopo passo.

In questa sezione, esplorerai un tipo specifico di collection chiamato list. Esaminerai più da vicino diversi tipi di list, tra cui ArrayList, LinkedList e Stack.

Poiché tutte le list ereditano dall'interfaccia List, è possibile creare oggetti utilizzando l'interfaccia genitore. Ma approfondiremo questo aspetto più avanti.

Per ora, discutiamo il primo tipo di list: ArrayList.

Sopra, puoi vedere la sintassi per creare un ArrayList<>. C'è una parte che potrebbe non esserti familiare: il generics. Tratteremo i generics e come crearli più avanti.

Per ora, ricorda solo che quando crei un ArrayList, specifichi il tipo di dato tra parentesi angolari. Inoltre, tieni presente che le list non possono lavorare con tipi di dato primitivi. Invece, utilizziamo le wrapper class.

Ora, creiamo una list nel codice e aggiungiamo alcuni oggetti utilizzando il metodo add().

Main.java

Main.java

copy

              
1234567891011121314

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numberList = new ArrayList<>();
        numberList.add(10);
        numberList.add(15);
        numberList.add(5);
        System.out.println(numberList);
    }
}

Come puoi vedere, il metodo add() è molto semplice: aggiunge semplicemente il valore specificato alla lista.

Ricorda inoltre che è necessario importare List e ArrayList dalla libreria java.util. Tuttavia, se utilizzi IntelliJ IDEA, queste librerie vengono importate automaticamente, quindi non è necessario preoccuparsene.

Ora, vediamo un esempio di creazione di una lista con un nostro tipo di dato personalizzato:

Main.java

Main.java

copy

              
1234567891011121314151617181920212223242526272829303132333435

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        List<Dog> dogList = new ArrayList<>();
        dogList.add(bob);
        dogList.add(ben);
        dogList.add(brian);
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

Come puoi vedere, abbiamo creato una nostra classe Dog e un ArrayList utilizzando questo tipo di dato. Quando abbiamo stampato la lista, sono stati visualizzati tutti gli oggetti memorizzati al suo interno.

Cosa succede se hai un array e hai bisogno di convertirlo in una lista? Puoi farlo utilizzando il metodo asList() della classe Arrays.

Questo metodo consente di creare una lista che contiene gli stessi elementi dell'array originale. È particolarmente utile quando si desidera applicare i metodi delle liste a un array. La sintassi è semplice:

Arrays.asList(arrayName);

E puoi utilizzarlo direttamente durante l'inizializzazione di una nuova lista, ad esempio:

Main.java

Main.java

copy

              
12345678910111213141516171819202122232425262728293031323334

            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        Dog[] dogs = {bob, ben, brian};
        List<Dog> dogList = new ArrayList<>(Arrays.asList(dogs));
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

Così come è possibile convertire un array in una lista, è anche possibile convertire una lista in un array utilizzando il metodo toArray().

Metodi di ArrayList<>

Analisi dei principali metodi delle liste. Finora, le liste potevano essere facilmente sostituite dagli array, ma la differenza fondamentale risiede nei metodi.

Il metodo add() è un metodo sovraccarico, ovvero presenta più varianti. Una di queste consente di aggiungere un elemento in uno specifico indice.

Quando si inserisce un elemento nel mezzo di una lista, tutti gli elementi a destra si spostano di una posizione per fare spazio al nuovo elemento.

Ad esempio, se si aggiunge un elemento all'inizio della lista, tutti gli elementi esistenti si sposteranno di una posizione verso destra.

Ecco un esempio:

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 5; i++) { // Filling `numbers` list with 5 values
            numbers.add(i);
        }
        System.out.println("`numbers` before modifying: " + numbers);
        numbers.add(2, 10); // Adding 10 on the second index
        System.out.println("`numbers` after first modifying: " + numbers);
        numbers.add(0, 5);
        System.out.println("`numbers` after second modifying: " + numbers);
    }
}

Il modo in cui i valori si spostano durante l'inserimento di un elemento può essere visualizzato nella seguente illustrazione:

Recupero degli elementi

Ovviamente, se è possibile aggiungere oggetti a una lista in una posizione specifica, è anche possibile recuperare oggetti tramite il loro indice utilizzando il metodo get(int index).

Ecco un esempio:

Main.java

Main.java

copy

              
12345678910111213141516171819

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");
        names.add("Eva");

        // Retrieving element by index
        String element = names.get(2);  // Retrieving the 3rd element (index starts from 0)
        System.out.println("The element at index 2 is: " + element);
    }
}

Rimozione degli elementi

È possibile aggiungere, è possibile recuperare, ma si può anche eliminare? Certamente! È possibile rimuovere elementi utilizzando il metodo remove(int index).

Questo metodo è anche sovraccaricato, il che significa che esiste un altro modo per rimuovere un elemento. Si può utilizzare il metodo remove(Object obj), che elimina la prima occorrenza dell'elemento specificato.

Immaginiamo ora di avere un elenco ampio di tutti gli studenti del nostro corso. Tuttavia, uno studente si è comportato male ed è stato espulso. Non si conosce il suo indice esatto, quindi è necessario rimuoverlo per nome. Ma c'è un problema: il codice è leggermente difettoso e il suo nome potrebbe comparire più volte nell'elenco.

Scriviamo un programma per rimuovere tutte le occorrenze di questo studente dalla lista:

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        while (students.contains("Bob")) {
            students.remove("Bob");
        }
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Potresti aver notato che abbiamo utilizzato un altro metodo della lista—contains(Object obj). Questo metodo verifica se l'elemento specificato è presente nella lista e restituisce true o false.

Utilizzando contains(), impostiamo la condizione per il ciclo while, permettendoci di rimuovere tutte le occorrenze di uno studente come "Bob" dalla lista.

A proposito, è possibile semplificare notevolmente questo processo utilizzando il metodo removeAll(Collection<?> c):

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        List<String> expelledStudents = new ArrayList<>();
        expelledStudents.add("Bob");
        students.removeAll(expelledStudents);
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Il metodo removeAll() accetta una collezione come parametro, contenente i valori che verranno rimossi dalla lista su cui è stato chiamato il metodo.

In questo approccio, abbiamo creato una collezione di studenti espulsi e vi abbiamo aggiunto "Bob". Questo rende il nostro codice facilmente espandibile—basta aggiungere altri studenti problematici alla lista degli espulsi nel tempo.

Aggiornamento di un valore tramite indice

Torniamo ai metodi delle liste—ora è il momento del metodo di aggiornamento.

Poiché il metodo add() sposta semplicemente tutti gli elementi a destra quando si inserisce un nuovo valore, è necessario un metodo diverso per aggiornare un valore esistente tramite indice.

Il metodo set(int index, Object value) svolge proprio questa funzione:

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> example = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            example.add(i);
        }
        System.out.println("List before modification: " + example);
        example.set(2, 28);
        System.out.println("List after modification: " + example);
    }
}

È piuttosto semplice—abbiamo sostituito l'elemento al secondo indice con il numero 28.

Altri Metodi

Hai già esaminato i metodi più comuni, ma ce ne sono molti altri. Poiché vengono utilizzati raramente, non ci soffermeremo su ciascuno di essi.

Invece, puoi trovare tutti i metodi necessari—insieme alla documentazione completa e spiegazioni dettagliate—aprendo la classe ArrayList in IntelliJ IDEA.

Per farlo, importa semplicemente la libreria ArrayList, tieni premuto il Command key (Ctrl per Windows) e fai clic su ArrayList. Questo ti mostrerà tutti i campi e i metodi disponibili nella classe, aiutandoti a esplorare eventuali metodi che potresti aver trascurato.

1. Quale metodo possiamo utilizzare per aggiungere un elemento tramite indice?

2. Quale metodo possiamo utilizzare per recuperare un elemento tramite indice?

3. Quale metodo possiamo utilizzare per rimuovere la prima occorrenza di un elemento?

4. Quale metodo possiamo utilizzare per sostituire un elemento tramite indice?

5. Quale metodo possiamo utilizzare per verificare la presenza di un elemento?

6. Possiamo creare una lista da un array?

7. Come possiamo creare una lista da un array?

question mark

Quale metodo possiamo utilizzare per aggiungere un elemento tramite indice?

Select the correct answer

question mark

Quale metodo possiamo utilizzare per recuperare un elemento tramite indice?

Select the correct answer

question mark

Quale metodo possiamo utilizzare per rimuovere la prima occorrenza di un elemento?

Select the correct answer

question mark

Quale metodo possiamo utilizzare per sostituire un elemento tramite indice?

Select the correct answer

question mark

Quale metodo possiamo utilizzare per verificare la presenza di un elemento?

Select the correct answer

question mark

Possiamo creare una lista da un array?

Select the correct answer

question mark

Come possiamo creare una lista da un array?

Select the correct answer

Tutto è chiaro?

Come possiamo migliorarlo?

Grazie per i tuoi commenti!

Sezione 1. Capitolo 2
some-alt