Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

List.of e List.of() — listas não modificáveis

`List.of` cria uma lista não modificável a partir dos elementos fornecidos. Sem argumentos, `List.of()` devolve uma lista vazia. Nenhuma sobrecarga aceita elementos `null`.

Versão: Java SE 21

Sintaxe

import java.util.List;

List<E> empty = List.of();
List<E> values = List.of(e1, e2);

// Factory method signatures (E is the element type):
// static <E> List<E> of()
// static <E> List<E> of(E e1, ..., E eN)  [one overload for each N from 1 to 10]
// static <E> List<E> of(E... elements)

List.of é uma família de métodos de fábrica estáticos da interface java.util.List, disponível desde Java 9. List.of() é a sobrecarga sem argumentos: devolve uma lista vazia e não modificável que podes passar quando se espera uma lista mas não há elementos a fornecer. Em List<String> empty = List.of();, Java infere o tipo dos elementos a partir do tipo declarado da variável.

Existem sobrecargas com um número fixo de parâmetros para 1 a 10 elementos e uma sobrecarga de argumentos variáveis, of(E... elements), para qualquer número de elementos. A lista mantém a ordem dos argumentos e admite duplicados. Se algum dos elementos fornecidos for null, a chamada lança NullPointerException em vez de devolver uma lista.

Chamar add, remove ou set na lista devolvida lança UnsupportedOperationException, mesmo que a lista esteja vazia. O facto de a lista não ser modificável não torna imutáveis os objetos que contém. Para acrescentar, remover ou substituir elementos, cria uma cópia superficial e modificável com new ArrayList<>(source).

Exemplos

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

public class ListOfDemo {
    public static void main(String[] args) {
        List<String> empty = List.of();
        List<String> colors = List.of("red", "blue", "red");
        System.out.println("Empty size: " + empty.size());
        System.out.println("Colors: " + String.join(", ", colors));

        try {
            colors.set(0, "green");
        } catch (UnsupportedOperationException expected) {
            System.out.println("UnsupportedOperationException");
        }

        try {
            List.of("red", null);
        } catch (NullPointerException expected) {
            System.out.println("NullPointerException");
        }

        List<String> editable = new ArrayList<>(empty);
        editable.add("green");
        System.out.println("Mutable copy: " + editable.get(0));
        System.out.println("Original size: " + empty.size());
    }
}

Resultado

Empty size: 0
Colors: red, blue, red
UnsupportedOperationException
NullPointerException
Mutable copy: green
Original size: 0

O exemplo mostra uma lista vazia, a preservação da ordem e dos duplicados e duas exceções distintas. Acrescentar um elemento à cópia modificável não altera a lista vazia original.

Lições relacionadas

  • Java · Lição 67 · Básico · Versão: 2
  • Java · Lição 34 · Intermédio · Versão: 2
  • Java · Lição 43 · Intermédio · Versão: 2

Fontes