จะสลับวัตถุใน Java ได้อย่างไร

การสลับวัตถุเป็นหนึ่งในการกระทำที่ได้รับความนิยมมากที่สุดในการเขียนโปรแกรม มีประโยชน์อย่างยิ่งในการเรียงลำดับ สิ่งที่เกิดขึ้นในการสลับคือตัวแปรสองตัวแลกเปลี่ยนค่าของพวกมัน ในบทความนี้ เราจะเรียนรู้วิธีสลับวัตถุใน Java ในสองกรณีที่แตกต่างกัน หนึ่งกำลังสลับวัตถุอิสระและอีกอันกำลังสลับสองวัตถุในรายการหรืออาร์เรย์ ขั้นแรกให้ตรวจสอบการแลกเปลี่ยนวัตถุอิสระ

การสลับวัตถุแตกต่างจากการสลับประเภทข้อมูลดั้งเดิม

หนึ่งในวิธีทั่วไปที่ใช้ในการสลับค่าดั้งเดิมคือการใช้ตัวแปรชั่วคราว อย่างไรก็ตาม คุณทราบดีว่า Java ใช้ “Pass by Value” เมื่อส่งพารามิเตอร์ไปยังเมธอด ดังนั้น การสลับวัตถุจะไม่ทำงานตามที่คุณคาดหวังด้วยวิธีนี้ ตัวอย่างต่อไปนี้จะแสดง

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

ผลลัพธ์: ไม่มีการแลกเปลี่ยน! เมื่อเราเรียกใช้เมธอด swap และส่งผ่านอ็อบเจ็กต์ เราจะส่งสำเนาของอ็อบเจ็กต์ พร้อมด้วยค่าคุณสมบัติทั้งหมด นี่คือเหตุผลที่เรียกว่า “ส่งต่อคุณค่า” วิธีการสลับจริง ๆ แล้วสลับวัตถุที่ส่งผลกระทบต่อสำเนาของวัตถุต้นฉบับเท่านั้น ดังนั้นวัตถุดั้งเดิมจึงไม่มีการเปลี่ยนแปลง วิธีแก้ปัญหานี้คือการใช้คลาส wrapper เพื่อห่อวัตถุทั้งสอง

การสลับวัตถุด้วยคลาส 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;
        }
    }
}

ที่นี่เราใช้คลาส wrapper ที่มีคุณสมบัติของประเภทของวัตถุที่เราต้องการสลับ ด้วยการใช้วิธีสลับอย่างง่าย มันจะสลับเนื้อหาของอ็อบเจกต์ InnerClass ของอ็อบเจ็กต์คลาส wrapper สำหรับการใช้งานเพิ่มเติมของวัตถุ InnerClass ที่สลับ เราสามารถใช้ wrapperObj1.xyz และ wrapperObj2.xyz ตามลำดับ ผลลัพธ์:

วิธีการ swap() ในตัวใน Java

คลาสของ Java Collections Framework มีเมธอดในตัวเพื่อสลับองค์ประกอบที่เรียกว่าswap( ) java.util เป็นคลาสยูทิลิตี้ที่มีเมธอดสแตติกที่สามารถดำเนินการกับองค์ประกอบต่างๆ เช่น รายการจากอินเทอร์เฟซคอลเลกชัน การใช้วิธีการ swap นั้นง่ายกว่าตัวอย่างที่เรากล่าวถึงก่อนหน้านี้มาก เมธอดswap()เป็นเมธอดแบบคงที่ ดังนั้นคุณจึงเรียกมันด้วยชื่อคลาสเป็นCollections.swap( ) ประเภทการคืนค่าของเมธอดswap()นั้นเป็นโมฆะ ดังนั้นมันจะไม่ส่งคืนอะไรเลย คุณต้องส่งอาร์กิวเมนต์สามรายการไปยังเมธอดswap() ตรวจสอบหมายเหตุด้านล่าง

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

พารามิเตอร์:

• รายการ — รายการประกอบด้วยองค์ประกอบที่เราแลกเปลี่ยน
• a — ดัชนีขององค์ประกอบที่จะสลับ
• b — ดัชนีขององค์ประกอบอื่นที่จะสลับ

โปรดทราบว่าวิธีนี้จะส่ง IndexOutOfBoundsException หาก a หรือ b อยู่นอกช่วงของขนาดรายการ ดัชนีสูงสุดของรายการน้อยกว่าขนาดของรายการหนึ่งรายการ ค่าดัชนีใด ๆ ที่มากกว่านั้นจะทำให้ IndexOutOfBoundsException ถูกส่งออกไป ตัวอย่างของการใช้เมธอด swap บน ArrayList แสดงอยู่ด้านล่าง

วิธีการ swap() บน 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 ของผลไม้มีหกองค์ประกอบ เราสลับองค์ประกอบที่ 2 ^และ 5 ^โดยใช้วิธีฟังก์ชัน swap() วิธีปฏิบัติที่ดีที่สุดคือการเขียนเมธอดswap()ภายในบล็อก try-catch เนื่องจากสามารถส่ง IndexOutOfBoundsException ในขณะรันไทม์ได้ ผลลัพธ์: หากเราส่ง '2' และ '8' เป็นดัชนี แอปพลิเคชันจะส่งข้อยกเว้นเนื่องจากขนาดของรายการคือ 6

Collections.swap(fruits, 2, 8);

ผลลัพธ์จะเป็น:

บทสรุป

ในบทช่วยสอนนี้ เราได้กล่าวถึงเทคนิคการสลับที่ใช้ใน Java หนึ่งในนั้นใช้คลาส wrapper และอีกอันใช้เมธอด Collection.swap() สิ่งสำคัญคือต้องจำไว้ว่าการจัดการข้อยกเว้นควรทำเมื่อใช้ฟังก์ชันswap()เนื่องจากจะส่งข้อยกเว้นรันไทม์