remove delete an element from an array java
Aprenda vários métodos para excluir ou remover um elemento de um array em Java, como usar outro array, usar streams Java 8, usar ArrayList:
As matrizes Java não fornecem um método de remoção direto para remover um elemento. Na verdade, já discutimos que os arrays em Java são estáticos, portanto, o tamanho dos arrays não pode ser alterado depois de instanciados. Portanto, não podemos excluir um elemento e reduzir o tamanho do array.
Portanto, se quisermos excluir ou remover um elemento da matriz, precisamos empregar métodos diferentes que geralmente são soluções alternativas.
=> Veja a série completa de tutoriais de treinamento em Java para iniciantes
O que você aprenderá:
Remover / excluir um elemento de um array em Java
Neste tutorial, discutiremos os vários métodos para excluir um elemento de um array.
Inclui:
- Usando outro Array
- Usando fluxos Java 8
- Usando ArrayList
- Usando System.arraycopy ()
Usando Outro Array
Este é o método tradicional e um tanto ineficiente de excluir um elemento do array. Aqui definimos uma nova matriz com tamanho menor que 1 para a matriz original. Em seguida, copiamos os elementos do array original para o novo array. Mas ao fazer essa cópia, pulamos o elemento no índice especificado.
Dessa forma, copiamos todos os elementos, exceto o elemento a ser excluído, para o novo array, indicando que o elemento foi excluído.
Podemos representar esta operação pictoricamente conforme mostrado abaixo.
Vamos implementar esse método em um programa Java.
import java.util.Arrays; class Main { public static void main(String() args) { // define original array int() tensArray = { 10,20,30,40,50,60}; // Print the original array System.out.println('Original Array: ' + Arrays.toString(tensArray)); // the index at which the element in the array is to be removed int rm_index = 2; // display index System.out.println('Element to be removed at index: ' + rm_index); // if array is empty or index is out of bounds, removal is not possible if (tensArray == null || rm_index<0 || rm_index>= tensArray.length) { System.out.println('No removal operation can be performed!!'); } // Create a proxy array of size one less than original array int() proxyArray = new int(tensArray.length - 1); // copy all the elements in the original to proxy array except the one at index for (int i = 0, k = 0; i Resultado:
qual é o melhor atualizador de driver
Usando Java 8 Streams
Streams são uma nova adição ao Java da versão 8 em diante. Usando fluxos Java8, podemos excluir um elemento de um array. Para fazer isso, primeiro a matriz é convertida em um fluxo. Em seguida, o elemento no índice especificado é excluído usando o método de filtro de fluxos.
Uma vez que o elemento é excluído, usando os métodos ‘map’ e ‘toArray’, o fluxo é convertido de volta para a matriz.
A implementação da remoção de um elemento de uma matriz usando stream é mostrada abaixo.
import java.util.Arrays; import java.util.stream.IntStream; class Main { // Function to remove the element public static int() removeArrayElement(int() oddArray, int index) { //array is empty or index is beyond array bounds if (oddArray == null || index <0 || index>= oddArray.length) { return oddArray; } // delete the element at specified index and return the array return IntStream.range(0, oddArray.length) .filter(i -> i != index) .map(i ->oddArray(i)).toArray(); } public static void main(String() args) { int() oddArray = { 1, 3,5,7,9,11}; // define array of odd numbers System.out.println('Original Array: ' + Arrays.toString(oddArray)); // Print the resultant array int index = 2; // index at which element is to be removed System.out.println('Element to be removed at index: ' + index); // display index // function call removeArrayElement oddArray = removeArrayElement(oddArray, index); // Print the resultant array System.out.println('Array after deleting element: ' + Arrays.toString(oddArray)); } } Resultado:
Usando ArrayList
Podemos usar um ArrayList para realizar esta operação. Para remover um elemento de uma matriz, primeiro convertemos a matriz em um ArrayList e, em seguida, usamos o método ‘remove’ de ArrayList para remover o elemento em um índice específico.
Depois de removido, convertemos o ArrayList de volta ao array.
A implementação a seguir mostra a remoção do elemento de uma matriz usando ArrayList.
import java.util.*; import java.util.stream.*; class Main { public static int() remove_Element(int() myArray, int index) { if (myArray == null || index <0 || index>= myArray.length) { System.out.println('non-existing index'); return myArray; } //array to arrayList List arrayList = IntStream.of(myArray) .boxed().collect(Collectors.toList()); // Remove the specified element arrayList.remove(index); // return the resultant array returnarrayList.stream().mapToInt(Integer::intValue).toArray(); } public static void main(String() args) { int() myArray = { 11,22,33,44,55,66,77,88,99,111 }; System.out.println('Original Array: ' + Arrays.toString(myArray)); int index = 10; System.out.println('Index at which element is to be deleted: ' + index); myArray = remove_Element(myArray, index); System.out.println('Resultant Array: ' + Arrays.toString(myArray) + '
'); index = 2; System.out.println('Index at which element is to be deleted: ' + index); myArray = remove_Element(myArray, index); System.out.println('Resultant Array: ' + Arrays.toString(myArray)); } } Resultado:
O programa acima produz saída para duas condições. Primeiro, um índice não existente (10) é passado, ou seja, além do tamanho da matriz atual. O programa exibe uma mensagem apropriada e não exclui nenhum elemento.
No segundo caso, um índice = 2 é passado. Desta vez, o elemento na posição 2 é excluído e a matriz resultante é passada.
Usando System.arraycopy ()
Este método é semelhante ao primeiro método, exceto que usamos o método ‘arrayCopy’ para copiar os elementos da matriz original para a nova matriz.
Primeiro, copiamos os elementos do array original de 0 para indexar no novo array. Em seguida, copiamos os elementos do índice + 1 até o comprimento no novo array. Assim, durante a cópia, pulamos o elemento no índice especificado e geramos uma nova matriz.
Essa nova matriz indica a matriz resultante obtida após a exclusão de um elemento no índice especificado.
import java.util.Arrays; class Main { public static void main(String() args) { // define the array of integers int() intArray = { 10,20,30,40,50 }; // display the original array System.out.println('Original Array: ' + Arrays.toString(intArray)); // index at which the element is to be deleted int index = 2; // the index System.out.println('Element to be deleted at index: ' + index); // check if the array is empty or index is out of bounds if (intArray == null || index <0 || index>= intArray.length) { System.out.println('No removal operation can be performed!!'); } // create an array to hold elements after deletion int() copyArray = new int(intArray.length - 1); // copy elements from original array from beginning till index into copyArray System.arraycopy(intArray, 0, copyArray, 0, index); // copy elements from original array from index+1 till end into copyArray System.arraycopy(intArray, index + 1, copyArray, index, intArray.length - index - 1); // display the copied array after deletion System.out.println('Array after deleting an element: ' + Arrays.toString(copyArray)); } } Resultado:
perguntas frequentes
Q # 1) Como remover um elemento de um Array?
Responda: Java não fornece um método direto para remover um elemento da matriz. Mas dado um índice no qual o elemento deve ser excluído, podemos usar ArrayList para remover o elemento no índice especificado.
Para isso, primeiro convertemos o array em ArrayList e usando o método remove removemos o elemento. Feito isso, convertemos o ArrayList de volta ao array. Existem também várias outras soluções alternativas que podemos empregar para esse propósito.
P # 2) O que ArrayList remove fazer?
Responda: O método de remoção ArrayList remove o elemento na ArrayList em um determinado índice que é fornecido como um argumento.
diferença entre java e c ++
P # 3) Como você remove duplicatas de uma matriz em Java?
Responda: Os elementos duplicados de um array podem ser removidos usando um array temporário que contará os elementos um por um e colocará apenas os elementos únicos no array temporário. Uma matriz precisa ser classificada para remover as duplicatas.
P # 4) O filtro retorna uma nova matriz?
Responda: sim. Filter retorna a nova matriz sem afetar a matriz original.
Q # 5) Como R emove trabalhar em Java?
Responda: O método remove de ArrayList em Java remove o elemento no índice especificado. Também na lista vinculada, o método remove remove o nó na posição fornecida.
Conclusão
Neste tutorial, vimos as várias maneiras ou soluções alternativas com as quais podemos remover o elemento de uma matriz em um determinado índice.
Em nossos tópicos subsequentes, discutiremos mais algumas operações realizadas em arrays em Java.
=> Confira o guia de treinamento intensivo de Java aqui
Leitura recomendada
- Tutorial de comprimento de array Java com exemplos de código
- Array Java - como imprimir elementos de um array em Java?
- Como classificar uma matriz em Java - Tutorial com exemplos
- Array Java - declarar, criar e inicializar um array em Java
- Array genérico de Java - como simular matrizes genéricas em Java?
- Reverter uma matriz em Java - 3 métodos com exemplos
- Tutorial de reflexão Java com exemplos
- Como Passar / Retornar um Array em Java
