# Java List: i metodi e le applicazioni più importanti

Un elenco Java è particolarmente adatto a scenari in cui la **dimensione dell’insieme di dati** non è nota in anticipo o può cambiare nel tempo. Ti mostreremo esempi concreti di utilizzo degli elenchi e di quali operazioni è possibile eseguire con essi.

## A cosa servono gli elenchi Java?

Gli elenchi sono una delle strutture dati di base della programmazione Java e hanno un’ampia gamma di applicazioni. Contengono elementi in una **sequenza ordinata** che possono essere aggiunti, modificati, cancellati o interrogati. In un elenco Java, è possibile avere oggetti di classi diverse. È anche possibile memorizzare elementi duplicati o nulli. Inoltre, queste liste supportano classi e metodi generici, il che garantisce la sicurezza dei tipi.

Uno degli ambiti d’uso degli elenchi è nelle applicazioni di database, dove sono utilizzati per memorizzare e accedere ai **dati restituiti dalle query**. Nelle interfacce grafiche, gli elenchi Java sono spesso utilizzati per visualizzare una lista di elementi, ad esempio le opzioni di un menu a discesa o i diversi articoli di un negozio online.

Gli elenchi Java sono indispensabili anche negli algoritmi e nelle strutture di dati. Vengono utilizzati nell’implementazione di **algoritmi di ordinamento, algoritmi di ricerca o strutture di stack e code**. Nelle applicazioni di rete, gli elenchi possono contribuire a facilitare la gestione delle connessioni e dei socket.

## I metodi dell’elenco Java

Java List appartiene all’interfaccia `Collection` e deve essere importato dal pacchetto **java.util**. Le classi di implementazione includono gli [ArrayList in Java](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/arraylist-in-java/), LinkedList, Vector e Stack. È possibile dichiarare le varie istanze dell’elenco come segue:

```Java
List linkedList = new LinkedList(); // LinkedList
List arrayList = new ArrayList(); // ArrayList
List vecList = new Vector(); // Vector
List stackList = new Stack(); //Stack
```

Di seguito ti presentiamo alcuni dei metodi più importanti utilizzati in relazione agli elenchi Java:

1. `int size()`: determina il numero di elementi di un elenco.
2. `void add(int index, E element)`: aggiunge un elemento in una posizione specifica.
3. `boolean isEmpty()`: verifica se l’elenco è vuoto.
4. `void clear()`: rimuove tutti gli elementi dall’elenco.
5. `boolean contains(Object o)`: restituisce il valore `true` se contiene l’oggetto `o`.
6. `boolean add(E e)`: aggiunge l’elemento specificato alla fine dell’elenco.
7. `boolean remove(Object o)`: rimuove la prima occorrenza di un particolare elemento.
8. `E get(int index)`: restituisce l’elemento all’indice indicato.
9. `E set(int index, E element)`: sostituisce o inserisce un elemento al rispettivo indice.
10. `Object[] toArray()`: restituisce un array con gli elementi dell’elenco.
11. `List<E> subList(int fromIndex, int toIndex)`: restituisce una sottolista che comprende gli elementi nell’intervallo specificato.
12. `default void replaceAll(UnaryOperator<E> operator)`: metodo standard in Java 8 che applica gli [operatori Java](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/operatori-java/) unari a ciascun elemento e sostituisce il risultato con il rispettivo elemento.

## Casi d’uso tipici degli elenchi Java

Di seguito vengono illustrati gli usi più comuni di un elenco Java. Tra questi, le **conversioni** da array a elenchi e viceversa, nonché l’ordinamento, il recupero o la modifica di elementi.

### Convertire un array in un elenco

Per convertire in un array, puoi eseguire un ciclo attraverso un elenco e utilizzare il metodo `.add()` per aggiungere gli elementi all’array uno per uno.

```Java
import java.util.*;
    public class ArrayToList{
      public static void main(String args[]){
      // Creating Array
      String[] colors={"blue","green","red","yellow"};
      System.out.println("Array: "+Arrays.toString(colors));
      //Converting Array to List
      List<String> list=new ArrayList<String>();
      for(String color: colors){
        list.add(color);
      }
      System.out.println("List: "+list);
      }
    }
```

Il risultato è il seguente:

```Java
Array: [blue, green, red, yellow]
List: [blue, green, red, yellow]
```

### Convertire un elenco in un array

Un elenco può essere convertito in un array con il metodo `toArray()`:

```Java
import java.util.*;
    public class ListToArray{
      public static void main(String args[]){
       List<String> days = new ArrayList<String>();
       days.add("Monday");
       days.add("Tuesday");
       days.add("Wednesday");
       days.add("Thursday");
       days.add("Friday");
       days.add("Saturday");
       days.add("Sunday");
       // Converting ArrayList to Array
       String[] array = days.toArray(new String[days.size()]);
       System.out.println("Array: "+Arrays.toString(array));
       System.out.println("List: "+days);
      }
    }
```

Dal risultato si nota che i contenuti dell’array e dell’elenco sono identici:

```Java
Array: [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]
List: [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]
```

### Recuperare e modificare gli elementi di un elenco Java

Con il metodo `get()` si può accedere a un elemento in un indice specifico, mentre con `set()` un oggetto può essere sostituito in una posizione specificata.

```Java
import java.util.*;
    public class ListExample{
      public static void main(String args[]){
      // Creating a List
      List<String> letters=new ArrayList<String>();
      // Adding elements
      letters.add("a");
      letters.add("b");
      letters.add("c");
      // get()
      System.out.println("Element at index 1: "+letters.get(1));
      // set()
      letters.set(2, "d");
      for(String letter: letters)
      System.out.println(letter);
      }
    }
```

Poiché in Java il conteggio inizia dall’indice 0, si ottiene il seguente risultato:

```Java
Element at index 1: b
a
b
d
```

### Ordinare un elenco

Per ordinare un elenco Java, possiamo utilizzare il metodo `.sort()` della classe `Collection`. Si itera l’elenco con un ciclo e si visualizzano gli elementi nella console in ordine:

```Java
import java.util.*;
    class SortArrayList{
      public static void main(String args[]){
      // Creating a list of numbers
      List<Integer> numbers=new ArrayList<Integer>();
      numbers.add(4);
      numbers.add(57);
      numbers.add(92);
      numbers.add(26);
      // Sorting
      Collections.sort(numbers);
      for(Integer number: numbers)
        System.out.println(number);
      }
    }
```

I numeri dell’elenco Java vengono visualizzati sullo schermo in ordine crescente:

```Java
4
26
57
92
```


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/elenco-java-java-list/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/elenco-java-java-list/) for AI/LLM consumption.