Hogyan lehet objektumokat cserélni Java-ban?

Az objektumok cseréje a programozás egyik legnépszerűbb művelete. Rendezésnél különösen hasznos. A csere során két változó cseréli ki az értékeit. Ebből a cikkből megtudjuk, hogyan cserélhetünk objektumokat Java nyelven két különböző esetben. Az egyik független objektumok cseréje, a másik pedig két objektum felcserélése egy listában vagy egy tömbben. Először vizsgáljuk meg a független objektumok felcserélését.

Az objektumok cseréje eltér a primitív adattípusok cseréjétől

A primitív értékek felcserélésére használt egyik általános módszer az időbeli változó használata. Tudja azonban, hogy a Java a „Pass by Value” funkciót használja, amikor paramétereket ad át egy metódusnak. Ezért az objektumok cseréje nem úgy működik, ahogyan ezzel a módszerrel várta. A következő példa megmutatja.

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

A kimenet: Nem volt csere! Amikor meghívjuk a swap metódust és átadjuk az objektumokat, akkor átadjuk az objektum másolatát, az összes tulajdonságértékkel együtt. Ez az oka annak, hogy „érték szerinti átadásnak” nevezik. A swap metódus valójában csak az eredeti objektum másolatára ható objektumokat cseréli fel. Így az eredeti tárgyak változatlanok maradnak. Erre az lenne a megoldás, ha egy wrapper osztályt használnánk a két objektum burkolására.

Objektumok cseréje egy burkoló osztállyal

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

Itt egy wrapper osztályt használtunk, amelynek van egy olyan tulajdonsága, hogy milyen típusú objektumokat kell cserélnünk. Egy egyszerű swap metódus használatával felcseréli a wrapper osztály objektumok InnerClass objektumainak tartalmát. A felcserélt InnerClass objektumok további megvalósításához ennek megfelelően használhatjuk a wrapperObj1.xyz és a wrapperObj2.xyz fájlokat. A kimenet:

A Java beépített swap() metódusa

A Java Collections Framework osztályaiban van egy beépített metódus az elemek cseréjére , swap() néven . A java.util egy segédprogramosztály, amely statikus metódusokat tartalmaz, amelyek olyan elemeken működhetnek, mint a Listák a Gyűjtemény felületéről. A swap módszer használata sokkal egyszerűbb, mint a korábban tárgyalt példa. A swap() metódus egy statikus metódus, ezért a Collections.swap() osztálynévvel hívja meg . A swap() metódus visszatérési típusa érvénytelen, így nem ad vissza semmit. Három argumentumot kell átadnia a swap() metódusnak. Ellenőrizze az alábbi megjegyzést.

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

Paraméterek:

• lista — a lista azokat az elemeket tartalmazza, amelyeket felcserélünk.
• a — cserélni kívánt elem indexe .
• b — egy másik cserélni kívánt elem indexe .

Vegye figyelembe, hogy ez a módszer egy IndexOutOfBoundsException kivételt dob, ha a vagy a b a lista méretének tartományán kívül esik. A lista maximális indexe eggyel kisebb, mint a lista mérete. Az ennél nagyobb indexértékek az IndexOutOfBoundsException kivetítését okozzák. Az alábbiakban látható egy példa arra, hogyan kell használni a swap metódust egy ArrayList-en.

swap() metódus egy ArrayList-en

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

A gyümölcsök ArrayListája hat elemet tartalmaz. ^{A 2.} és 5. ^{elemet a} swap() függvény segítségével felcseréljük . A legjobb gyakorlat az, ha a swap() metódust egy try-catch blokkba írjuk, mivel az IndexOutOfBoundsException kivételt dobhat futás közben. A kimenet: Ha '2' és '8' indexet adunk meg, az alkalmazás kivételt dob, mivel a lista mérete hat.

Collections.swap(fruits, 2, 8);

A kimenet a következő lesz:

Következtetés

Ebben az oktatóanyagban néhány Java-ban használt cseretechnikát tárgyaltunk. Az egyik wrapper osztályt használ, a másik pedig Collection.swap() metódust. Fontos megjegyezni, hogy a kivételkezelést a swap() függvény használatakor kell elvégezni , mivel az futásidejű kivételt dob.