Java मध्ये ऑब्जेक्ट्स स्वॅप कसे करावे?

ऑब्जेक्ट्स बदलणे ही प्रोग्रामिंगमधील सर्वात लोकप्रिय क्रिया आहे. वर्गीकरणात हे विशेषतः उपयुक्त आहे. स्वॅपिंगमध्ये काय होते ते दोन व्हेरिएबल्स त्यांच्या मूल्यांची देवाणघेवाण करतात. या लेखात, आपण दोन वेगवेगळ्या केसेसमध्ये Java मध्ये ऑब्जेक्ट्स कसे स्वॅप करायचे ते शिकू. एक म्हणजे स्वतंत्र वस्तूंची अदलाबदल करणे आणि दुसरी यादी किंवा अॅरेमधील दोन वस्तूंची अदलाबदल करणे. प्रथम स्वतंत्र वस्तूंचे स्वॅपिंगचे परीक्षण करूया.

ऑब्जेक्ट्स स्वॅप करणे हे आदिम डेटा प्रकार स्वॅप करण्यापेक्षा वेगळे आहे

आदिम मूल्ये बदलण्यासाठी वापरल्या जाणार्‍या सामान्य पद्धतींपैकी एक म्हणजे टेम्पोरल व्हेरिएबल वापरणे. तथापि, तुम्हाला माहित आहे की जावा एखाद्या पद्धतीमध्ये पॅरामीटर्स पास करताना "पॅस बाय व्हॅल्यू" वापरते. त्यामुळे, या पद्धतीसह वस्तूंची अदलाबदली तुमच्या अपेक्षेप्रमाणे कार्य करणार नाही. पुढील उदाहरण ते दर्शवेल.

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 वापरू शकतो. आउटपुट:

Java मधील अंगभूत स्वॅप() पद्धत

Java Collection Framework च्या क्लासेसमध्ये swap() नावाचे घटक स्वॅप करण्यासाठी अंगभूत पद्धत असते . java.util हा एक युटिलिटी क्लास आहे ज्यामध्ये स्टॅटिक पद्धती आहेत ज्या कलेक्शन इंटरफेसमधील लिस्ट सारख्या घटकांवर ऑपरेट करू शकतात. आपण आधी चर्चा केलेल्या उदाहरणापेक्षा स्वॅप पद्धत वापरणे खूप सोपे आहे. swap () पद्धत ही एक स्थिर पद्धत आहे आणि म्हणून तुम्ही ती Collections.swap() या वर्गाच्या नावाने चालवू शकता . swap() पद्धतीचा रिटर्न प्रकार शून्य आहे त्यामुळे ते काहीही परत करणार नाही. तुम्हाला swap() पद्धतीमध्ये तीन वितर्क पास करावे लागतील . खालील टीप तपासा.

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

पॅरामीटर्स:

• सूची - सूचीमध्ये आपण स्वॅप केलेले घटक असतात.
• a — स्वॅप करावयाच्या घटकाची अनुक्रमणिका .
• b — स्वॅप करायच्या दुसर्‍या घटकाची अनुक्रमणिका .

लक्षात ठेवा की जर a किंवा b सूची आकाराच्या श्रेणीबाहेर असेल तर ही पद्धत IndexOutOfBoundsException टाकेल. सूचीची कमाल अनुक्रमणिका सूचीच्या आकारापेक्षा एक कमी आहे. त्‍यापेक्षा जास्त असलेल्‍या कोणतेही इंडेक्स व्हॅल्यू IndexOutOfBoundsException फेकण्‍यास कारणीभूत ठरेल. ArrayList वर स्वॅप पद्धत कशी वापरायची याचे उदाहरण खाली दाखवले आहे.

ArrayList वर swap() पद्धत

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

फळांच्या अॅरेलिस्टमध्ये सहा घटक असतात. फंक्शन swap() पद्धतीचा वापर करून आपण 2 ^रा आणि 5 ^वा घटक स्वॅप करतो . ट्राय-कॅच ब्लॉकमध्ये स्वॅप() पद्धत लिहिणे हा सर्वोत्तम सराव आहे कारण तो रन टाइममध्ये IndexOutOfBoundsException टाकू शकतो. आउटपुट: जर आपण '2' आणि '8' अनुक्रमणिका म्हणून पास केले तर अनुप्रयोग अपवाद करेल कारण सूचीचा आकार सहा आहे.

Collections.swap(fruits, 2, 8);

आउटपुट असेल:

निष्कर्ष

या ट्यूटोरियलमध्ये, आम्ही Java मध्ये वापरल्या जाणार्‍या काही स्वॅपिंग तंत्रांची चर्चा केली. त्यापैकी एक रॅपर क्लास वापरत आहे आणि दुसरा Collection.swap() पद्धत वापरत आहे. हे लक्षात ठेवणे महत्त्वाचे आहे की फंक्शन swap() वापरताना अपवाद हाताळणी केली पाहिजे कारण ते रनटाइम अपवाद टाकते.