Création d'une fonction de permutation

Introduction

En Java, échanger des types de données primitifs est facile et peut être fait avec une simple affectation de variables. Cependant, échanger des types de données non primitifs, comme des objets, peut être complexe. Heureusement, la classe java.util.Collections inclut une méthode swap() qui facilite l'échange d'éléments dans une liste de types de données primitifs et non primitifs. Dans ce laboratoire, vous allez apprendre à créer une fonction d'échange en utilisant la méthode Collections.swap().

Skills Graph

Créez un fichier Java

Tout d'abord, créez un fichier Java nommé SwapFunction.java dans le répertoire ~/project.

touch ~/project/SwapFunction.java

Importez la bibliothèque java.util

Importez la bibliothèque java.util pour utiliser la classe Collections dans le fichier Java.

import java.util.*;

Déclarez une fonction qui accepte une liste de n'importe quel type de données

Déclarez une fonction qui acceptera une liste de n'importe quel type de données. Vous pouvez spécifier le type de données à l'aide de la fonction de généricité de Java. Pour cet exemple, nous allons construire une fonction nommée swapElements qui prend une ArrayList d'objets String et échange deux éléments à des index spécifiés.

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

Implémentez une fonction d'échange en utilisant la méthode Collections.swap()

Dans la fonction swapElements, utilisez la méthode Collections.swap() pour échanger les éléments aux indices spécifiés.

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

Testez la fonction d'échange

Testez la fonction swapElements en créant une ArrayList d'objets String, en ajoutant quelques éléments puis en échangeant deux éléments.

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

Enregistrez le fichier Java, puis compilez et exécutez-le.

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

Vous devriez voir la sortie suivante :

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

Échanger plusieurs éléments dans une liste

La fonction swapElements peut également être utilisée pour échanger plusieurs éléments dans une liste en appelant la méthode Collections.swap() plusieurs fois.

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

Enregistrez le fichier Java, puis compilez et exécutez-le.

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

Vous devriez voir la sortie suivante :

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

Gérer les exceptions

Si les indices spécifiés sont en dehors des limites de la liste, la fonction swapElements lancera une exception IndexOutOfBoundsException. Pour gérer cela, ajoutez un bloc try-catch à la fonction.

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); // indice en dehors des limites
        swapElements(list, 1, 2);
        System.out.println("After Swap: " + list);
    }
}

Enregistrez le fichier Java, puis compilez et exécutez-le.

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

Vous devriez voir la sortie suivante :

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

Échanger des éléments dans un tableau

Vous pouvez également utiliser la fonction swapElements pour échanger des éléments dans un tableau en convertissant le tableau en une liste.

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

Enregistrez le fichier Java, puis compilez et exécutez-le.

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

Vous devriez voir la sortie suivante :

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

Échanger des éléments dans une liste d'objets personnalisés

La fonction swapElements peut également être utilisée pour échanger des éléments dans une liste d'objets personnalisés. Définissez une classe Personne avec les champs nom et âge, puis créez une liste d'objets Personne et échangez deux éléments dans la 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);
    }
}

Enregistrez le fichier Java, puis compilez et exécutez-le.

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

Vous devriez voir la sortie suivante :

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

Récapitulatif

Dans ce laboratoire, vous avez appris à créer une fonction swap() en Java en utilisant la méthode Collections.swap(). Vous avez appris à créer une fonction qui accepte une liste de tout type de données, à utiliser la méthode Collections.swap() pour échanger deux éléments à des index spécifiés et à gérer les exceptions. Vous avez également appris à échanger des éléments dans un tableau et dans une liste d'objets personnalisés.