创建交换函数

介绍

在 Java 中，交换基本数据类型（primitive data types）非常简单，可以通过简单的变量赋值来实现。然而，交换非基本数据类型（如对象）可能会比较复杂。幸运的是，java.util.Collections 类提供了一个 swap() 方法，可以轻松地交换列表中基本和非基本数据类型的元素。在本实验中，你将学习如何使用 Collections.swap() 方法创建一个交换函数。

创建一个 Java 文件

首先，在 ~/project 目录下创建一个名为 SwapFunction.java 的 Java 文件。

touch ~/project/SwapFunction.java

导入 java.util 库

导入 java.util 库以在 Java 文件中使用 Collections 类。

import java.util.*;

声明一个接受任意数据类型列表的函数

声明一个可以接受任意数据类型列表的函数。你可以使用 Java 的泛型（Generics）特性来指定数据类型。在这个示例中，我们将构建一个名为 swapElements 的函数，它接受一个 String 对象的 ArrayList，并交换指定索引处的两个元素。

public class SwapFunction {
    public static <T> void swapElements(ArrayList<T> list, int index1, int index2){
        // swap code goes here
    }
}

使用 Collections.swap() 方法实现交换函数

在 swapElements 函数中，使用 Collections.swap() 方法来交换指定索引处的元素。

public class SwapFunction {
    public static <T> void swapElements(ArrayList<T> list, int index1, int index2){
        Collections.swap(list, index1, index2);
    }
}

测试交换函数

通过创建一个 String 对象的 ArrayList，添加一些元素，然后交换两个元素来测试 swapElements 函数。

public class SwapFunction {
    public static <T> void swapElements(ArrayList<T> list, int index1, int index2){
        Collections.swap(list, index1, index2);
    }

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>(Arrays.asList("apple", "banana", "orange", "kiwi"));
        System.out.println("Before Swap: " + list);
        swapElements(list, 0, 2);
        System.out.println("After Swap: " + list);
    }
}

保存 Java 文件，然后编译并运行它。

javac ~/project/SwapFunction.java && java SwapFunction

你应该会看到以下输出：

Before Swap: [apple, banana, orange, kiwi]
After Swap: [orange, banana, apple, kiwi]

交换列表中的多个元素

通过多次调用 Collections.swap() 方法，swapElements 函数也可以用于交换列表中的多个元素。

public class SwapFunction {
    public static <T> void swapElements(ArrayList<T> list, int index1, int index2){
        Collections.swap(list, index1, index2);
    }

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>(Arrays.asList("apple", "banana", "orange", "kiwi"));
        System.out.println("Before Swap: " + list);
        swapElements(list, 0, 3);
        swapElements(list, 1, 2);
        System.out.println("After Swap: " + list);
    }
}

保存 Java 文件，然后编译并运行它。

javac ~/project/SwapFunction.java && java SwapFunction

你应该会看到以下输出：

Before Swap: [apple, banana, orange, kiwi]
After Swap: [kiwi, orange, banana, apple]

处理异常

如果指定的索引超出了列表的范围，swapElements 函数将抛出 IndexOutOfBoundsException 异常。为了处理这种情况，可以在函数中添加一个 try-catch 块。

public class SwapFunction {
    public static <T> void swapElements(ArrayList<T> list, int index1, int index2){
        try {
            Collections.swap(list, index1, index2);
        } catch (IndexOutOfBoundsException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>(Arrays.asList("apple", "banana", "orange", "kiwi"));
        System.out.println("Before Swap: " + list);
        swapElements(list, 0, 4); // out of bounds index
        swapElements(list, 1, 2);
        System.out.println("After Swap: " + list);
    }
}

保存 Java 文件，然后编译并运行它。

javac ~/project/SwapFunction.java && java SwapFunction

你应该会看到以下输出：

Before Swap: [apple, banana, orange, kiwi]
Error: Index 4 out of bounds for length 4
After Swap: [apple, orange, banana, kiwi]

交换数组中的元素

你也可以通过将数组转换为列表，使用 swapElements 函数来交换数组中的元素。

public class SwapFunction {
    public static <T> void swapElements(ArrayList<T> list, int index1, int index2){
        try {
            Collections.swap(list, index1, index2);
        } catch (IndexOutOfBoundsException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        String[] array = {"apple", "banana", "orange", "kiwi"};
        ArrayList<String> list = new ArrayList<>(Arrays.asList(array));
        System.out.println("Before Swap: " + list);
        swapElements(list, 0, 3);
        swapElements(list, 1, 2);
        System.out.println("After Swap: " + list);
    }
}

保存 Java 文件，然后编译并运行它。

javac ~/project/SwapFunction.java && java SwapFunction

你应该会看到以下输出：

Before Swap: [apple, banana, orange, kiwi]
After Swap: [kiwi, orange, banana, apple]

交换自定义对象列表中的元素

swapElements 函数也可以用于交换自定义对象列表中的元素。定义一个包含 name 和 age 字段的 Person 类，然后创建一个 Person 对象列表，并交换列表中的两个元素。

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String toString() {
        return name + " (" + age + ")";
    }
}

public class SwapFunction {
    public static <T> void swapElements(ArrayList<T> list, int index1, int index2){
        try {
            Collections.swap(list, index1, index2);
        } catch (IndexOutOfBoundsException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("Alice", 25));
        list.add(new Person("Bob", 30));
        list.add(new Person("Charlie", 35));
        list.add(new Person("David", 40));

        System.out.println("Before Swap: " + list);
        swapElements(list, 0, 3);
        swapElements(list, 1, 2);
        System.out.println("After Swap: " + list);
    }
}

保存 Java 文件，然后编译并运行它。

javac ~/project/SwapFunction.java && java SwapFunction

你应该会看到以下输出：

Before Swap: [Alice (25), Bob (30), Charlie (35), David (40)]
After Swap: [David (40), Charlie (35), Bob (30), Alice (25)]

总结

在本实验中，你学习了如何使用 Collections.swap() 方法创建一个 Java swap() 函数。你学习了如何创建一个接受任意数据类型列表的函数，如何使用 Collections.swap() 方法交换指定索引处的两个元素，以及如何处理异常。你还学习了如何交换数组中的元素以及自定义对象列表中的元素。