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, LinkedList, Vector e Stack. È possibile dichiarare le varie istanze dell’elenco come segue:

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 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.

    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:

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():

    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:

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.

    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:

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:

    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:

4
26
57
92