Creando una función de intercambio

Introducción

En Java, intercambiar tipos de datos primitivos es fácil y se puede hacer con una simple asignación de variables. Sin embargo, intercambiar tipos de datos no primitivos, como objetos, puede ser complejo. Afortunadamente, la clase java.util.Collections incluye un método swap() que facilita el intercambio de elementos en una lista de tipos de datos primitivos y no primitivos. En este laboratorio, aprenderás a crear una función de intercambio utilizando el método Collections.swap().

Skills Graph

Crea un archivo Java

Primero, crea un archivo Java llamado SwapFunction.java en el directorio ~/project.

touch ~/project/SwapFunction.java

Importa la biblioteca java.util

Importa la biblioteca java.util para utilizar la clase Collections en el archivo Java.

import java.util.*;

Declara una función que acepta una lista de cualquier tipo de datos

Declara una función que aceptará una lista de cualquier tipo de datos. Puedes especificar el tipo de datos utilizando la característica de genéricos de Java. Para este ejemplo, construiremos una función llamada swapElements que toma una ArrayList de objetos String y intercambia dos elementos en índices especificados.

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

Implementa una función de intercambio utilizando el método Collections.swap()

En la función swapElements, utiliza el método Collections.swap() para intercambiar los elementos en los índices especificados.

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

Prueba la función de intercambio

Prueba la función swapElements creando una ArrayList de objetos String, agregando algunos elementos y luego intercambiando dos elementos.

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

Guarda el archivo Java, luego compila y ejecútalo.

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

Deberías ver la siguiente salida:

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

Intercambia múltiples elementos en una lista

La función swapElements también se puede utilizar para intercambiar múltiples elementos en una lista llamando al método Collections.swap() varias veces.

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

Guarda el archivo Java, luego compila y ejecútalo.

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

Deberías ver la siguiente salida:

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

Manejar excepciones

Si los índices especificados están fuera de los límites de la lista, la función swapElements lanzará una excepción IndexOutOfBoundsException. Para manejar esto, agrega un bloque try-catch a la función.

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

Guarda el archivo Java, luego compila y ejecútalo.

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

Deberías ver la siguiente salida:

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

Intercambia elementos en una matriz

También puedes utilizar la función swapElements para intercambiar elementos en una matriz convirtiendo la matriz en una lista.

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

Guarda el archivo Java, luego compila y ejecútalo.

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

Deberías ver la siguiente salida:

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

Intercambia elementos en una lista de objetos personalizados

La función swapElements también se puede utilizar para intercambiar elementos en una lista de objetos personalizados. Define una clase Person con los campos name y age, luego crea una lista de objetos Person y intercambia dos elementos en la lista.

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

Guarda el archivo Java, luego compila y ejecútalo.

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

Deberías ver la siguiente salida:

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

Resumen

En este laboratorio, aprendiste cómo crear una función swap() en Java utilizando el método Collections.swap(). Aprendiste cómo crear una función que acepta una lista de cualquier tipo de datos, cómo utilizar el método Collections.swap() para intercambiar dos elementos en índices especificados y cómo manejar excepciones. También aprendiste cómo intercambiar elementos en una matriz y en una lista de objetos personalizados.