Rimozione di un elemento da una matrice (Java)

C’è un modo veloce (e bello) per rimuovere un elemento da un array in Java?

Potresti usare gli ArrayUtils di commons lang.

array = ArrayUtils.removeElement(array, element) 

libreria commons.apache.org: Javadocs

La tua domanda non è molto chiara. Dalla tua risposta, posso dire meglio ciò che stai cercando di fare:

 public static String[] removeElements(String[] input, String deleteMe) { List result = new LinkedList(); for(String item : input) if(!deleteMe.equals(item)) result.add(item); return result.toArray(input); } 

NB: questo non è stato verificato. Il controllo degli errori è lasciato al lettore (io lancerei IllegalArgumentException se input o deleteMe è nullo, una lista vuota sull’input dell’elenco null non ha senso Rimuovere le stringhe null dall’array potrebbe avere senso, ma I ‘ Lo lascerò anche come esercizio, al momento, lancia un NPE quando tenta di chiamare equamente su deleteMe se deleteMe è null.)

Scelte che ho fatto qui:

Ho usato un LinkedList. L’iterazione dovrebbe essere altrettanto veloce e si evitano ridimensionamenti o allocazione di un elenco troppo grande se si eliminano molti elementi. È ansible utilizzare una lista array e impostare la dimensione iniziale sulla lunghezza dell’input. Probabilmente non farebbe molta differenza.

La scelta migliore sarebbe quella di utilizzare una raccolta, ma se questo è fuori causa, usare arraycopy . Puoi usarlo per copiare da e verso lo stesso array con un offset leggermente diverso.

Per esempio:

 public void removeElement(Object[] arr, int removedIdx) { System.arraycopy(arr, removedIdx + 1, arr, removedIdx, arr.length - 1 - removedIdx); } 

Modifica in risposta al commento:

Non è un altro buon modo, è davvero l’unico modo accettabile.

Per allocare una raccolta (crea una nuova matrice), quindi eliminare un elemento (che la raccolta verrà eseguita utilizzando arraycopy) quindi chiamare suArray su di essa (crea un SECONDO nuovo array) per ogni eliminazione ci porta al punto in cui non si tratta di un problema di ottimizzazione , è una programmazione criminale ctriggers.

Supponiamo che tu abbia un array che occupa, per esempio, 100mb di ram. Ora vuoi iterare su di esso ed eliminare 20 elementi.

Provaci…

So che ti ASSUMI che non sarà così grande, o che se ne eliminassi così tanti contemporaneamente lo codificherai diversamente, ma ho risolto un sacco di codice in cui qualcuno ha fatto delle supposizioni del genere.

Non è ansible rimuovere un elemento dall’array Java di base. Dai un’occhiata a varie collezioni e ArrayList.

La soluzione di bell’aspetto sarebbe quella di utilizzare un elenco invece di matrice in primo luogo.

 List.remove(index) 

Se devi utilizzare gli array, due chiamate a System.arraycopy saranno probabilmente le più veloci.

 Foo[] result = new Foo[source.length - 1]; System.arraycopy(source, 0, result, 0, index); if (source.length != index) { System.arraycopy(source, index + 1, result, index, source.length - index - 1); } 

( Arrays.asList è anche un buon candidato per lavorare con gli array, ma non sembra supportare la remove .)

Penso che la domanda fosse chiedere una soluzione senza l’uso dell’API Collections. Uno utilizza gli array sia per i dettagli di basso livello, dove le prestazioni sono importanti, sia per un’integrazione SOA liberamente accoppiata. In seguito, è OK convertirli in collezioni e passarli alla logica di business come quella.

Per le cose a basso livello di prestazioni, di solito è già offuscato dallo stato imperativo veloce e sporco che si mescola per loop, ecc. In questo caso la conversione avanti e indietro tra le raccolte e gli array è ingombrante, illeggibile e persino ad alta intensità di risorse.

A proposito, TopCoder, qualcuno? Sempre quei parametri dell’array! Quindi preparati a essere in grado di gestirli quando sei in Arena.

Di seguito è la mia interpretazione del problema e una soluzione. È diverso nella funzionalità di entrambi quelli forniti da Bill K e jelovirt . Inoltre, gestisce con garbo il caso quando l’elemento non è nell’array.

Spero possa aiutare!

 public char[] remove(char[] symbols, char c) { for (int i = 0; i < symbols.length; i++) { if (symbols[i] == c) { char[] copy = new char[symbols.length-1]; System.arraycopy(symbols, 0, copy, 0, i); System.arraycopy(symbols, i+1, copy, i, symbols.length-i-1); return copy; } } return symbols; } 

È ansible utilizzare l’ API ArrayUtils per rimuoverlo in un “modo gradevole”. Implementa molte operazioni (rimuovi, trova, aggiungi, contiene, ecc.) Su Array.
Guarda. Mi ha reso la vita più semplice.

Sono necessarie altre pre-condizioni per quelle scritte da Bill K e dadinn

 Object[] newArray = new Object[src.length - 1]; if (i > 0){ System.arraycopy(src, 0, newArray, 0, i); } if (newArray.length > i){ System.arraycopy(src, i + 1, newArray, i, newArray.length - i); } return newArray; 

Non è ansible modificare la lunghezza di un array, ma è ansible modificare i valori contenuti nell’indice copiando nuovi valori e memorizzandoli su un numero di indice esistente. 1 = mike, 2 = jeff // 10 = george 11 passa a 1 sovrascrittura mike.

 Object[] array = new Object[10]; int count = -1; public void myFunction(String string) { count++; if(count == array.length) { count = 0; // overwrite first } array[count] = string; } 

okay, grazie mille ora uso sth come questo:

 public static String[] removeElements(String[] input, String deleteMe) { if (input != null) { List list = new ArrayList(Arrays.asList(input)); for (int i = 0; i < list.size(); i++) { if (list.get(i).equals(deleteMe)) { list.remove(i); } } return list.toArray(new String[0]); } else { return new String[0]; } } 

Copia l’array originale in un altro array, senza che l’elemento sia rimosso.

Un modo più semplice per farlo è usare List, Set … e usare il metodo remove ().

Scambia l’object da rimuovere con l’ultimo elemento, se il ridimensionamento dell’array non è un interesse.

Spero che tu usi le collezioni java collection / java commons!

Con java.util.ArrayList puoi fare cose come le seguenti:

 yourArrayList.remove(someObject); yourArrayList.add(someObject); 

Usa una ArrayList :

 alist.remove(1); //removes the element at position 1 

Certo, crea un altro array 🙂