Rimozione corretta di un numero intero da un elenco <Numero intero>

Ecco una bella trappola che ho appena incontrato. Considera un elenco di numeri interi:

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

Qualche ipotesi istruita su cosa succede quando si esegue list.remove(1)? Che dire list.remove(new Integer(1))? Ciò può causare alcuni cattivi bug.

Qual è il modo corretto di distinguere tra remove(int index), che rimuove un elemento da un determinato indice e remove(Object o), che rimuove un elemento per riferimento, quando si tratta di elenchi di numeri interi?

Il punto principale da considerare qui è quello menzionato da @Nikita : l'esatta corrispondenza dei parametri ha la precedenza sull'auto -box.

Java chiama sempre il metodo più adatto al tuo argomento. Il boxing automatico e l'upcasting implicito vengono eseguiti solo se non esiste un metodo che può essere chiamato senza casting / boxing automatico.

L'interfaccia Elenco specifica due metodi di rimozione (notare la denominazione degli argomenti):

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

Ciò significa che list.remove(1)rimuove l'oggetto nella posizione 1 e remove(new Integer(1))rimuove la prima occorrenza dell'elemento specificato da questo elenco.

Puoi usare il casting

list.remove((int) n);

e

list.remove((Integer) n);

Non importa se n è un int o Integer, il metodo chiamerà sempre quello che ti aspetti.

L'uso di (Integer) no Integer.valueOf(n)è più efficiente di new Integer(n)come i primi due possono utilizzare la cache di numeri interi, mentre i successivi creeranno sempre un oggetto.

Non conosco il modo "corretto", ma il modo in cui hai suggerito funziona bene:

list.remove(int_parameter);

rimuove l'elemento in una determinata posizione e

list.remove(Integer_parameter);

rimuove un determinato oggetto dall'elenco.

È perché la VM inizialmente tenta di trovare il metodo dichiarato esattamente con lo stesso tipo di parametro e solo allora prova il box automatico.

list.remove(4)è una corrispondenza esatta di list.remove(int index), quindi verrà chiamato. Se si desidera chiamare list.remove(Object)effettuare le seguenti operazioni: list.remove((Integer)4).

Qualche ipotesi plausibile su cosa succede quando si esegue list.remove (1)? Che dire di list.remove (nuovo numero intero (1))?

Non è necessario indovinare. Il primo caso risulterà List.remove(int)essere chiamato e l'elemento in posizione 1verrà rimosso. Il secondo caso risulterà List.remove(Integer)essere chiamato e l'elemento il cui valore è uguale a Integer(1)verrà rimosso. In entrambi i casi, il compilatore Java seleziona il sovraccarico corrispondente più vicino.

Sì, c'è un potenziale di confusione (e bug) qui, ma è un caso d'uso abbastanza raro.

Quando i due List.removemetodi sono stati definiti in Java 1.2, i sovraccarichi non erano ambigui. Il problema è sorto solo con l'introduzione di generici e autoboxing in Java 1.5. Con il senno di poi, sarebbe stato meglio se a uno dei metodi di rimozione fosse stato assegnato un nome diverso. Ma ormai è troppo tardi.

Si noti che anche se la VM non ha fatto la cosa giusta, cosa che fa, è comunque possibile garantire un comportamento corretto utilizzando il fatto che remove(java.lang.Object)opera su oggetti arbitrari:

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

Semplicemente mi è piaciuto seguire come suggerito da #decitrig nel primo commento con risposta accettata.

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

Questo mi ha aiutato. Grazie ancora #decitrig per il tuo commento. Potrebbe essere d'aiuto per qualcuno.

Bene, ecco il trucco.

Facciamo due esempi qui:

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

  }

}

Ora diamo un'occhiata all'output:

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]

Ora analizziamo l'output:

1. Quando 3 viene rimosso dalla raccolta, chiama il remove()metodo della raccolta che accetta Object ocome parametro. Quindi rimuove l'oggetto 3. Ma nell'oggetto arrayList viene sovrascritto dall'indice 3 e quindi il quarto elemento viene rimosso.

2. Con la stessa logica di rimozione degli oggetti, null viene rimosso in entrambi i casi nel secondo output.

Quindi per rimuovere il numero 3che è un oggetto dovremo esplicitamente passare 3 come un object.

E questo può essere fatto lanciando o avvolgendo usando la classe wrapper Integer.

Per esempio:

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