Paano magpalit ng mga bagay sa Java?

Ang pagpapalit ng mga bagay ay isa sa pinakasikat na pagkilos sa programming. Ito ay partikular na kapaki-pakinabang sa pag-uuri. Ang nangyayari sa pagpapalit ay dalawang variable na nagpapalitan ng kanilang mga halaga. Sa artikulong ito, natutunan namin kung paano magpalit ng mga bagay sa Java sa dalawang magkaibang kaso. Ang isa ay nagpapalit ng mga independiyenteng bagay at ang isa ay nagpapalit ng dalawang bagay sa isang Listahan o isang Array. Suriin muna natin ang pagpapalit ng mga independiyenteng bagay.

Ang pagpapalit ng mga bagay ay iba sa pagpapalit ng mga primitive na uri ng data

Isa sa mga karaniwang paraan na gagamitin upang magpalit ng mga primitive na halaga ay ang paggamit ng temporal na variable. Gayunpaman, alam mong gumagamit ang Java ng "Pass by Value" kapag nagpapasa ng mga parameter sa isang paraan. Samakatuwid, ang pagpapalit ng mga bagay ay hindi gagana gaya ng iyong inaasahan sa pamamaraang ito. Ipapakita ito ng sumusunod na halimbawa.

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

Ang output: Walang swapping! Kapag tinawag namin ang paraan ng swap at ipinasa ang mga bagay, ipinapasa namin ang isang kopya ng bagay, kasama ang lahat ng mga halaga ng ari-arian. Ito ang dahilan kung bakit tinawag itong "Pass by Value". Ang paraan ng swap ay aktwal na nagpapalit ng mga bagay na nakakaapekto lamang sa kopya ng orihinal na bagay. Kaya't ang mga orihinal na bagay ay pinananatiling hindi nagbabago. Ang solusyon dito ay ang paggamit ng klase ng wrapper para balutin ang dalawang bagay.

Pagpapalit ng mga bagay gamit ang klase ng wrapper

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

Dito ginamit namin ang isang klase ng wrapper na may katangian ng uri ng mga bagay na kailangan naming ipagpalit. Sa pamamagitan ng paggamit ng isang simpleng paraan ng swap, pinapalitan nito ang nilalaman ng mga bagay sa InnerClass ng mga bagay sa klase ng wrapper. Para sa anumang karagdagang pagpapatupad ng mga napalitang bagay na InnerClass, maaari naming gamitin ang wrapperObj1.xyz at wrapperObj2.xyz nang naaayon. Ang output:

Ang built-in na swap() na pamamaraan sa Java

Ang mga klase ng Java Collections Framework ay may built-in na paraan upang magpalit ng mga elemento na tinatawag na swap() . Ang java.util ay isang utility class na naglalaman ng mga static na pamamaraan na maaaring gumana sa mga elemento tulad ng Mga Listahan mula sa interface ng Collection. Ang paggamit ng swap method ay mas madali kaysa sa halimbawang tinalakay natin kanina. Ang swap() method ay isang static na paraan at samakatuwid ay ginagamit mo ito gamit ang pangalan ng klase bilang Collections.swap() . Ang uri ng pagbabalik ng swap() na pamamaraan ay walang bisa kaya hindi ito magbabalik ng anuman. Kailangan mong ipasa ang tatlong argumento sa swap() method. Suriin ang tala sa ibaba.

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

Mga Parameter:

• list — naglalaman ang listahan ng mga elementong pinagpapalitan namin.
• a — index ng isang elemento na ipapalit .
• b — index ng isa pang elemento na ipapalit .

Tandaan na ang pamamaraang ito ay magtapon ng IndexOutOfBoundsException kung alinman sa a o b ay wala sa hanay ng laki ng listahan. Ang pinakamataas na index ng listahan ay mas mababa ng isa kaysa sa laki ng listahan. Ang anumang halaga ng index na higit pa rito ay magiging sanhi ng pag-itsa ng IndexOutOfBoundsException. Ang isang halimbawa ng kung paano gamitin ang paraan ng swap sa isang ArrayList ay ipinapakita sa ibaba.

swap() method sa isang 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);
        }
    }
}

Ang ArrayList ng mga prutas ay naglalaman ng anim na elemento. Pinapalitan namin ang ika-2 ^at ika-5 ^na elemento gamit ang function na swap() na pamamaraan. Ang pinakamahusay na kasanayan ay isulat ang swap() na paraan sa loob ng isang try-catch block dahil maaari itong maghagis ng IndexOutOfBoundsException sa oras ng pagtakbo. Ang output: Kung ipapasa natin ang '2' at '8' bilang mga index, ang application ay maglalagay ng exception dahil anim ang laki ng listahan.

Collections.swap(fruits, 2, 8);

Ang magiging output ay:

Konklusyon

Sa tutorial na ito, tinalakay namin ang ilang mga diskarte sa pagpapalit na ginamit sa Java. Ang isa sa kanila ay gumagamit ng isang klase ng wrapper at ang isa ay gumagamit ng Collection.swap() na pamamaraan. Mahalagang tandaan na ang paghawak ng exception ay dapat gawin kapag ginagamit ang function swap() dahil naglalabas ito ng runtime exception.