quitar - metodo para eliminar espacios en blanco java

Eliminar correctamente un entero de una lista<Entero>

Question

Aquí hay un buen escollo que acabo de encontrar. Considera una lista de enteros:

List<Integer> list = new ArrayList<Integer>();
list.add(5);
list.add(6);
list.add(7);
list.add(1);

¿Alguna conjetura sobre qué sucede cuando ejecutas list.remove(1) ? ¿Qué pasa con list.remove(new Integer(1)) ? Esto puede causar algunos errores desagradables.

¿Cuál es la forma correcta de diferenciar entre remove(int index) , que elimina un elemento del índice dado y remove(Object o) , que elimina un elemento por referencia, cuando se trata de listas de enteros?

El punto principal a considerar aquí es el mencionado por @Nikita : la coincidencia exacta de parámetros tiene prioridad sobre el auto-boxeo.

Answer 1

¿Alguna conjetura sobre qué sucede cuando ejecutas list.remove (1)? ¿Qué pasa con list.remove (nuevo Integer (1))?

No hay necesidad de adivinar. El primer caso dará como resultado la List.remove(int) de List.remove(int) y se eliminará el elemento en la posición 1 . El segundo caso dará como resultado la List.remove(Integer) a List.remove(Integer) y se eliminará el elemento cuyo valor es igual a Integer(1) . En ambos casos, el compilador de Java selecciona la sobrecarga de coincidencia más cercana.

Sí, existe la posibilidad de confusión (y errores) aquí, pero es un caso de uso bastante poco común.

Cuando los dos métodos List.remove se definieron en Java 1.2, las sobrecargas no fueron ambiguas. El problema solo surgió con la introducción de genéricos y autoboxing en Java 1.5. En retrospectiva, hubiera sido mejor si uno de los métodos de eliminación hubiera recibido un nombre diferente. Pero es demasiado tarde ahora.

Answer 2

Bueno, aquí está el truco.

Tomemos dos ejemplos aquí:

public class ArrayListExample {

public static void main(String[] args) {
    Collection<Integer> collection = new ArrayList<>();
    List<Integer> arrayList = new ArrayList<>();

    collection.add(1);
    collection.add(2);
    collection.add(3);
    collection.add(null);
    collection.add(4);
    collection.add(null);
    System.out.println("Collection" + collection);

    arrayList.add(1);
    arrayList.add(2);
    arrayList.add(3);
    arrayList.add(null);
    arrayList.add(4);
    arrayList.add(null);
    System.out.println("ArrayList" + arrayList);

    collection.remove(3);
    arrayList.remove(3);
    System.out.println("");
    System.out.println("After Removal of ''3'' :");
    System.out.println("Collection" + collection);
    System.out.println("ArrayList" + arrayList);

    collection.remove(null);
    arrayList.remove(null);
    System.out.println("");
    System.out.println("After Removal of ''null'': ");
    System.out.println("Collection" + collection);
    System.out.println("ArrayList" + arrayList);

  }

}

Ahora echemos un vistazo a la salida:

Collection[1, 2, 3, null, 4, null]
ArrayList[1, 2, 3, null, 4, null]

After Removal of ''3'' :
Collection[1, 2, null, 4, null]
ArrayList[1, 2, 3, 4, null]

After Removal of ''null'': 
Collection[1, 2, 4, null]
ArrayList[1, 2, 3, 4]

Ahora analicemos el resultado:

1. Cuando se elimina 3 de la colección, llama al método remove() de la colección que toma Object o como parámetro. Por lo tanto, elimina el objeto 3 . Pero en el objeto arrayList, el índice 3 lo reemplaza y, por lo tanto, el cuarto elemento se elimina.

2. Por la misma lógica de eliminación de objetos, null se elimina en ambos casos en el segundo resultado.

Entonces, para eliminar el número 3 que es un objeto, explícitamente necesitamos pasar 3 como un object .

Y eso se puede hacer lanzando o envolviendo usando la clase contenedora Integer .

P.ej:

Integer removeIndex = Integer.valueOf("3");
collection.remove(removeIndex);

Answer 3

Explicación simple del código de Java para visualizar la diferencia entre ArrayList.remove(Object o) y ArrayList.remove(int index)

CÓDIGO:

ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(7);
list.add(4);
list.add(5);
list.add(6);
list.add(7);

for (int a = 0; a < list.size(); a++) {
    System.out.print("" + list.get(a));
}

System.out.print("  ");

//CASE 1: We are removing data object 7.
list.remove(new Integer(7));

for (int a = 0; a < list.size(); a++) {
    System.out.print("" + list.get(a));
}

System.out.print("  ");

//CASE 2: Again we are removing data object 7.
list.remove(new Integer(7));

for (int a = 0; a < list.size(); a++) {
    System.out.print("" + list.get(a));
}

System.out.print("  ");

//CASE 3: We are removing data at index 1
list.remove(1);

for (int a = 0; a < list.size(); a++) {
    System.out.print("" + list.get(a));
}

SALIDA:

1274567
124567
12456
1456

EXPLICACIÓN:

CASO 1: estamos eliminando el primer objeto Integer que se produce con los datos 7.

CASO 2: Entonces nuevamente estamos haciendo lo mismo que en CASE 1 con los datos restantes.

CASO 3: Estamos eliminando datos en la posición de índice 1.

CONCLUSIÓN:

Tomando un ejemplo de ArrayList<Integer> como se usa en el código java anterior: ArrayList.remove(Integer object) simplemente eliminará el objeto Integer específico que aparece primero en ArrayList . Sin embargo, ArrayList.remove(int index) siempre eliminará el elemento de la matriz en una posición de índice determinada.

MÁS SOBRE :

No podemos declarar ArrayList<int> porque int es tipo de datos primario. Cualquier clase que tenga el Object clase base solo se especifica en el tipo de datos genérico ArrayList . por ejemplo: ArrayList<String> , ArrayList<Integer> etc.

Answer 4

Java siempre llama al método que mejor se adapte a su argumento. El auto boxing y upcasting implícito solo se realiza si no hay un método que se pueda invocar sin casting / auto boxing.

La interfaz de Lista especifica dos métodos de eliminación (tenga en cuenta la denominación de los argumentos):

• remove(Object o)
• remove(int index)

Esto significa que list.remove(1) elimina el objeto en la posición 1 y lo remove(new Integer(1)) elimina la primera aparición del elemento especificado de esta lista.

Answer 5

No sé de la manera "correcta", pero la forma en que sugirió funciona muy bien:

list.remove(int_parameter);

elimina el elemento en la posición dada y

list.remove(Integer_parameter);

elimina el objeto dado de la lista.

Es porque VM al principio intenta encontrar el método declarado con exactamente el mismo tipo de parámetro y solo luego prueba el autoboxing.

Answer 6

Puedes usar casting

list.remove((int) n);

y

list.remove((Integer) n);

No importa si n es un entero o entero, el método siempre llamará al que espera.

Usar (Integer) n Integer.valueOf(n) es más eficiente que el new Integer(n) ya que los dos primeros pueden usar el caché Integer, mientras que el último siempre creará un objeto.

Answer 7

Simplemente me gustó seguir lo sugerido por #decitrig en respuesta aceptada primer comentario.

list.remove(Integer.valueOf(intereger_parameter));

Esto me ayudó. Gracias de nuevo #decitrig por tu comentario. Puede ayudar a alguien.

Answer 8

Tenga en cuenta que incluso si la máquina virtual no hizo lo correcto, lo que hace, aún podría garantizar un comportamiento correcto al utilizar el hecho de que remove(java.lang.Object) opera en objetos arbitrarios:

myList.remove(new Object() {
  @Override
  public boolean equals(Object other) {
    int k = ((Integer) other).intValue();
    return k == 1;
  }
}

Answer 9

list.remove(4) es una coincidencia exacta de list.remove(int index) , por lo que se llamará. Si desea llamar a list.remove(Object) haga lo siguiente: list.remove((Integer)4) .