HOWTO · Java
Remova o elemento do array e, em seguida, mude os outros elementos em Java
Este artigo apresenta como remover o elemento de um array e deslocar a matriz.
Nesta página
Os arrays Java têm comprimento fixo. Deslocar os valores para a esquerda fecha uma lacuna, mas não encurta o array. Para retornar um array com um elemento a menos, crie um array menor ou use uma coleção redimensionável. Os exemplos abaixo removem um elemento pelo índice baseado em zero; a última seção explica como removê-lo pelo valor.
Desloque os elementos para a esquerda e reduza o array com um laço
Copie cada elemento posterior ao índice escolhido para a posição anterior e, em seguida, use Arrays.copyOf para criar o resultado menor. O array original é modificado durante o deslocamento; portanto, faça uma cópia separada antes se precisar manter os valores originais.
O intervalo válido de índices vai de 0 a array.length - 1. Este exemplo verifica o índice antes de acessá-lo. Se estiver fora desse intervalo, o array permanece inalterado e uma mensagem é exibida.
Os arrays Java têm comprimento fixo. Atribuir os valores seguintes às posições anteriores desloca os elementos restantes para a esquerda, mas o array continua com o comprimento original. Para retornar um array com um elemento a menos, copie o trecho deslocado para um novo array. Execute este exemplo:
O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5};
int indexToRemove = 2;
if (indexToRemove >= 0 && indexToRemove < array.length) {
for (int i = indexToRemove; i < array.length - 1; i++) {
array[i] = array[i + 1];
}
array = Arrays.copyOf(array, array.length - 1);
System.out.println(Arrays.toString(array));
} else {
System.out.println("Index out of bounds");
}
}
}
Saída:
[1, 2, 4, 5]
O laço para no penúltimo índice original porque cada iteração lê array[i + 1]. Após o deslocamento, a antiga última posição contém um valor duplicado; Arrays.copyOf descarta essa posição ao alocar um array com um elemento a menos. Também é possível remover o último elemento: o laço não executa nenhuma vez, e a cópia descarta diretamente a última posição.
Copie ao redor de um índice com System.arraycopy()
System.arraycopy() pode copiar o trecho anterior ao elemento removido e o trecho posterior a ele para intervalos separados de um novo array. Seus argumentos são a origem, a posição inicial na origem, o destino, a posição inicial no destino e a quantidade de elementos a copiar. O comprimento da primeira cópia é o índice removido; o da segunda é array.length - indexToRemove - 1.
O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] array = {2, 4, 6, 8, 10};
int indexToRemove = 2;
if (indexToRemove >= 0 && indexToRemove < array.length) {
int[] result = new int[array.length - 1];
System.arraycopy(array, 0, result, 0, indexToRemove);
int elementsAfter = array.length - indexToRemove - 1;
System.arraycopy(array, indexToRemove + 1, result, indexToRemove, elementsAfter);
System.out.println(Arrays.toString(result));
} else {
System.out.println("Index out of bounds");
}
}
}
Saída:
[2, 4, 8, 10]
Neste caso, o array de destino já tem o tamanho desejado, portanto não há valores padrão sobrando no final. System.arraycopy() também permite intervalos sobrepostos quando a origem e o destino são o mesmo array; Java faz essa cópia com segurança. Copiar para um array de resultado distinto, como no exemplo, deixa explícitos o trecho inicial e o trecho final que serão mantidos.
Remova um elemento usando ArrayList
Use ArrayList<Integer> quando os dados já estiverem em uma coleção ou quando forem necessárias várias inserções e remoções. Não é possível passar diretamente um int[] para Arrays.asList e obter uma lista de inteiros: arrays de tipos primitivos são tratados como um único objeto. Converta os valores para Integer[], crie a lista, remova pelo índice e, em seguida, converta de volta para int[].
O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.
import java.util.ArrayList;
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5};
int indexToRemove = 2;
if (indexToRemove >= 0 && indexToRemove < array.length) {
Integer[] boxed = Arrays.stream(array).boxed().toArray(Integer[]::new);
ArrayList<Integer> values = new ArrayList<>(Arrays.asList(boxed));
values.remove(indexToRemove);
int[] result = values.stream().mapToInt(Integer::intValue).toArray();
System.out.println(Arrays.toString(result));
} else {
System.out.println("Index out of bounds");
}
}
}
Saída:
[1, 2, 4, 5]
values.remove(indexToRemove) seleciona a sobrecarga que remove o item naquela posição. A conversão de volta para int[] é necessária porque a lista armazena objetos Integer, enquanto a origem usa valores primitivos int. Essa opção é conveniente, mas cria uma lista e um novo array; para uma única remoção de um int[] existente, qualquer uma das abordagens de cópia de array evita a conversão para coleção.
Escolha entre índice e valor e trate os casos extremos
Os exemplos removem um elemento pelo índice, usando indexação baseada em zero. Um índice válido satisfaz index >= 0 && index < array.length. Decida como o código chamador deve reagir quando essa condição for falsa: retornar o array original, retornar um status ou informar o problema. Não acesse array[index] antes de confirmar que a verificação foi aprovada. Um array vazio não tem nenhum índice válido, então a mesma verificação rejeita todos os índices com segurança.
Para remover pelo valor, procure o primeiro índice correspondente e use o mesmo padrão de deslocamento e redução. Este exemplo remove apenas a primeira ocorrência. Se nenhum valor corresponder, o array original permanece inalterado; ocorrências repetidas posteriores à primeira continuam no resultado.
O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] array = {3, 7, 3, 9};
int target = 3;
int indexToRemove = -1;
for (int i = 0; i < array.length; i++) {
if (array[i] == target) {
indexToRemove = i;
break;
}
}
if (indexToRemove >= 0) {
int[] result = new int[array.length - 1];
for (int i = 0; i < indexToRemove; i++) {
result[i] = array[i];
}
for (int i = indexToRemove + 1; i < array.length; i++) {
result[i - 1] = array[i];
}
array = result;
}
System.out.println(Arrays.toString(array));
}
}
Com esta entrada, o primeiro 3 é removido e o resultado é [7, 3, 9]. Se target não estiver presente, indexToRemove permanece -1, a cópia é ignorada e o array original é exibido sem alterações. Para remover todas as ocorrências correspondentes, conte os valores que não correspondem para determinar o tamanho do resultado e, em seguida, copie apenas esses valores.
Escolha o laço quando quiser acompanhar e controlar cada deslocamento. Escolha System.arraycopy() quando for mais claro construir um array do tamanho correto a partir de dois intervalos. Escolha ArrayList quando o código ao redor já precisar de uma coleção redimensionável ou de várias alterações. As três abordagens produzem uma sequência lógica sem o elemento removido; somente o primeiro laço também altera o conteúdo do array de entrada antes de retornar uma cópia menor.