¿Cómo intercambiar objetos en Java?

El intercambio de objetos es una de las acciones más populares en la programación. Es particularmente útil en la clasificación. Lo que sucede en el intercambio es que dos variables intercambian sus valores. En este artículo, aprendemos cómo intercambiar objetos en Java en dos casos diferentes. Uno está intercambiando objetos independientes y el otro está intercambiando dos objetos en una Lista o una Matriz. Primero examinemos el intercambio de objetos independientes.

Intercambiar objetos es diferente de intercambiar tipos de datos primitivos

Uno de los métodos comunes para intercambiar valores primitivos es usar una variable temporal. Sin embargo, sabe que Java usa "Pasar por valor" cuando pasa parámetros a un método. Por lo tanto, el intercambio de objetos no funcionará como esperaba con este método. El siguiente ejemplo lo mostrará.

public class ObjectSwapper {
    public static void main(String[] args) {
        InnerClass obj1 = new InnerClass(12345);
        InnerClass obj2 = new InnerClass(11111);
        swap(obj1, obj2);
        System.out.println("Obj1 ID value : " + obj1.id + "\n" + "Obj2 ID value :  " + obj2.id);
    }
    static void swap(InnerClass x, InnerClass y) {
        InnerClass temp;
        temp = x;
        x = y;
        y = temp;
    }
    static class InnerClass {
        public int id;
        public InnerClass(int Id) {
            this.id = Id;
        }
    }
}

El resultado: ¡ No hubo intercambio! Cuando llamamos al método de intercambio y pasamos los objetos, pasamos una copia del objeto, con todos los valores de propiedad. Esta es la razón por la que se llama “Pase por valor”. El método de intercambio en realidad intercambia los objetos que afectan solo a la copia del objeto original. Así que los objetos originales se mantienen sin cambios. La solución a esto sería usar una clase contenedora para envolver los dos objetos.

Intercambio de objetos con una clase contenedora

public class ObjectSwapper {
    public static void main(String[] args) {
 
        InnerClass obj1 = new InnerClass(12345);
        InnerClass obj2 = new InnerClass(11111);
        objectWrapper wrapperObj1 = new objectWrapper(obj1);
        objectWrapper wrapperObj2 = new objectWrapper(obj2);
        // Values before swapping
        System.out.println("WrapperObj1 InncerClass ID value : " + wrapperObj1.innerObject.id + "\n" + "WrapperObj2 InncerClass ID value : "
                + wrapperObj2.innerObject.id + "\n");
        
        swap(wrapperObj1, wrapperObj2);
        
        // Values after swapping
        System.out.println("WrapperObj1 InncerClass ID value : " + wrapperObj1.innerObject.id + "\n" + "WrapperObj2 InncerClass ID value : "
                + wrapperObj2.innerObject.id);
    }
 
       static void swap(objectWrapper wrapperObj1, objectWrapper wrapperObj2) {
        InnerClass temp;
        temp = wrapperObj1.innerObject;
        wrapperObj1.innerObject = wrapperObj2.innerObject;
        wrapperObj2.innerObject = temp;
    }
 
    static class InnerClass {
        public int id;
        public InnerClass(int Id) {
            id = Id;
        }
    }
 
    static class objectWrapper {
        InnerClass innerObject;
        public objectWrapper(InnerClass objInnner) {
            this.innerObject = objInnner;
        }
    }
}

Aquí usamos una clase contenedora que tiene una propiedad del tipo de objetos que necesitamos intercambiar. Mediante el uso de un método de intercambio simple, intercambia el contenido de los objetos InnerClass de los objetos de la clase contenedora. Para cualquier otra implementación de los objetos InnerClass intercambiados, podemos usar wrapperObj1.xyz y wrapperObj2.xyz en consecuencia. La salida:

El método swap() incorporado en Java

Las clases de Java Collections Framework tienen un método incorporado para intercambiar elementos llamado swap() . java.util es una clase de utilidad que contiene métodos estáticos que pueden operar en elementos como listas de la interfaz de colección . Usar el método de intercambio es mucho más fácil que el ejemplo que discutimos anteriormente. El método swap() es un método estático y, por lo tanto, lo invoca con el nombre de clase como Collections.swap() . El tipo de devolución del método swap() es nulo, por lo que no devolverá nada. Debe pasar tres argumentos al método swap() . Revisa la nota a continuación.

swap(List<?> list, int a, int b)

Parámetros:

• lista: la lista contiene los elementos que intercambiamos.
• a: índice de un elemento que se va a intercambiar .
• b — índice de otro elemento a intercambiar .

Tenga en cuenta que este método generará una excepción IndexOutOfBoundsException si a o b están fuera del rango del tamaño de la lista. El índice máximo de la lista es uno menos que el tamaño de la lista. Cualquier valor de índice superior a ese hará que se produzca la excepción IndexOutOfBoundsException. A continuación se muestra un ejemplo de cómo utilizar el método de intercambio en una ArrayList.

método swap() en una ArrayList

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ArrayListSwapper {
    public static void main(String[] args) {
        try {
            List fruits = new ArrayList();
            fruits.add("Mango");
            fruits.add("Papaya");
            fruits.add("Apple");
            fruits.add("Orange");
            fruits.add("Watermelon");
            fruits.add("Bael");
            System.out.println("Before swapping : " + fruits);
         //using Collection.swap() method
            Collections.swap(fruits, 2, 5);
            System.out.println("After swapping : " + fruits);
        } catch (IndexOutOfBoundsException e) {
            System.out.println("Index Out of Bound Exception thrown : " + e);
        }
    }
}

La ArrayList de frutas contiene seis elementos. Intercambiamos los elementos 2 ^y 5 ^usando el método de función swap() . La mejor práctica es escribir el método swap() dentro de un bloque try-catch, ya que puede generar una excepción IndexOutOfBoundsException en tiempo de ejecución. El resultado: si pasamos '2' y '8' como índices, la aplicación generará una excepción ya que el tamaño de la lista es seis.

Collections.swap(fruits, 2, 8);

La salida será:

Conclusión

En este tutorial, discutimos un par de técnicas de intercambio utilizadas en Java. Uno de ellos usa una clase contenedora y el otro usa el método Collection.swap() . Es importante recordar que el manejo de excepciones debe realizarse cuando se usa la función swap() ya que genera una excepción en tiempo de ejecución.