Einführung
In Java ist das Austauschen primitiver Datentypen einfach und kann mit einer einfachen Variablenzuweisung durchgeführt werden. Das Austauschen nicht-primitiver Datentypen wie Objekte kann jedoch komplex sein. Glücklicherweise enthält die Klasse java.util.Collections eine Methode swap(), mit der es einfach ist, Elemente in einer Liste von primitiven und nicht-primitiven Datentypen auszutauschen. In diesem Lab werden Sie lernen, wie Sie eine Austauschfunktion mit der Methode Collections.swap() erstellen.
Erstellen einer Java-Datei
Erstellen Sie zunächst eine Java-Datei mit dem Namen SwapFunction.java im Verzeichnis ~/project.
touch ~/project/SwapFunction.java
Importiere die java.util Bibliothek
Importieren Sie die java.util-Bibliothek, um die Collections-Klasse in der Java-Datei zu verwenden.
import java.util.*;
Deklariere eine Funktion, die eine Liste beliebigen Datentyps akzeptiert
Deklarieren Sie eine Funktion, die eine Liste beliebigen Datentyps akzeptieren wird. Sie können den Datentyp mithilfe der Generics-Funktion von Java angeben. Für dieses Beispiel werden wir eine Funktion namens swapElements erstellen, die eine ArrayList von String-Objekten annimmt und zwei Elemente an den angegebenen Indizes tauscht.
public class SwapFunction {
public static <T> void swapElements(ArrayList<T> list, int index1, int index2){
// swap code goes here
}
}
Implementiere eine Swap-Funktion mit der Collections.swap()-Methode
In der swapElements-Funktion verwenden Sie die Collections.swap()-Methode, um die Elemente an den angegebenen Indizes zu tauschen.
public class SwapFunction {
public static <T> void swapElements(ArrayList<T> list, int index1, int index2){
Collections.swap(list, index1, index2);
}
}
Teste die Swap-Funktion
Testen Sie die swapElements-Funktion, indem Sie eine ArrayList von String-Objekten erstellen, einige Elemente hinzufügen und dann zwei Elemente tauschen.
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);
}
}
Speichern Sie die Java-Datei, kompilieren Sie sie und führen Sie sie aus.
javac ~/project/SwapFunction.java && java SwapFunction
Sie sollten die folgende Ausgabe sehen:
Before Swap: [apple, banana, orange, kiwi]
After Swap: [orange, banana, apple, kiwi]
Tausche mehrere Elemente in einer Liste
Die swapElements-Funktion kann auch verwendet werden, um mehrere Elemente in einer Liste zu tauschen, indem die Collections.swap()-Methode mehrmals aufgerufen wird.
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);
}
}
Speichern Sie die Java-Datei, kompilieren Sie sie und führen Sie sie aus.
javac ~/project/SwapFunction.java && java SwapFunction
Sie sollten die folgende Ausgabe sehen:
Before Swap: [apple, banana, orange, kiwi]
After Swap: [kiwi, orange, banana, apple]
Behandle Ausnahmen
Wenn die angegebenen Indizes außerhalb der Grenzen der Liste liegen, wird die swapElements-Funktion eine IndexOutOfBoundsException-Ausnahme werfen. Um dies zu behandeln, fügen Sie einen try-catch-Block zur Funktion hinzu.
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);
}
}
Speichern Sie die Java-Datei, kompilieren Sie sie und führen Sie sie aus.
javac ~/project/SwapFunction.java && java SwapFunction
Sie sollten die folgende Ausgabe sehen:
Before Swap: [apple, banana, orange, kiwi]
Error: Index 4 out of bounds for length 4
After Swap: [apple, orange, banana, kiwi]
Tausche Elemente in einem Array
Sie können auch die swapElements-Funktion verwenden, um Elemente in einem Array zu tauschen, indem Sie das Array in eine Liste umwandeln.
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);
}
}
Speichern Sie die Java-Datei, kompilieren Sie sie und führen Sie sie aus.
javac ~/project/SwapFunction.java && java SwapFunction
Sie sollten die folgende Ausgabe sehen:
Before Swap: [apple, banana, orange, kiwi]
After Swap: [kiwi, orange, banana, apple]
Tausche Elemente in einer Liste benutzerdefinierter Objekte
Die swapElements-Funktion kann auch verwendet werden, um Elemente in einer Liste benutzerdefinierter Objekte zu tauschen. Definieren Sie eine Person-Klasse mit name- und age-Feldern, erstellen Sie dann eine Liste von Person-Objekten und tauschen Sie zwei Elemente in der Liste.
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);
}
}
Speichern Sie die Java-Datei, kompilieren Sie sie und führen Sie sie aus.
javac ~/project/SwapFunction.java && java SwapFunction
Sie sollten die folgende Ausgabe sehen:
Before Swap: [Alice (25), Bob (30), Charlie (35), David (40)]
After Swap: [David (40), Charlie (35), Bob (30), Alice (25)]
Zusammenfassung
In diesem Lab haben Sie gelernt, wie Sie eine Java-swap()-Funktion mit der Collections.swap()-Methode erstellen. Sie haben gelernt, wie Sie eine Funktion erstellen, die eine Liste beliebigen Datentyps akzeptiert, wie Sie die Collections.swap()-Methode verwenden, um zwei Elemente an bestimmten Indizes zu tauschen, und wie Sie Ausnahmen behandeln. Sie haben auch gelernt, wie Sie Elemente in einem Array und in einer Liste benutzerdefinierter Objekte tauschen.
