O método Swap em Java

  1. Troque dois elementos em uma lista Java com o método swap
  2. Troca de dois caracteres em uma string Java
  3. Trocar dois objetos em Java

O método swap() é usado para trocar a posição de dois elementos, caracteres ou objetos em Java. Este método pode ser aplicado a uma lista, string ou objeto. Neste artigo, discutiremos o uso do método swap() em:

  1. Trocando dois elementos em uma lista
  2. Trocando dois caracteres em uma string
  3. Trocando dois objetos

Troque dois elementos em uma lista Java com o método swap

Este é um método usado para trocar dois elementos específicos em posições definidas sem impactar outros elementos em uma lista. Se um dos índices especificados for maior que o tamanho da lista, o método retornará uma exceção out of bound. O swap() dará uma saída da lista com os elementos nos índices trocados.

Sintaxe:

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

Este método leva três parâmetros como seus argumentos - a lista na qual o método swap() será aplicado e os dois índices que serão trocados.

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

Resultado:

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

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

No exemplo acima, trocamos a letra g no índice 6 pela letra a no índice 0. O método swap trocou apenas essas duas letras, sem interferir com quaisquer outros elementos da lista.

Troca de dois caracteres em uma string Java

Uma das principais propriedades do valor da string é que ele é imutável, o que significa que não pode ser alterado. Para realizar a operação de troca, primeiro temos que copiar o objeto String para um StringBuilder ou un array de caracteres. Esses dois tipos de dados nos permitem realizar a operação de troca no objeto copiado. A seguir, realizaremos a operação de troca usando o array char e StringBuilder para criar uma nova string com caracteres trocados.

Executar troca de string usando matriz Char em Java

O método de troca tem três parâmetros - a String em que vamos realizar a troca e os dois índices dos caracteres que trocamos. Para realizar uma troca de caracteres, primeiro criamos um objeto de armazenamento temporário de caracteres - tempo. Este objeto temporário armazena o primeiro caractere conforme o substituímos pelo segundo caractere e, em seguida, o passa para o segundo caractere para completar o processo de troca.

Existem três etapas envolvidas:

  • Converte a String em um objeto de matriz char
  • Obtenha o comprimento do objeto
  • Troca os índices do array char

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

Resultado:

Farouvite
eavouritF
Favourite

Executar troca de string usando StringBuilder em Java

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

Resultado:

Faiorvte
eavoritF
Favorite

Trocar dois objetos em Java

O método swap também pode ser usado para trocar os atributos dos dois objetos. A troca de objetos pode ser realizada em objetos com um atributo e também em objetos com mais de um atributo.

Trocar objeto por um atributo

Suponha que tenhamos uma classe chamada House com alguns atributos como o número de quartos e o número de banheiros. Vamos criar dois objetos de House - house1 e house2. House tem apenas um atributo - valor. Nosso objetivo é trocar os dados em house1 e house2.

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

Resultado:

5, 2

Trocar objeto com mais de um atributo em Java

Usamos uma classe Wrapper para trocar o atributo de dois objetos que possuem vários atributos. Se realizarmos a troca sem a classe de invólucro, a troca de função criará apenas uma cópia das referências do 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;}
}

Resultado:

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

A classe wrapper troca objetos mesmo se a classe do membro não der acesso à classe de usuário. Ao aplicar o método swap() a um objeto, você pode selecionar a abordagem a ser usada com base no número de atributos em um objeto.

Artigo relacionado - Java String

  • Obter caractere em string por índice em Java
  • Substituir Caractere em String no Índice em Java