如何在 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()时应该进行异常处理，因为它会抛出运行时异常。