¿Cómo elimino objetos de una matriz en Java?
https://stackoverflow.com/questions/112503
-
02-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Dada una serie de norte Objetos, digamos que es un conjunto de cuerdas, y tiene los siguientes valores:
foo[0] = "a";
foo[1] = "cc";
foo[2] = "a";
foo[3] = "dd";
¿Qué tengo que hacer para borrar/eliminar todas las cadenas/objetos iguales a "a" en la matriz?
Solución
[Si desea algún código listo para usar, desplácese hasta mi "Editar3" (después del corte).El resto queda aquí para la posteridad.]
para desarrollar La idea del basurero:
List<String> list = new ArrayList<String>(Arrays.asList(array));
list.removeAll(Arrays.asList("a"));
array = list.toArray(array);
Editar:ahora estoy usando Arrays.asList en lugar de Collections.singleton:singleton está limitado a una entrada, mientras que el asList Este enfoque le permite agregar otras cadenas para filtrarlas más tarde: Arrays.asList("a", "b", "c").
Editar2:El enfoque anterior conserva la misma matriz (por lo que la matriz sigue teniendo la misma longitud);el elemento después del último se establece en nulo.Si quieres un nuevo matriz con el tamaño exacto requerido, use esto en su lugar:
array = list.toArray(new String[0]);
Editar3:Si usa este código con frecuencia en la misma clase, puede considerar agregar esto a su clase:
private static final String[] EMPTY_STRING_ARRAY = new String[0];
Entonces la función se convierte en:
List<String> list = new ArrayList<>();
Collections.addAll(list, array);
list.removeAll(Arrays.asList("a"));
array = list.toArray(EMPTY_STRING_ARRAY);
Esto dejará de ensuciar su montón con matrices de cadenas vacías e inútiles que de otro modo serían newed cada vez que se llama a su función.
La sugerencia de cynicalman (ver comentarios) también ayudará con el montón de basura y, para ser justos, debo mencionarlo:
array = list.toArray(new String[list.size()]);
Prefiero mi enfoque, porque puede ser más fácil equivocarse en el tamaño explícito (por ejemplo, llamar size() en la lista equivocada).
Otros consejos
Una alternativa en Java 8:
String[] filteredArray = Arrays.stream(array)
.filter(e -> !e.equals(foo)).toArray(String[]::new);
Hacer una List fuera de la matriz con Arrays.asList(), y llama remove() sobre todos los elementos apropiados.Luego llame toArray() en la 'Lista' para volver a formar una matriz.
No tiene un gran rendimiento, pero si lo encapsulas correctamente, siempre podrás hacer algo más rápido más adelante.
Siempre puedes hacer:
int i, j;
for (i = j = 0; j < foo.length; ++j)
if (!"a".equals(foo[j])) foo[i++] = foo[j];
foo = Arrays.copyOf(foo, i);
Puedes usar una biblioteca externa:
org.apache.commons.lang.ArrayUtils.remove(java.lang.Object[] array, int index)
Está en proyecto Apache Commons Lang. http://commons.apache.org/lang/
Ver código a continuación
ArrayList<String> a = new ArrayList<>(Arrays.asList(strings));
a.remove(i);
strings = new String[a.size()];
a.toArray(strings);
Si necesita eliminar varios elementos de la matriz sin convertirla a List ni crear una matriz adicional, puede hacerlo en O(n) independientemente del número de elementos a eliminar.
Aquí, a es la matriz inicial, int... r Son índices (posiciones) ordenados distintos de elementos a eliminar:
public int removeItems(Object[] a, int... r) {
int shift = 0;
for (int i = 0; i < a.length; i++) {
if (shift < r.length && i == r[shift]) // i-th item needs to be removed
shift++; // increment `shift`
else
a[i - shift] = a[i]; // move i-th item `shift` positions left
}
for (int i = a.length - shift; i < a.length; i++)
a[i] = null; // replace remaining items by nulls
return a.length - shift; // return new "length"
}
Pequeñas pruebas:
String[] a = {"0", "1", "2", "3", "4"};
removeItems(a, 0, 3, 4); // remove 0-th, 3-rd and 4-th items
System.out.println(Arrays.asList(a)); // [1, 2, null, null, null]
En su tarea, primero puede escanear la matriz para recopilar las posiciones de "a", luego llamar removeItems().
Algo sobre hacer una lista, luego eliminarlo y luego volver a una matriz me parece incorrecto.No lo he probado, pero creo que lo siguiente funcionará mejor.Sí, probablemente estoy preoptimizando excesivamente.
boolean [] deleteItem = new boolean[arr.length];
int size=0;
for(int i=0;i<arr.length;i==){
if(arr[i].equals("a")){
deleteItem[i]=true;
}
else{
deleteItem[i]=false;
size++;
}
}
String[] newArr=new String[size];
int index=0;
for(int i=0;i<arr.length;i++){
if(!deleteItem[i]){
newArr[index++]=arr[i];
}
}
Me doy cuenta de que esta es una publicación muy antigua, pero algunas de las respuestas aquí me ayudaron, ¡así que aquí está mi valor de dos peniques y medio penique!
Luché para que esto funcionara durante bastante tiempo antes de darme cuenta de que era necesario cambiar el tamaño de la matriz en la que estoy escribiendo nuevamente, a menos que los cambios realizados en el ArrayList deje el tamaño de la lista sin cambios.
Si el ArrayList que estás modificando termina con más o menos elementos que con los que empezó, la línea List.toArray() causará una excepción, por lo que necesita algo como List.toArray(new String[] {}) o List.toArray(new String[0]) para crear una matriz con el nuevo tamaño (correcto).
Suena obvio ahora que lo sé.No es tan obvio para un novato en Android/Java que se está familiarizando con construcciones de código nuevas y desconocidas y no es tan obvio en algunas de las publicaciones anteriores aquí, así que solo quería dejar este punto realmente claro para cualquiera que se rasque la cabeza durante horas como lo estaba yo. !
Hay muchas respuestas aquí; el problema, tal como lo veo, es que no dijiste POR QUÉ estás usando una matriz en lugar de una colección, así que déjame sugerir un par de razones y qué soluciones se aplicarían (la mayoría de las soluciones). Ya han sido respondidas en otras preguntas aquí, por lo que no entraré en demasiados detalles):
razón:No sabías que existía el paquete de colección o no confiabas en él.
solución:Utilice una colección.
Si planea agregar/eliminar desde el medio, use una LinkedList.Si está realmente preocupado por el tamaño o, a menudo, indexa justo en el medio de la colección, utilice ArrayList.Ambos deberían tener operaciones de eliminación.
razón:Le preocupa el tamaño o desea controlar la asignación de memoria
solución:Utilice un ArrayList con un tamaño inicial específico.
Una ArrayList es simplemente una matriz que puede expandirse, pero no siempre es necesario hacerlo.Será muy inteligente agregar/eliminar elementos, pero nuevamente, si está insertando/eliminando MUCHOS del medio, use una LinkedList.
razón:Tiene una matriz entrando y otra saliendo, por lo que desea operar en una matriz
solución:Conviértalo en un ArrayList, elimine el elemento y vuelva a convertirlo
razón:Crees que puedes escribir un mejor código si lo haces tú mismo
solución:no puedes, usa una matriz o una lista vinculada.
razón:Esta es una tarea de clase y no tienes permiso o no tienes acceso a las API de colección por algún motivo.
suposición:Necesita que la nueva matriz tenga el "tamaño" correcto
solución:Escanee la matriz en busca de elementos coincidentes y cuéntelos.Cree una nueva matriz del tamaño correcto (tamaño original - número de coincidencias).use System.arraycopy repetidamente para copiar cada grupo de elementos que desea conservar en su nuevo Array.Si se trata de una tarea de clase y no puedes usar System.arraycopy, simplemente cópialos uno a la vez manualmente en un bucle, pero nunca hagas esto en el código de producción porque es mucho más lento.(Estas soluciones se detallan en otras respuestas)
razón:necesitas ejecutar metal desnudo
suposición:no DEBES asignar espacio innecesariamente o tomar demasiado tiempo
suposición:Está realizando un seguimiento del tamaño utilizado en la matriz (longitud) por separado porque, de lo contrario, tendría que reasignar su matriz para eliminaciones/inserciones.
Un ejemplo de por qué es posible que desee hacer esto:una única matriz de primitivas (digamos valores int) está consumiendo una parte importante de tu RAM, ¡como el 50%!Un ArrayList los forzaría a ingresar en una lista de punteros a objetos Integer que usarían varias veces esa cantidad de memoria.
solución:Itere sobre su matriz y cada vez que encuentre un elemento para eliminar (llamémoslo elemento n), use System.arraycopy para copiar la cola de la matriz sobre el elemento "eliminado" (el origen y el destino son la misma matriz). Es inteligente. basta con hacer la copia en la dirección correcta para que la memoria no se sobrescriba:
System.arraycopy(ary, n+1, ary, n, length-n) length--;
Probablemente querrás ser más inteligente si eliminas más de un elemento a la vez.Sólo moverías el área entre una "partida" y la siguiente en lugar de toda la cola y, como siempre, evitarías mover cualquier fragmento dos veces.
En este último caso, es absolutamente necesario que haga el trabajo usted mismo, y usar System.arraycopy es realmente la única forma de hacerlo, ya que elegirá la mejor manera posible de mover la memoria para la arquitectura de su computadora; debería ser mucho más rápido. que cualquier código que usted mismo pueda escribir razonablemente.
EDITAR:
Se ha aclarado el punto con los valores nulos en la matriz.Perdón por mis comentarios.
Original:
Ehm...la línea
array = list.toArray(array);
reemplaza todos los espacios en la matriz donde ha estado el elemento eliminado con nulo.Esto podría ser peligroso, porque los elementos se eliminan, ¡pero la longitud de la matriz sigue siendo la misma!
Si desea evitar esto, utilice una nueva matriz como parámetro para toArray().Si no desea utilizar removeAll, un Set sería una alternativa:
String[] array = new String[] { "a", "bc" ,"dc" ,"a", "ef" };
System.out.println(Arrays.toString(array));
Set<String> asSet = new HashSet<String>(Arrays.asList(array));
asSet.remove("a");
array = asSet.toArray(new String[] {});
System.out.println(Arrays.toString(array));
Da:
[a, bc, dc, a, ef]
[dc, ef, bc]
Donde como resultado la respuesta actualmente aceptada de Chris Yester Young:
[a, bc, dc, a, ef]
[bc, dc, ef, null, ef]
con el codigo
String[] array = new String[] { "a", "bc" ,"dc" ,"a", "ef" };
System.out.println(Arrays.toString(array));
List<String> list = new ArrayList<String>(Arrays.asList(array));
list.removeAll(Arrays.asList("a"));
array = list.toArray(array);
System.out.println(Arrays.toString(array));
sin dejar ningún valor nulo.
Mi pequeño aporte a este problema.
public class DeleteElementFromArray {
public static String foo[] = {"a","cc","a","dd"};
public static String search = "a";
public static void main(String[] args) {
long stop = 0;
long time = 0;
long start = 0;
System.out.println("Searched value in Array is: "+search);
System.out.println("foo length before is: "+foo.length);
for(int i=0;i<foo.length;i++){ System.out.println("foo["+i+"] = "+foo[i]);}
System.out.println("==============================================================");
start = System.nanoTime();
foo = removeElementfromArray(search, foo);
stop = System.nanoTime();
time = stop - start;
System.out.println("Equal search took in nano seconds = "+time);
System.out.println("==========================================================");
for(int i=0;i<foo.length;i++){ System.out.println("foo["+i+"] = "+foo[i]);}
}
public static String[] removeElementfromArray( String toSearchfor, String arr[] ){
int i = 0;
int t = 0;
String tmp1[] = new String[arr.length];
for(;i<arr.length;i++){
if(arr[i] == toSearchfor){
i++;
}
tmp1[t] = arr[i];
t++;
}
String tmp2[] = new String[arr.length-t];
System.arraycopy(tmp1, 0, tmp2, 0, tmp2.length);
arr = tmp2; tmp1 = null; tmp2 = null;
return arr;
}
}
matriz inicial
int[] array = {5,6,51,4,3,2};
Si desea eliminar 51 que es el índice 2, utilice lo siguiente
for(int i = 2; i < array.length -1; i++){
array[i] = array[i + 1];
}
¿Depende de lo que quieras decir con "eliminar"?Una matriz es una construcción de tamaño fijo: no se puede cambiar la cantidad de elementos que contiene.Por lo tanto, puede a) crear una matriz nueva y más corta sin los elementos que no desea ob) asignar las entradas que no desea a algo que indique su estado "vacío";normalmente es nulo si no estás trabajando con primitivas.
En el primer caso, cree una Lista a partir de la matriz, elimine los elementos y cree una nueva matriz a partir de la lista.Si el rendimiento es importante, repita la matriz asignando cualquier elemento que no deba eliminarse a una lista y luego cree una nueva matriz a partir de la lista.En el segundo caso, simplemente continúe y asigne nulos a las entradas de la matriz.
Arrgh, no consigo que el código se muestre correctamente.Lo siento, lo hice funcionar.Lo siento de nuevo, creo que no leí la pregunta correctamente.
String foo[] = {"a","cc","a","dd"},
remove = "a";
boolean gaps[] = new boolean[foo.length];
int newlength = 0;
for (int c = 0; c<foo.length; c++)
{
if (foo[c].equals(remove))
{
gaps[c] = true;
newlength++;
}
else
gaps[c] = false;
System.out.println(foo[c]);
}
String newString[] = new String[newlength];
System.out.println("");
for (int c1=0, c2=0; c1<foo.length; c1++)
{
if (!gaps[c1])
{
newString[c2] = foo[c1];
System.out.println(newString[c2]);
c2++;
}
}
Copiará todos los elementos excepto el que tiene índice i:
if(i == 0){
System.arraycopy(edges, 1, copyEdge, 0, edges.length -1 );
}else{
System.arraycopy(edges, 0, copyEdge, 0, i );
System.arraycopy(edges, i+1, copyEdge, i, edges.length - (i+1) );
}
En una serie de cadenas como
Nombre de cadena = 'a b c d e a f b d e' // podría ser como Nombre de cadena = 'aa bb c d e aa f bb d e'
Construyo la siguiente clase
class clearname{
def parts
def tv
public def str = ''
String name
clearname(String name){
this.name = name
this.parts = this.name.split(" ")
this.tv = this.parts.size()
}
public String cleared(){
int i
int k
int j=0
for(i=0;i<tv;i++){
for(k=0;k<tv;k++){
if(this.parts[k] == this.parts[i] && k!=i){
this.parts[k] = '';
j++
}
}
}
def str = ''
for(i=0;i<tv;i++){
if(this.parts[i]!='')
this.str += this.parts[i].trim()+' '
}
return this.str
}}
return new clearname(name).cleared()
obteniendo este resultado
a B C D e F
Espero que este código ayude a alguien Saludos
class sd
{
public static void main(String[ ] args)
{
System.out.println("Search and Delete");
int key;
System.out.println("Enter the length of array:");
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int numbers[]=new int[n];
int i = 0;
boolean found = false;
System.out.println("Enter the elements in Array :");
for ( i = 0; i < numbers.length; i++)
{
numbers[i]=in.nextInt();
}
System.out.println("The elements in Array are:");
for ( i = 0; i < numbers.length; i++)
{
System.out.println(numbers[i]);
}
System.out.println("Enter the element to be searched:");
key=in.nextInt();
for ( i = 0; i < numbers.length; i++)
{
if (numbers[ i ] == key)
{
found = true;
break;
}
}
if (found)
{
System.out.println("Found " + key + " at index " + i + ".");
numbers[i]=0;//haven't deleted the element in array
System.out.println("After Deletion:");
for ( i = 0; i < numbers.length; i++)
{
if (numbers[ i ]!=0)
{ //it skips displaying element in array
System.out.println(numbers[i]);
}
}
}
else
{
System.out.println(key + "is not in this array.");
}
}
}//Sorry.. if there are mistakes.
Usar:
list.removeAll(...);
//post what char you need in the ... section
Asigne nulo a las ubicaciones de la matriz.
