¿Cómo intercambiar o intercambiar objetos en Java?

Para comprender cómo intercambiar objetos en Java, consideremos una ilustración a continuación :

Ilustración: 

Digamos que tenemos una clase llamada “Auto” con algunos atributos. Y creamos dos objetos de Car, digamos car1 y car2, ¿cómo intercambiar los datos de car1 y car2?

Métodos: 

1. Usando conceptos de OOPS
2. Uso de las clases Wrapper de Java

Método 1: Usando conceptos de OOPS 

Aquí simplemente intercambiaremos miembros para lo cual tomaremos directamente una ilustración de muestra de ‘Auto’ con la que jugaremos. Entonces, si la clase ‘Car’ tiene solo un atributo entero, digamos «no» (número de auto), podemos intercambiar autos simplemente intercambiando los miembros de dos autos.

Ejemplo 1-A

// Java program to demonstrate that we can swap two
// objects be swapping members
 
// Class 1
// Number class Car
class Car {
    // Attributes associated with car
    int no;
    Car(int no) { this.no = no; }
}
 
// Class 2
// Uses Car objects
class GFG {
    // Method 1
    // To swap
    public static void swap(Car c1, Car c2)
    {
        int temp = c1.no;
        c1.no = c2.no;
        c2.no = temp;
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
        // Creating car class objects(creating cars)
        Car c1 = new Car(1);
        Car c2 = new Car(2);
 
        // Calling method 1
        swap(c1, c2);
 
        // Print and display commands
        System.out.println("c1.no = " + c1.no);
        System.out.println("c2.no = " + c2.no);
    }
}

c1.no = 2
c2.no = 1

Nota: Geek, ¿y si no conocemos a los miembros de Car? 

La solución anterior funcionó porque sabíamos que hay un miembro «no» en Car. ¿Qué sucede si no conocemos a los miembros de Car o si la lista de miembros es demasiado grande? Esta es una situación muy común ya que una clase que usa alguna otra clase no puede acceder a los miembros de otra clase . ¿Funciona la siguiente solución? 
 

Ejemplo 1-B

// Java program to demonstrate that we can swap two
// objects be swapping members
// Where it does not work
 
// Class 1
// A car with number and name
class Car {
      
    // Attributes of Car class
    int model, no;
 
    // Constructor
    Car(int model, int no)
    {
      // This keyword is used to refer
      // current instance itself
        this.model = model;
        this.no = no;
    }
 
    // Method of this class
    // To print Car
    void print()
    {
       // Printing number and model of car
        System.out.println("no = " + no +
                           ", model = " + model);
    }
}
 
// Class 2
// A class that uses Car
class Main
{
    // swap() doesn't swap c1 and c2
    public static void swap(Car c1, Car c2)
    {
        Car temp = c1;
        c1 = c2;
        c2 = temp;
    }
 
    // Driver method
    public static void main(String[] args)
    {
        Car c1 = new Car(101, 1);
        Car c2 = new Car(202, 2);
        swap(c1, c2);
        c1.print();
        c2.print();
    }
}

no = 1, model = 101
no = 2, model = 202

Explicación de la salida:   como podemos ver en la salida anterior, los objetos no se intercambian. Hemos discutido en una publicación anterior que los parámetros se pasan por valor en Java. Entonces, cuando pasamos c1 y c2 a swap(), la función swap() crea una copia de estas referencias.

Método 2: clase contenedora 

Si creamos una clase contenedora que contiene referencias de Car, podemos intercambiar autos intercambiando referencias de la clase contenedora.

Ejemplo 

// Java program to Demonstrate that Wrapper Classes
// Can be Used to Swap two Objects
 
// Class 1
// A car with model and no.
class Car {
    // Attributes associated with car
    int model, no;
 
    // Constructor of class 1
    Car(int model, int no)
    {
        // This refers to current instance itself
        this.model = model;
        this.no = no;
    }
 
    // Method
    // To print object details
    void print()
    {
        System.out.println("no = " + no
                           + ", model = " + model);
    }
}
 
// Class 2
// Wrapper over class that is used for swapping
class CarWrapper {
    Car c;
 
    // Constructor
    CarWrapper(Car c) { this.c = c; }
}
 
// Class 3
// Uses Car class and swaps objects of Car
// using CarWrapper
class GFG {
    // This method swaps car objects in wrappers
    // cw1 and cw2
    public static void swap(CarWrapper cw1, CarWrapper cw2)
    {
        Car temp = cw1.c;
        cw1.c = cw2.c;
        cw2.c = temp;
    }
 
    // Main driver method
    public static void main(String[] args)
    {
        Car c1 = new Car(101, 1);
        Car c2 = new Car(202, 2);
        CarWrapper cw1 = new CarWrapper(c1);
        CarWrapper cw2 = new CarWrapper(c2);
        swap(cw1, cw2);
        cw1.c.print();
        cw2.c.print();
    }
}

Producción: 

no = 2, model = 202
no = 1, model = 101

Entonces, una solución de clase contenedora funciona incluso si la clase de usuario no tiene acceso a los miembros de la clase cuyos objetos se van a intercambiar.
Este artículo es una contribución de Anurag Rai . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo y enviarlo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.