Menghapus Integer dengan benar dari Daftar <Integer>

Ini perangkap yang bagus yang baru saja saya temui. Pertimbangkan daftar bilangan bulat:

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

Adakah tebakan berpendidikan tentang apa yang terjadi ketika Anda mengeksekusi list.remove(1)? Bagaimana dengan list.remove(new Integer(1))? Ini dapat menyebabkan beberapa bug jahat.

Apa cara yang tepat untuk membedakan remove(int index), yang menghilangkan elemen dari indeks yang diberikan dan remove(Object o), yang menghilangkan elemen dengan referensi, ketika berhadapan dengan daftar bilangan bulat?

Poin utama yang perlu dipertimbangkan di sini adalah yang @Nikita sebutkan - pencocokan parameter yang tepat lebih diutamakan daripada tinju otomatis.

Java selalu memanggil metode yang paling sesuai dengan argumen Anda. Tinju otomatis dan upcasting implisit hanya dilakukan jika tidak ada metode yang dapat dipanggil tanpa casting / tinju otomatis.

Antarmuka Daftar menetapkan dua metode penghapusan (harap perhatikan penamaan argumen):

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

Itu berarti bahwa list.remove(1)menghapus objek di posisi 1 dan remove(new Integer(1))menghilangkan kejadian pertama dari elemen yang ditentukan dari daftar ini.

Anda bisa menggunakan casting

list.remove((int) n);

dan

list.remove((Integer) n);

Tidak masalah jika n adalah int atau Integer, metode ini akan selalu memanggil yang Anda harapkan.

Menggunakan (Integer) natau Integer.valueOf(n)lebih efisien daripada new Integer(n)dua yang pertama dapat menggunakan cache Integer, sedangkan yang berikutnya akan selalu membuat objek.

Saya tidak tahu tentang cara yang 'pantas', tetapi cara yang Anda sarankan berfungsi dengan baik:

list.remove(int_parameter);

menghapus elemen pada posisi yang diberikan dan

list.remove(Integer_parameter);

menghapus objek yang diberikan dari daftar.

Itu karena VM pada awalnya mencoba untuk menemukan metode yang dideklarasikan dengan tipe parameter yang persis sama dan hanya kemudian mencoba autoboxing.

list.remove(4)adalah pasangan yang tepat list.remove(int index), sehingga akan dipanggil. Jika Anda ingin panggilan list.remove(Object)melakukan hal berikut: list.remove((Integer)4).

Adakah tebakan berpendidikan tentang apa yang terjadi ketika Anda menjalankan list.remove (1)? Bagaimana dengan list.remove (Integer baru (1))?

Tidak perlu menebak. Kasing pertama akan menghasilkan List.remove(int)dipanggil, dan elemen pada posisi 1akan dihapus. Kasus kedua akan menghasilkan List.remove(Integer)dipanggil, dan elemen yang nilainya sama dengan Integer(1)akan dihapus. Dalam kedua kasus, kompiler Java memilih kelebihan pencocokan terdekat.

Ya, ada potensi kebingungan (dan bug) di sini, tetapi ini adalah kasus penggunaan yang tidak biasa.

Ketika kedua List.removemetode didefinisikan di Java 1.2, kelebihan tidak tidak ambigu. Masalahnya hanya muncul dengan pengenalan obat generik dan autoboxing di Jawa 1.5. Dalam pandangan belakang, akan lebih baik jika salah satu metode pemindahan diberi nama yang berbeda. Tapi sekarang sudah terlambat.

Perhatikan bahwa bahkan jika VM tidak melakukan hal yang benar, yang dilakukan, Anda masih bisa memastikan perilaku yang tepat dengan menggunakan fakta yang remove(java.lang.Object)beroperasi pada objek yang berubah-ubah:

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

Cukup saya suka mengikuti seperti yang disarankan oleh #decitrig dalam jawaban pertama komentar yang diterima.

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

Ini membantu saya. Terima kasih lagi #decitrig atas komentar Anda. Mungkin membantu untuk seseorang.

Nah di sini adalah triknya.

Mari kita ambil dua contoh di sini:

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

  }

}

Sekarang mari kita lihat hasilnya:

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]

Sekarang mari kita menganalisis hasilnya:

1. Ketika 3 dihapus dari koleksi itu memanggil remove()metode koleksi yang diambil Object osebagai parameter. Karenanya ia menghilangkan objek 3. Tetapi dalam objek arrayList ditimpa oleh indeks 3 dan karenanya elemen ke-4 dihapus.

2. Dengan logika yang sama dari penghapusan objek null dihapus dalam kedua kasus di output kedua.

Jadi untuk menghapus angka 3yang merupakan objek, kita secara eksplisit perlu melewati 3 sebagai object.

Dan itu bisa dilakukan dengan casting atau pembungkus menggunakan kelas wrapper Integer.

Misalnya:

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