Suppression appropriée d'un entier d'une liste <Integer>

Voici un joli piège que je viens de rencontrer. Considérez une liste d'entiers:

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

Une supposition éclairée sur ce qui se passe lorsque vous exécutez list.remove(1)? Et alors list.remove(new Integer(1))? Cela peut provoquer des bugs désagréables.

Quelle est la bonne façon de faire la différence entre remove(int index), qui supprime un élément d'un index donné et remove(Object o), qui supprime un élément par référence, lorsqu'il s'agit de listes d'entiers?

Le principal point à considérer ici est celui mentionné par @Nikita - la correspondance exacte des paramètres a priorité sur la boxe automatique.

Java appelle toujours la méthode qui convient le mieux à votre argument. La boxe automatique et la conversion ascendante implicite ne sont effectuées que s'il n'y a pas de méthode pouvant être appelée sans casting / boxe automatique.

L'interface List spécifie deux méthodes de suppression (veuillez noter la dénomination des arguments):

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

Cela signifie que list.remove(1)supprime l'objet à la position 1 et remove(new Integer(1))supprime la première occurrence de l'élément spécifié de cette liste.

Vous pouvez utiliser le casting

list.remove((int) n);

et

list.remove((Integer) n);

Peu importe si n est un entier ou un entier, la méthode appellera toujours celle que vous attendez.

Utiliser (Integer) nou Integer.valueOf(n)est plus efficace que new Integer(n)les deux premiers peuvent utiliser le cache Integer, tandis que le dernier créera toujours un objet.

Je ne connais pas la bonne façon, mais la façon dont vous avez suggéré fonctionne très bien:

list.remove(int_parameter);

supprime l'élément à une position donnée et

list.remove(Integer_parameter);

supprime l'objet donné de la liste.

C'est parce que VM essaie d'abord de trouver la méthode déclarée avec exactement le même type de paramètre et essaie seulement ensuite la case automatique.

list.remove(4)est une correspondance exacte de list.remove(int index), il sera donc appelé. Si vous voulez appeler list.remove(Object)procédez comme suit: list.remove((Integer)4).

Une supposition éclairée sur ce qui se passe lorsque vous exécutez list.remove (1)? Qu'en est-il de list.remove (nouvel entier (1))?

Inutile de deviner. Le premier cas entraînera List.remove(int)un appel et l'élément en position 1sera supprimé. Le deuxième cas entraînera List.remove(Integer)un appel et l'élément dont la valeur est égale à Integer(1)sera supprimé. Dans les deux cas, le compilateur Java sélectionne la surcharge correspondante la plus proche.

Oui, il y a un risque de confusion (et de bugs) ici, mais c'est un cas d'utilisation assez rare.

Lorsque les deux List.removeméthodes ont été définies dans Java 1.2, les surcharges n'étaient pas ambiguës. Le problème ne s'est posé qu'avec l'introduction des génériques et de l'autoboxing dans Java 1.5. Avec le recul, il aurait été préférable de donner un nom différent à l'une des méthodes de suppression. Mais il est trop tard maintenant.

Notez que même si la machine virtuelle n'a pas fait la bonne chose, ce qu'elle fait, vous pouvez toujours garantir un comportement correct en utilisant le fait qui remove(java.lang.Object)fonctionne sur des objets arbitraires:

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

J'ai simplement aimé suivre comme suggéré par #decitrig dans le premier commentaire de réponse acceptée.

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

Cela m'a aidé. Merci encore #decitrig pour votre commentaire. Cela peut aider quelqu'un.

Eh bien, voici l'astuce.

Prenons deux exemples ici:

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

  }

}

Voyons maintenant la sortie:

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]

Analysons maintenant la sortie:

1. Lorsque 3 est supprimé de la collection, il appelle la remove()méthode de la collection qui prend Object ocomme paramètre. Par conséquent, il supprime l'objet 3. Mais dans l'objet arrayList, il est remplacé par l'index 3 et donc le 4ème élément est supprimé.

2. Par la même logique de suppression d'objet, null est supprimé dans les deux cas dans la deuxième sortie.

Donc, pour supprimer le nombre 3qui est un objet, nous devrons explicitement passer 3 en tant queobject .

Et cela peut être fait par cast ou wrapping en utilisant la classe wrapper Integer .

Par exemple:

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