జావాలో వస్తువులను ఎలా మార్చుకోవాలి?

ప్రోగ్రామింగ్‌లో వస్తువులను మార్చుకోవడం అత్యంత ప్రజాదరణ పొందిన చర్యలలో ఒకటి. క్రమబద్ధీకరణలో ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది. ఇచ్చిపుచ్చుకోవడంలో జరిగేది రెండు వేరియబుల్స్ వాటి విలువలను మార్పిడి చేసుకోవడం. ఈ కథనంలో, జావాలోని వస్తువులను రెండు వేర్వేరు సందర్భాలలో ఎలా మార్చుకోవాలో నేర్చుకుంటాము . ఒకటి స్వతంత్ర వస్తువులను మార్చుకోవడం మరియు మరొకటి జాబితా లేదా అర్రేలోని రెండు వస్తువులను మార్పిడి చేయడం. స్వతంత్ర వస్తువులను మార్చుకోవడాన్ని మొదట పరిశీలిద్దాం.

ఆబ్జెక్ట్‌లను మార్చుకోవడం అనేది ఆదిమ డేటా రకాలను మార్చుకోవడం కంటే భిన్నంగా ఉంటుంది

ఆదిమ విలువలను మార్చుకోవడానికి ఉపయోగించే సాధారణ పద్ధతుల్లో ఒకటి టెంపోరల్ వేరియబుల్‌ని ఉపయోగించడం. అయినప్పటికీ, ఒక పద్ధతికి పారామితులను పంపేటప్పుడు జావా "పాస్ బై వాల్యూ"ని ఉపయోగిస్తుందని మీకు తెలుసు. కాబట్టి, ఈ పద్ధతితో మీరు ఊహించిన విధంగా వస్తువులను మార్చుకోవడం పని చేయదు. కింది ఉదాహరణ దానిని చూపుతుంది.

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

అవుట్‌పుట్: మార్పిడి లేదు! మేము స్వాప్ పద్ధతిని పిలిచి, ఆబ్జెక్ట్‌లను పాస్ చేసినప్పుడు, మేము అన్ని ఆస్తి విలువలతో ఆబ్జెక్ట్ యొక్క కాపీని పాస్ చేస్తాము. అందుకే దీన్ని “పాస్ బై వాల్యూ” అంటారు. స్వాప్ పద్ధతి వాస్తవానికి అసలు వస్తువు యొక్క కాపీని మాత్రమే ప్రభావితం చేసే వస్తువులను మార్పిడి చేస్తుంది. కాబట్టి అసలు వస్తువులు మారకుండా ఉంచబడతాయి. రెండు వస్తువులను చుట్టడానికి రేపర్ క్లాస్‌ని ఉపయోగించడం దీనికి పరిష్కారం.

రేపర్ క్లాస్‌తో వస్తువులను మార్చుకోవడం

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

ఇక్కడ మనం మార్పిడి చేయాల్సిన వస్తువుల రకాన్ని కలిగి ఉండే రేపర్ క్లాస్‌ని ఉపయోగించాము. సరళమైన స్వాప్ పద్ధతిని ఉపయోగించడం ద్వారా, ఇది రేపర్ క్లాస్ ఆబ్జెక్ట్‌ల యొక్క ఇన్నర్‌క్లాస్ ఆబ్జెక్ట్‌ల కంటెంట్‌ను మార్చుకుంటుంది. మార్పిడి చేసిన ఇన్నర్‌క్లాస్ ఆబ్జెక్ట్‌ల యొక్క ఏదైనా తదుపరి అమలు కోసం, మేము తదనుగుణంగా wrapperObj1.xyz మరియు wrapperObj2.xyzలను ఉపయోగించవచ్చు. అవుట్‌పుట్:

జావాలో అంతర్నిర్మిత స్వాప్() పద్ధతి

జావా కలెక్షన్స్ ఫ్రేమ్‌వర్క్ యొక్క తరగతులు swap() అని పిలువబడే మూలకాలను స్వాప్ చేయడానికి అంతర్నిర్మిత పద్ధతిని కలిగి ఉన్నాయి . java.util అనేది సేకరణ ఇంటర్‌ఫేస్ నుండి జాబితాల వంటి మూలకాలపై పనిచేసే స్టాటిక్ పద్ధతులను కలిగి ఉండే యుటిలిటీ క్లాస్. మేము ఇంతకు ముందు చర్చించిన ఉదాహరణ కంటే స్వాప్ పద్ధతిని ఉపయోగించడం చాలా సులభం. swap () పద్ధతి ఒక స్టాటిక్ మెథడ్ కాబట్టి మీరు Collections.swap() అనే క్లాస్ పేరుతో దీన్ని ఇన్వోక్ చేయండి . స్వాప్() పద్ధతి యొక్క రిటర్న్ రకం శూన్యం కాబట్టి అది దేనినీ తిరిగి ఇవ్వదు. మీరు స్వాప్() పద్ధతికి మూడు ఆర్గ్యుమెంట్‌లను పాస్ చేయాలి . దిగువ గమనికను తనిఖీ చేయండి.

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

పారామితులు:

• list — జాబితా మనం మార్చుకునే మూలకాలను కలిగి ఉంటుంది.
• a — మార్పిడి చేయవలసిన మూలకం యొక్క సూచిక .
• b — మార్పిడి చేయవలసిన మరొక మూలకం యొక్క సూచిక .

a లేదా b జాబితా పరిమాణం పరిధిని దాటి ఉంటే ఈ పద్ధతి IndexOutOfBoundsExceptionని విసిరివేస్తుందని గమనించండి. జాబితా యొక్క గరిష్ట సూచిక జాబితా పరిమాణం కంటే ఒకటి తక్కువగా ఉంటుంది. ఇండెక్స్‌అవుట్‌ఆఫ్‌బౌండ్స్‌ఎక్సెప్షన్‌ని దాని కంటే ఎక్కువ ఏదైనా ఇండెక్స్ విలువ విసిరివేస్తుంది. అర్రేలిస్ట్‌లో స్వాప్ పద్ధతిని ఎలా ఉపయోగించాలో ఉదాహరణ క్రింద చూపబడింది.

అర్రేలిస్ట్‌లో స్వాప్() పద్ధతి

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

పండ్ల శ్రేణిలో ఆరు మూలకాలు ఉన్నాయి. మేము ఫంక్షన్ స్వాప్() పద్ధతిని ఉపయోగించి 2 ^nd మరియు 5 ^వ మూలకాలను మార్చుకుంటాము . రన్ టైమ్‌లో IndexOutOfBoundsExceptionని విసిరివేయగలగడం వలన, swap() పద్ధతిని ట్రై-క్యాచ్ బ్లాక్‌లో వ్రాయడం ఉత్తమ అభ్యాసం . అవుట్‌పుట్: మనం '2' మరియు '8'లను ఇండెక్స్‌లుగా పాస్ చేస్తే, జాబితా పరిమాణం ఆరు ఉన్నందున అప్లికేషన్ మినహాయింపును ఇస్తుంది.

Collections.swap(fruits, 2, 8);

అవుట్‌పుట్ ఇలా ఉంటుంది:

ముగింపు

ఈ ట్యుటోరియల్‌లో, మేము జావాలో ఉపయోగించే కొన్ని స్వాపింగ్ టెక్నిక్‌లను చర్చించాము. వాటిలో ఒకటి రేపర్ క్లాస్‌ని ఉపయోగిస్తోంది మరియు మరొకటి Collection.swap() పద్ధతిని ఉపయోగిస్తోంది. ఫంక్షన్ స్వాప్()ని ఉపయోగిస్తున్నప్పుడు మినహాయింపు నిర్వహణ జరగాలని గుర్తుంచుకోవడం ముఖ్యం, ఎందుకంటే ఇది రన్‌టైమ్ మినహాయింపును ఇస్తుంది.