Kepiye carane ngganti obyek ing Jawa?

Ngganti obyek minangka salah sawijining tumindak sing paling populer ing pemrograman. Iku utamané migunani ing ngurutake. Apa sing kedadeyan ing swapping yaiku rong variabel sing ngganti nilai. Ing artikel iki, kita sinau carane ngganti obyek ing Jawa ing rong kasus beda. Siji ngganti obyek independen lan liyane ngganti rong obyek ing Daftar utawa Array. Ayo ditliti dhisik ngganti obyek independen.

Ngganti obyek beda karo ngganti jinis data primitif

Salah sawijining cara sing umum digunakake kanggo ngganti nilai primitif yaiku nggunakake variabel temporal. Nanging, sampeyan ngerti Java nggunakake "Pass by Value" nalika ngirim parameter menyang metode. Mulane, ngganti obyek ora bisa kaya sing dikarepake karo metode iki. Conto ing ngisor iki bakal nuduhake.

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

Output: Ora ana swapping! Nalika kita nelpon cara swap lan pass obyek, kita pass salinan obyek, karo kabeh nilai property. Iki minangka alesan kenapa diarani "Pass by Value". Cara swap bener-bener ngganti obyek sing mung mengaruhi salinan obyek asli. Dadi obyek asli tetep ora owah. Solusi kanggo iki bakal nggunakake kelas pambungkus kanggo mbungkus rong obyek.

Ngganti obyek karo kelas pambungkus

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

Ing kene kita nggunakake kelas pambungkus sing nduweni properti saka jinis obyek sing kudu diganti. Kanthi nggunakake cara swap prasaja, swap isi obyek InnerClass obyek kelas pambungkus. Kanggo implementasine luwih saka obyek InnerClass swapped, kita bisa nggunakake wrapperObj1.xyz lan wrapperObj2.xyz patut. Output:

Metode swap () sing dibangun ing Jawa

Kelas Java Collections Framework duwe metode sing dibangun kanggo ngganti unsur sing diarani swap() . Java.util minangka kelas sarana sing ngemot cara statis sing bisa digunakake ing unsur kaya Dhaptar saka antarmuka Koleksi. Nggunakake metode swap luwih gampang tinimbang conto sing wis dibahas sadurunge. Cara swap () iku cara statis lan mulane sampeyan njaluk karo jeneng kelas minangka Collections.swap () . Jinis bali saka cara swap () ora sah supaya ora bakal ngasilake apa-apa. Sampeyan kudu pass telung bantahan kanggo cara swap () . Priksa cathetan ing ngisor iki.

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

Parameter:

• dhaftar - dhaftar ngemot unsur kita pertukaran.
• a - indeks saka unsur sing bakal diganti .
• b - indeks saka unsur liyane sing bakal diganti .

Elinga yen cara iki bakal mbuwang IndexOutOfBoundsException yen a utawa b metu saka sawetara ukuran dhaftar. Indeks maksimum dhaptar kurang siji saka ukuran dhaptar. Nilai indeks apa wae sing luwih saka iku bakal nyebabake IndexOutOfBoundsException dibuwang. Conto carane nggunakake cara swap ing ArrayList kapacak ing ngisor iki.

metode swap() ing 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 woh-wohan ngemot enem unsur. Kita ngganti unsur 2 ^lan 5 ^nggunakake metode fungsi swap () . Praktek paling apik yaiku nulis metode swap () ing blok cob-catch amarga bisa mbuwang IndexOutOfBoundsException nalika mbukak. Output: Yen kita pass '2' lan '8' minangka indeks aplikasi bakal uncalan pangecualian minangka ukuran dhaftar enem.

Collections.swap(fruits, 2, 8);

Output bakal:

Kesimpulan

Ing tutorial iki, kita ngrembug sawetara teknik pertukaran sing digunakake ing basa Jawa. Salah sijine nggunakake kelas pambungkus lan liyane nggunakake metode Collection.swap () . Penting kanggo elinga yen penanganan pangecualian kudu ditindakake nalika nggunakake fungsi swap () amarga mbuwang pengecualian runtime.