如何在 Java 中交換對象？

交換對像是編程中最流行的操作之一。它在排序時特別有用。交換中發生的是兩個變量交換它們的值。在本文中，我們學習瞭如何在兩種不同情況下交換 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;
        }
    }
}

輸出：沒有交換！當我們調用 swap 方法並傳遞對象時，我們傳遞的是該對象的一個副本，其中包含所有屬性值。這就是為什麼它被稱為“按值傳遞”的原因。swap 方法實際上交換了只影響原始對象副本的對象。所以原始對象保持不變。解決方案是使用包裝器類來包裝這兩個對象。

使用包裝器類交換對象

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

這裡我們使用了一個包裝類，它具有我們需要交換的對像類型的屬性。通過使用簡單的 swap 方法，它交換包裝類對象的 InnerClass 對象的內容。對於交換的 InnerClass 對象的任何進一步實現，我們可以相應地使用 wrapperObj1.xyz 和 wrapperObj2.xyz。輸出：

Java 內置的 swap() 方法

Java Collections Framework 的類有一個內置的方法來交換元素，稱為swap()。java.util是一個包含靜態方法的實用程序類，這些方法可以對 Collection 接口中的列表等元素進行操作。使用 swap 方法比我們之前討論的示例要容易得多。swap ()方法是一個靜態方法，因此您可以使用類名Collections.swap()來調用它。swap()方法的返回類型是 void，所以它不會返回任何東西。您需要將三個參數傳遞給swap()方法。檢查下面的註釋。

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

參數：

• list — 列表包含我們交換的元素。
• a —要交換的元素的索引。
• b —要交換的另一個元素的索引。

請注意，如果 a 或 b 超出列表大小的範圍，此方法將拋出 IndexOutOfBoundsException。列表的最大索引比列表的大小小一。任何超過該值的索引值都會導致拋出 IndexOutOfBoundsException。下面顯示瞭如何在 ArrayList 上使用 swap 方法的示例。

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

fruits 的 ArrayList 包含六個元素。我們使用函數 swap()方法交換第 2^個和第 5^個元素。最佳做法是在 try-catch 塊中編寫swap()方法，因為它可以在運行時拋出 IndexOutOfBoundsException。輸出：如果我們將“2”和“8”作為索引傳遞，應用程序將拋出異常，因為列表的大小為 6。

Collections.swap(fruits, 2, 8);

輸出將是：

結論

在本教程中，我們討論了 Java 中使用的幾種交換技術。其中一個使用包裝類，另一個使用Collection.swap()方法。重要的是要記住，在使用函數swap()時應該進行異常處理，因為它會拋出運行時異常。