Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

java.util.List — una raccolta ordinata di elementi

List<E> descrive una raccolta ordinata con indici a partire da zero, che di solito ammette duplicati. Scopri come leggere, aggiungere e rimuovere elementi e come distinguere una lista modificabile da una copia non modificabile e da una vista di intervallo.

Versione: Java SE 21; repository runtime, production runtime not attested

Sintassi

List<E> list = new ArrayList<>();
List<E> values = List.of(e1, e2);
List<E> snapshot = List.copyOf(list);

java.util.List<E> è un’interfaccia per raccolte ordinate che di solito ammettono duplicati; E indica il tipo degli elementi. ArrayList è un’implementazione modificabile. List.size() restituisce il numero di elementi e List.isEmpty() verifica se la lista è vuota. List.get(i) legge un elemento; gli indici validi soddisfano 0 <= i < size().

List.add(e) aggiunge un elemento in fondo, mentre List.add(i, e) lo inserisce alla posizione i; è consentito anche i == size(). List.addAll(c) aggiunge gli elementi nell’ordine di iterazione della raccolta; List.addAll(i, c) li inserisce alla posizione indicata. List.set(i, e) sostituisce un elemento e restituisce il valore precedente, senza modificare la dimensione. List.clear() rimuove tutti gli elementi.

List.contains(o) verifica la presenza usando l’uguaglianza, mentre List.indexOf(o) restituisce il primo indice oppure -1. List.remove(i) rimuove e restituisce l’elemento all’indice indicato; List.remove(o) rimuove la prima occorrenza uguale e segnala se la lista è cambiata. Per List<Integer>, remove(1) rimuove in base all’indice, mentre remove(Integer.valueOf(1)) rimuove in base al valore.

List.of(...) crea una lista non modificabile; List.copyOf(c) fornisce un’istantanea non modificabile che non risente di successive aggiunte, rimozioni o sostituzioni di elementi nella raccolta di origine. Entrambe le factory rifiutano null. Non eseguono una copia profonda degli elementi: gli oggetti contenuti possono comunque cambiare. Le operazioni di modifica sono facoltative nell’interfaccia; le liste create da queste factory lanciano UnsupportedOperationException se si tenta di modificarle.

List.subList(from, to) restituisce una vista di [from, to), non una copia indipendente. Le modifiche supportate tramite la vista influiscono sulla lista sottostante; subList(from, to).clear() rimuove l’intervallo. Una modifica strutturale della lista sottostante al di fuori della vista rende indefinita la semantica della vista. In Java 21, ArrayList lancia IndexOutOfBoundsException se from < 0 o to > size(). In caso contrario, se from > to, il metodo lancia IllegalArgumentException.

Esempi

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

public class Main {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>(List.of("A", "B"));
        items.add("C");
        items.addAll(List.of("D", "E"));
        System.out.println(items.size() + " " + items.get(0));
        System.out.println(items.set(1, "X"));
        System.out.println(items.contains("X") + " " + items.indexOf("X"));
        System.out.println(items.remove(0));
        System.out.println(items.remove("E"));
        List<String> snapshot = List.copyOf(items);
        items.subList(1, 3).clear();
        System.out.println(items);
        System.out.println(snapshot);
        items.clear();
        System.out.println(items.isEmpty());
    }
}

Risultato

5 A
B
true 1
A
true
[X]
[X, C, D]
true

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti