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

CKTIS / Java

List.remove em Java: remover por índice ou por valor

Escolhe a sobrecarga certa de `List.remove`: uma devolve o elemento removido num dado índice e a outra indica se foi removida a primeira ocorrência do valor.

Versão: Java SE 21

Sintaxe

E remove(int index)
boolean remove(Object o)

List.remove(int) remove o elemento no índice indicado, contando a partir de zero, e devolve-o com o tipo E. O índice de cada elemento posterior diminui uma unidade. Se a lista suportar a remoção, um índice negativo ou maior ou igual a size() provoca IndexOutOfBoundsException.

List.remove(Object) remove apenas o primeiro elemento para o qual Objects.equals(o, element) devolve true. Devolve true se removeu um elemento ou false se não encontrou correspondência e a lista ficou inalterada. Ambas as sobrecargas são operações opcionais: uma lista que não suporta a remoção pode lançar UnsupportedOperationException. A sobrecarga Object também pode lançar ClassCastException se o tipo for incompatível ou NullPointerException se receber null e a lista não aceitar elementos nulos.

O compilador escolhe a sobrecarga com base no tipo do argumento em tempo de compilação. Numa List<Integer>, numbers.remove(1) remove o elemento no índice 1, ao passo que numbers.remove(Integer.valueOf(1)) procura o valor 1. Na segunda chamada, o argumento pode ser passado como Object, sem a conversão para um tipo primitivo (unboxing) exigida por um parâmetro int.

subList(from, to) devolve uma vista do intervalo [from, to), não uma cópia. Numa vista válida que suporte a remoção, window.remove(0) remove o primeiro elemento da vista também da lista subjacente. Se a lista subjacente sofrer uma alteração estrutural fora da vista, por exemplo através de um add direto, o comportamento da vista fica indefinido. Numa vista de ArrayList nesse estado, window.remove(0) pode lançar ConcurrentModificationException, mesmo num único thread. List não garante essa exceção. Cria uma nova vista ou faz uma cópia independente antes da alteração.

Exemplos

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

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>(List.of(1, 7, 1, 9, 1));

        Integer removed = numbers.remove(1);
        System.out.println("index: " + removed + " -> " + numbers);

        boolean found = numbers.remove(Integer.valueOf(1));
        System.out.println("value: " + found + " -> " + numbers);

        boolean missing = numbers.remove(Integer.valueOf(42));
        System.out.println("missing: " + missing + " -> " + numbers);

        List<Integer> window = numbers.subList(1, 3);
        Integer fromView = window.remove(0);
        System.out.println("view: " + fromView + " -> " + numbers);
    }
}

Resultado

index: 7 -> [1, 1, 9, 1]
value: true -> [1, 9, 1]
missing: false -> [1, 9, 1]
view: 9 -> [1, 1]

O índice `1` contém `7`. A chamada seguinte remove apenas o primeiro `1`, a ausência de `42` dá `false` e remover `9` através da vista altera a lista subjacente.

Lições relacionadas

  • Java · Lição 21 · Avançado · Versão: 2
  • Java · Lição 54 · Básico · Versão: 2

Fontes