remove delete an element from an array java
Impara vari metodi per eliminare o rimuovere un elemento da un array in Java come l'utilizzo di un altro array, l'utilizzo di Java 8 Streams, l'utilizzo di ArrayList:
Gli array Java non forniscono un metodo di rimozione diretta per rimuovere un elemento. In effetti, abbiamo già discusso che gli array in Java sono statici, quindi la dimensione degli array non può cambiare una volta creata un'istanza. Quindi non possiamo eliminare un elemento e ridurre la dimensione dell'array.
Quindi, se vogliamo eliminare o rimuovere un elemento dall'array, dobbiamo impiegare metodi diversi che di solito sono soluzioni alternative.
=> Guarda la serie completa di tutorial di formazione Java per principianti
Cosa imparerai:
Rimuovi / Elimina un elemento da un array in Java
In questo tutorial, discuteremo i vari metodi per eliminare un elemento da un array.
Include:
- Utilizzando un altro array
- Utilizzo di flussi Java 8
- Utilizzando ArrayList
- Utilizzo di System.arraycopy ()
Utilizzo di un altro array
Questo è il metodo tradizionale e alquanto inefficiente per eliminare un elemento dell'array. Qui definiamo un nuovo array con dimensioni inferiori a 1 rispetto all'array originale. Quindi copiamo gli elementi dall'array originale al nuovo array. Ma durante la copia, saltiamo l'elemento all'indice specificato.
In questo modo copiamo tutti gli elementi tranne l'elemento da eliminare nel nuovo array indicando che l'elemento è stato eliminato.
Possiamo rappresentare questa operazione graficamente come mostrato di seguito.
Implementiamo questo metodo in un programma 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 Produzione:
Utilizzo di Java 8 Streams
Gli stream sono una nuova aggiunta a Java dalla versione 8 in poi. Utilizzando i flussi Java8, possiamo eliminare un elemento da un array. Per fare ciò, in primo luogo, l'array viene convertito in un flusso. Quindi l'elemento all'indice specificato viene eliminato utilizzando il metodo di filtro dei flussi.
come faccio ad aprire un file swf
Una volta che l'elemento è stato eliminato, utilizzando i metodi 'map' e 'toArray', lo stream viene riconvertito nell'array.
Di seguito è illustrata l'implementazione della rimozione di un elemento da un array utilizzando stream.
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)); } }
Produzione:
Utilizzando ArrayList
Possiamo usare un ArrayList per eseguire questa operazione. Per rimuovere un elemento da un array, prima convertiamo l'array in un ArrayList e quindi utilizziamo il metodo 'remove' di ArrayList per rimuovere l'elemento in un particolare indice.
Una volta rimosso, riconvertiamo ArrayList nell'array.
La seguente implementazione mostra la rimozione dell'elemento da un array utilizzando 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)); } }
Produzione:
Il programma precedente produce output per due condizioni. Innanzitutto, viene passato un indice inesistente (10), ovvero oltre la dimensione dell'array corrente. Il programma visualizza un messaggio appropriato e non elimina alcun elemento.
Nel secondo caso, viene passato un indice = 2. Questa volta l'elemento in posizione 2 viene cancellato e viene passato l'array risultante.
Utilizzo di System.arraycopy ()
Questo metodo è simile al primo, tranne per il fatto che utilizziamo il metodo 'arrayCopy' per copiare gli elementi dell'array originale nel nuovo array.
Per prima cosa, copiamo gli elementi dell'array originale da 0 all'indice nel nuovo array. Successivamente, copiamo gli elementi da index + 1 fino a length nel nuovo array. Pertanto, durante la copia, ignoriamo l'elemento all'indice specificato e generiamo un nuovo array.
Questo nuovo array indica l'array risultante ottenuto dopo l'eliminazione di un elemento all'indice specificato.
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)); } }
Produzione:
Domande frequenti
D # 1) Come rimuovere un elemento da un array?
Risposta: Java non fornisce un metodo diretto per rimuovere un elemento dall'array. Ma dato un indice in corrispondenza del quale l'elemento deve essere cancellato, possiamo usare ArrayList per rimuovere l'elemento in corrispondenza dell'indice specificato.
Per questo, prima convertiamo l'array in ArrayList e usando il metodo remove rimuoviamo l'elemento. Una volta fatto, riconvertiamo ArrayList nell'array. Ci sono anche molte altre soluzioni alternative che possiamo utilizzare per questo scopo.
D # 2) Cosa fa la rimozione di ArrayList?
Risposta: Il metodo di rimozione di ArrayList rimuove l'elemento in ArrayList in un determinato indice fornito come argomento.
VPN per le mie transazioni di criptovalute
D # 3) Come rimuovi i duplicati da un array in Java?
Risposta: Gli elementi duplicati da un array possono essere rimossi utilizzando un array temporaneo che conterà gli elementi uno per uno e inserirà solo gli elementi univoci nell'array temporaneo. Un array deve essere ordinato per rimuovere i duplicati.
D # 4) Filter restituisce un nuovo array?
Risposta: Sì. Filter restituisce il nuovo array senza influire sull'array originale.
Q # 5) Come funziona R emove funziona in Java?
Risposta: Il metodo remove di ArrayList in Java rimuove l'elemento in corrispondenza dell'indice specificato. Anche nell'elenco collegato il metodo remove rimuove il nodo nella posizione data.
Conclusione
In questo tutorial, abbiamo visto i vari modi o soluzioni alternative con cui possiamo rimuovere l'elemento da un array in un dato indice.
Nei nostri argomenti successivi, discuteremo alcune ulteriori operazioni eseguite sugli array in Java.
=> Dai un'occhiata alla guida di formazione intensiva su Java qui
Lettura consigliata
- Tutorial sulla lunghezza di array Java con esempi di codice
- Java Array - Come stampare elementi di un array in Java?
- Come ordinare un array in Java - Tutorial con esempi
- Array Java: dichiara, crea e inizializza un array in Java
- Java Generic Array - Come simulare array generici in Java?
- Invertire un array in Java - 3 metodi con esempi
- Tutorial Java Reflection con esempi
- Come passare / restituire un array in Java