创建交换函数

JavaJavaBeginner
立即练习

💡 本教程由 AI 辅助翻译自英文原版。如需查看原文,您可以 切换至英文原版

介绍

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


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("`Java`")) -.-> java/DataStructuresGroup(["`Data Structures`"]) java(("`Java`")) -.-> java/ObjectOrientedandAdvancedConceptsGroup(["`Object-Oriented and Advanced Concepts`"]) java(("`Java`")) -.-> java/FileandIOManagementGroup(["`File and I/O Management`"]) java/DataStructuresGroup -.-> java/arrays_methods("`Arrays Methods`") java/DataStructuresGroup -.-> java/collections_methods("`Collections Methods`") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/classes_objects("`Classes/Objects`") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/packages_api("`Packages / API`") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/exceptions("`Exceptions`") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/arraylist("`ArrayList`") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/generics("`Generics`") java/FileandIOManagementGroup -.-> java/files("`Files`") java/FileandIOManagementGroup -.-> java/create_write_files("`Create/Write Files`") subgraph Lab Skills java/arrays_methods -.-> lab-117432{{"`创建交换函数`"}} java/collections_methods -.-> lab-117432{{"`创建交换函数`"}} java/classes_objects -.-> lab-117432{{"`创建交换函数`"}} java/packages_api -.-> lab-117432{{"`创建交换函数`"}} java/exceptions -.-> lab-117432{{"`创建交换函数`"}} java/arraylist -.-> lab-117432{{"`创建交换函数`"}} java/generics -.-> lab-117432{{"`创建交换函数`"}} java/files -.-> lab-117432{{"`创建交换函数`"}} java/create_write_files -.-> lab-117432{{"`创建交换函数`"}} end

创建 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 函数也可以用于交换自定义对象列表中的元素。定义一个包含 nameage 字段的 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() 方法交换指定索引处的两个元素,以及如何处理异常。你还学习了如何交换数组中的元素以及自定义对象列表中的元素。

您可能感兴趣的其他 Java 教程