Eliminar un elemento de una matriz (Java)

¿Hay alguna manera rápida (y bonita) de eliminar un elemento de una matriz en Java?

Podría usar ArrayUtils de commons lang.

array = ArrayUtils.removeElement(array, element) 

biblioteca commons.apache.org: Javadocs

Tu pregunta no es muy clara. De su propia respuesta, puedo decir mejor lo que está tratando de hacer:

 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: Esto no ha sido probado. La comprobación de errores se deja como un ejercicio para el lector (lanzaría IllegalArgumentException si input o deleteMe son nulos, una lista vacía en la lista nula no tiene sentido. Eliminar cadenas nulas de la matriz podría tener sentido, pero yo ‘ Lo dejo también como un ejercicio; actualmente lanzará un NPE cuando intente llamar a iguales en deleteMe si deleteMe es nulo.)

Elecciones que hice aquí:

Usé una LinkedList. La iteración debe ser igual de rápida, y evita cualquier cambio de tamaño, o asigna una lista demasiado grande si termina eliminando muchos elementos. Puede usar una ArrayList y establecer el tamaño inicial a la longitud de entrada. Es probable que no haga mucha diferencia.

La mejor opción sería usar una colección, pero si eso arraycopy por alguna razón, use arraycopy . Puede usarlo para copiar desde y hacia la misma matriz con un desplazamiento ligeramente diferente.

Por ejemplo:

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

Edite en respuesta al comentario:

No es otra buena manera, es realmente la única forma aceptable.

Para asignar una colección (crea una nueva matriz), luego eliminar un elemento (que la colección usará arraycopy) luego llamar a Array en ella (crea una SEGUNDA nueva matriz) por cada eliminación nos lleva al punto en que no es un problema de optimización , es una progtwigción criminalmente mala.

Supongamos que tiene una matriz ocupando, digamos, 100 mb de ram. Ahora desea iterar sobre él y eliminar 20 elementos.

Darle una oportunidad…

Sé que usted ASUME que no va a ser tan grande, o que si borra los muchos a la vez, lo codificaría de manera diferente, pero he arreglado un montón de código donde alguien hizo suposiciones como esa.

No puede eliminar un elemento de la matriz Java básica. Eche un vistazo a varias colecciones y ArrayList en su lugar.

Una buena solución sería usar una lista en lugar de una matriz en primer lugar.

 List.remove(index) 

Si tiene que usar arreglos, es probable que dos llamadas a System.arraycopy sean las más rápidas.

 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 también es un buen candidato para trabajar con matrices, pero no parece ser compatible con remove ).

Creo que la pregunta era pedir una solución sin el uso de la API de Colecciones. Uno usa arreglos ya sea para detalles de bajo nivel, donde el rendimiento importa, o para una integración de SOA débilmente acoplada. En lo posterior, está bien convertirlos en Colecciones y pasarlos a la lógica de negocios como tal.

Para el rendimiento de bajo nivel, generalmente ya está oscurecido por el estado imperativo rápido y sucio: mezclar por bucles for, etc. En ese caso, la conversión entre Colecciones y matrices es engorrosa, ilegible e incluso exigente en recursos.

Por cierto, TopCoder, ¿alguien? ¡Siempre esos parámetros de matriz! Así que prepárate para poder manejarlos cuando estés en la Arena.

Debajo está mi interpretación del problema y una solución. Tiene una funcionalidad diferente a la dada por Bill K y jelovirt . Además, maneja con gracia el caso cuando el elemento no está en la matriz.

¡Espero que ayude!

 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; } 

Podría usar la API de ArrayUtils para eliminarla de una “manera atractiva”. Implementa muchas operaciones (eliminar, encontrar, agregar, contener, etc.) en Arrays.
Echar un vistazo. Ha hecho mi vida más simple.

Se requieren algunas precondiciones adicionales para las escritas por Bill K y 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; 

No puede cambiar la longitud de una matriz, pero puede cambiar los valores que contiene el índice al copiar nuevos valores y almacenarlos en un número de índice existente. 1 = mike, 2 = jeff // 10 = george 11 va a 1 sobreescribir 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; } 

de acuerdo, creo que ahora uso algo así:

 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]; } } 

Copie su matriz original en otra matriz, sin el elemento que se eliminará.

Una manera más simple de hacer eso es usar una Lista, Establecer … y usar el método remove ().

Cambie el elemento que se va a eliminar con el último elemento, si no le interesa cambiar el tamaño de la matriz.

¡Espero que uses las colecciones java collection / java commons!

Con java.util.ArrayList puedes hacer cosas como las siguientes:

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

Use una ArrayList :

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

Claro, crea otra matriz 🙂