El método Swap en Java

  1. Intercambia dos elementos en una lista de Java con el método swap
  2. Intercambiar dos caracteres en una cadena de Java
  3. Intercambiar dos objetos en Java

El método swap() se utiliza para intercambiar la posición de dos elementos, caracteres u objetos en Java. Este método se puede aplicar a una lista, una cadena o un objeto. En este artículo, discutiremos el uso del método swap() en:

  1. Intercambio de dos elementos en una lista
  2. Intercambio de dos caracteres en una cadena
  3. Intercambio de dos objetos

Intercambia dos elementos en una lista de Java con el método swap

Este es un método que se utiliza para intercambiar dos elementos específicos en posiciones definidas sin afectar a otros elementos de una lista. Si uno de los índices especificados es mayor que el tamaño de la lista, el método devuelve una excepción out of bound. El swap() dará una salida de la lista con los elementos de los índices intercambiados.

Sintaxis:

public static void swap(List mylist, int m, int n)

Este método toma tres parámetros como argumentos: la lista en la que se aplicará el método swap() y los dos índices que se intercambiarán.

Ejemplo de código:

import java.util.Collections;
import java.util.ArrayList;

public class PerformSwap {
    public static void main(String[] args) {
        ArrayList<String> lettersList = new ArrayList<String>();
        lettersList.add("a");
        lettersList.add("b");
        lettersList.add("c");
        lettersList.add("d");
        lettersList.add("e");
        lettersList.add("f");
        lettersList.add("g");
        System.out.println("Original List: " + lettersList); 
        Collections.swap(lettersList, 0, 6);
        System.out.println("\nSwapped List: " + lettersList); 
    }
}

Producción:

Original List: [a, b, c, d, e, f, g]

Swapped List: [g, b, c, d, e, f, a]

En el ejemplo anterior, hemos intercambiado la letra g del índice 6 por la letra a del índice 0. El método swap solo ha intercambiado estas dos letras sin interferir con ningún otro elemento de la lista.

Intercambiar dos caracteres en una cadena de Java

Una de las principales propiedades del valor de la cadena es que es inmutable, lo que significa que no se puede cambiar. Para realizar la operación de intercambio, primero tenemos que copiar el objeto String a un StringBuilder o un array de caracteres. Estos dos tipos de datos nos permiten realizar una operación de intercambio sobre el objeto copiado. A continuación, realizaremos la operación de intercambio usando char array y StringBuilder para crear una nueva cadena con caracteres intercambiados.

Realizar un intercambio de cadenas con Char Array en Java

El método de intercambio tiene tres parámetros: el String en el que vamos a realizar el intercambio y los dos índices de los caracteres que intercambiamos. Para realizar un intercambio de caracteres, primero creamos un objeto de almacenamiento de caracteres temporal - tempo. Este objeto temporal almacena el primer carácter a medida que lo reemplazamos con el segundo carácter y luego pasa este carácter al segundo carácter para completar el proceso de intercambio.

Hay tres pasos involucrados:

  • Convierte la cadena en un objeto de array de caracteres
  • Obtiene la longitud del objeto
  • Intercambiar los índices del array de caracteres

Ejemplo de código:

public class SwapString {
    static char[] swap(String mystring, int i, int j)
    {
        char ch[] = mystring.toCharArray();
        char tempo = ch[i];
        ch[i] = ch[j];
        ch[j] = tempo;
        return ch;
    }
  
    public static void main(String args[])
    {
        String theS = "Favourite";

        System.out.println(swap(theS, 5, 2));
        System.out.println(swap(theS, 0, theS.length() - 1));
        System.out.println(theS);
    }
}

Producción:

Farouvite
eavouritF
Favourite

Realizar un intercambio de cadenas con StringBuilder en Java

Ejemplo de código:

public class SwapString { 
    static String swap(String mystring, int i, int j) 
    { 
        StringBuilder mysb = new StringBuilder(mystring); 
        mysb.setCharAt(i, mystring.charAt(j)); 
        mysb.setCharAt(j, mystring.charAt(i)); 
        return mysb.toString(); 
    } 
  
    public static void main(String args[]) 
    {
        String theS = "Favorite";
  
        System.out.println(swap(theS, 5, 2)); 
        System.out.println(swap(theS, 0, theS.length() - 1)); 
  
        // Original String 
        System.out.println(theS); 
    } 
}

Producción:

Faiorvte
eavoritF
Favorite

Intercambiar dos objetos en Java

El método swap también se puede utilizar para intercambiar los atributos de los dos objetos. El intercambio de objetos se puede realizar en objetos con un atributo y también en objetos con más de un atributo.

Intercambiar objeto con un atributo

Supongamos que tenemos una clase llamada House con algunos atributos como el número de dormitorios y el número de baños. Creemos dos objetos de House: house1 y house2. Casa tiene un solo atributo: value. Nuestro objetivo es intercambiar los datos en house1 y house1.

Ejemplo de código:

public class SwapObjects{
    public static void swap(House house1, House house2){
        House temp = house1;
        house1 = house2;
        house2 = temp;
    }
   
    public static void main(String[] args) {
        House house1 = new House();
        House house2 = new House();

        house1.value = 5;
        house2.value = 2;

        //swap using objects
        swap(house1, house2);
        System.out.println(house1.value +", " + house2.value);
    }
}
class House {
    public int value;
}

Producción:

5, 2

Intercambiar objeto con más de un atributo en Java

Usamos una clase Wrapper para intercambiar el atributo de dos objetos que tienen múltiples atributos. Si realizamos el intercambio sin la clase contenedora, la función swap solo creará una copia de las referencias del objeto.

public class SwapObjects{
    public static void main(String[] args) {
        House house1 = new House(5, 3);
        House house2 = new House(2, 1);
      
        Wrapper whs1 = new Wrapper(house1);
        Wrapper whs2 = new Wrapper(house2);

        //swap using wrapper of objects
        swap(whs1,whs2);
        whs1.house.print(); 
        whs2.house.print(); 
    }

    public static void swap(Wrapper whs1, Wrapper whs2){
        House temp = whs1.house;
        whs1.house = whs2.house;
        whs2.house = temp;
    }
}
class House 
{ 
    int bedroom, bathroom; 
  
    // Constructor 
    House(int bedroom, int bathroom) 
    { 
        this.bedroom = bedroom; 
        this.bathroom = bathroom; 
    } 
  
    // Utility method to print object details 
    void print() 
    { 
        System.out.println("bedrooms = " + bedroom +  
                        ", bathrooms = " + bathroom); 
    } 
} 
class Wrapper {
    House house;
    Wrapper(House house){ this.house = house;}
}

Producción:

bedrooms = 2, bathrooms = 1
bedrooms = 5, bathrooms = 3

La clase contenedora intercambia objetos incluso si la clase del miembro no da acceso a la clase de usuario. Mientras aplica el método swap() a un objeto, puede seleccionar el enfoque a utilizar en función del número de atributos de un objeto.

Artículo relacionado - Java String

  • Dividir una cadena por espacio en Java
  • Concatenar cadenas en Java