Bagaimana untuk menukar objek di Jawa?

Menukar objek adalah salah satu tindakan yang paling popular dalam pengaturcaraan. Ia amat berguna dalam menyusun. Apa yang berlaku dalam pertukaran ialah dua pembolehubah menukar nilainya. Dalam artikel ini, kita belajar cara menukar objek dalam Java dalam dua kes berbeza. Satu menukar objek bebas dan satu lagi menukar dua objek dalam Senarai atau Array. Mari kita periksa terlebih dahulu menukar objek bebas.

Menukar objek adalah berbeza daripada menukar jenis data primitif

Salah satu kaedah yang biasa digunakan untuk menukar nilai primitif ialah menggunakan pembolehubah temporal. Walau bagaimanapun, anda tahu Java menggunakan "Pass by Value" apabila menghantar parameter kepada kaedah. Oleh itu, menukar objek tidak akan berfungsi seperti yang anda jangkakan dengan kaedah ini. Contoh berikut akan menunjukkannya.

public class ObjectSwapper {
    public static void main(String[] args) {
        InnerClass obj1 = new InnerClass(12345);
        InnerClass obj2 = new InnerClass(11111);
        swap(obj1, obj2);
        System.out.println("Obj1 ID value : " + obj1.id + "\n" + "Obj2 ID value :  " + obj2.id);
    }
    static void swap(InnerClass x, InnerClass y) {
        InnerClass temp;
        temp = x;
        x = y;
        y = temp;
    }
    static class InnerClass {
        public int id;
        public InnerClass(int Id) {
            this.id = Id;
        }
    }
}

Keluaran: Tiada pertukaran! Apabila kita memanggil kaedah swap dan lulus objek, kita lulus salinan objek, dengan semua nilai harta. Inilah sebab mengapa ia dipanggil "Pass by Value". Kaedah swap sebenarnya menukar objek yang hanya memberi kesan kepada salinan objek asal. Jadi objek asal disimpan tidak berubah. Penyelesaian untuk ini adalah menggunakan kelas pembalut untuk membungkus kedua-dua objek.

Menukar objek dengan kelas pembalut

public class ObjectSwapper {
    public static void main(String[] args) {

        InnerClass obj1 = new InnerClass(12345);
        InnerClass obj2 = new InnerClass(11111);
        objectWrapper wrapperObj1 = new objectWrapper(obj1);
        objectWrapper wrapperObj2 = new objectWrapper(obj2);
        // Values before swapping
        System.out.println("WrapperObj1 InncerClass ID value : " + wrapperObj1.innerObject.id + "\n" + "WrapperObj2 InncerClass ID value : "
                + wrapperObj2.innerObject.id + "\n");

        swap(wrapperObj1, wrapperObj2);

        // Values after swapping
        System.out.println("WrapperObj1 InncerClass ID value : " + wrapperObj1.innerObject.id + "\n" + "WrapperObj2 InncerClass ID value : "
                + wrapperObj2.innerObject.id);
    }

       static void swap(objectWrapper wrapperObj1, objectWrapper wrapperObj2) {
        InnerClass temp;
        temp = wrapperObj1.innerObject;
        wrapperObj1.innerObject = wrapperObj2.innerObject;
        wrapperObj2.innerObject = temp;
    }

    static class InnerClass {
        public int id;
        public InnerClass(int Id) {
            id = Id;
        }
    }

    static class objectWrapper {
        InnerClass innerObject;
        public objectWrapper(InnerClass objInnner) {
            this.innerObject = objInnner;
        }
    }
}

Di sini kami menggunakan kelas pembalut yang mempunyai sifat jenis objek yang perlu kami tukar. Dengan menggunakan kaedah swap mudah, ia menukar kandungan objek InnerClass objek kelas pembalut. Untuk sebarang pelaksanaan selanjutnya bagi objek InnerClass yang ditukar, kami boleh menggunakan wrapperObj1.xyz dan wrapperObj2.xyz dengan sewajarnya. Keluaran:

Kaedah swap() terbina dalam dalam Java

Kelas Rangka Kerja Koleksi Java mempunyai kaedah terbina dalam untuk menukar elemen dipanggil swap() . Java.util ialah kelas utiliti yang mengandungi kaedah statik yang boleh beroperasi pada elemen seperti Senarai daripada antara muka Koleksi . Menggunakan kaedah swap adalah lebih mudah daripada contoh yang kita bincangkan sebelum ini. Kaedah swap() ialah kaedah statik dan oleh itu anda memanggilnya dengan nama kelas sebagai Collections.swap() . Jenis pulangan kaedah swap() adalah tidak sah jadi ia tidak akan mengembalikan apa-apa. Anda perlu menghantar tiga hujah kepada kaedah swap() . Semak nota di bawah.

swap(List<?> list, int a, int b)

Parameter:

• list — senarai mengandungi elemen yang kita tukar.
• a — indeks unsur yang hendak ditukar .
• b — indeks elemen lain yang hendak ditukar .

Ambil perhatian bahawa kaedah ini akan membuang IndexOutOfBoundsException jika sama ada a atau b berada di luar julat saiz senarai. Indeks maksimum senarai adalah kurang satu daripada saiz senarai. Sebarang nilai indeks yang lebih daripada itu akan menyebabkan IndexOutOfBoundsException dibuang. Contoh cara menggunakan kaedah swap pada ArrayList ditunjukkan di bawah.

kaedah swap() pada ArrayList

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ArrayListSwapper {
    public static void main(String[] args) {
        try {
            List fruits = new ArrayList();
            fruits.add("Mango");
            fruits.add("Papaya");
            fruits.add("Apple");
            fruits.add("Orange");
            fruits.add("Watermelon");
            fruits.add("Bael");
            System.out.println("Before swapping : " + fruits);
         //using Collection.swap() method
            Collections.swap(fruits, 2, 5);
            System.out.println("After swapping : " + fruits);
        } catch (IndexOutOfBoundsException e) {
            System.out.println("Index Out of Bound Exception thrown : " + e);
        }
    }
}

ArrayList buah-buahan mengandungi enam elemen. Kami menukar elemen ke-2 ^dan ke-5 ^menggunakan kaedah swap() fungsi . Amalan terbaik ialah menulis kaedah swap() dalam blok cuba-tangkap kerana ia boleh membuang IndexOutOfBoundsException pada masa berjalan. Output: Jika kita melepasi '2' dan '8' sebagai indeks, aplikasi akan membuang pengecualian kerana saiz senarai ialah enam.

Collections.swap(fruits, 2, 8);

Outputnya ialah:

Kesimpulan

Dalam tutorial ini, kami membincangkan beberapa teknik pertukaran yang digunakan dalam Java. Salah satunya menggunakan kelas pembalut dan satu lagi menggunakan kaedah Collection.swap() . Adalah penting untuk diingat bahawa pengendalian pengecualian harus dilakukan apabila menggunakan fungsi swap() kerana ia membuang pengecualian masa jalan.