Como trocar objetos em Java?

Trocar objetos é uma das ações mais populares na programação. É particularmente útil na classificação. O que acontece na troca são duas variáveis ​​trocando seus valores. Neste artigo, aprendemos como trocar objetos em Java em dois casos diferentes. Um está trocando objetos independentes e o outro está trocando dois objetos em uma lista ou uma matriz. Vamos primeiro examinar a troca de objetos independentes.

Trocar objetos é diferente de trocar tipos de dados primitivos

Um dos métodos comuns para trocar valores primitivos é usar uma variável temporal. No entanto, você sabe que Java usa “Passar por valor” ao passar parâmetros para um método. Portanto, a troca de objetos não funcionará conforme o esperado com esse método. O exemplo a seguir o 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;
        }
    }
}

A saída: não houve troca! Quando chamamos o método swap e passamos os objetos, passamos uma cópia do objeto, com todos os valores das propriedades. Esta é a razão pela qual é chamado de “Passar por Valor”. O método swap realmente troca os objetos impactando apenas a cópia do objeto original. Assim, os objetos originais são mantidos inalterados. A solução para isso seria usar uma classe wrapper para agrupar os dois objetos.

Trocando objetos com uma classe wrapper

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

Aqui usamos uma classe wrapper que possui uma propriedade do tipo de objeto que precisamos trocar. Usando um método de troca simples, ele troca o conteúdo dos objetos InnerClass dos objetos de classe wrapper. Para qualquer implementação adicional dos objetos InnerClass trocados, podemos usar wrapperObj1.xyz e wrapperObj2.xyz adequadamente. A saída:

O método interno swap() em Java

As classes do Java Collections Framework possuem um método embutido para trocar elementos chamado swap() . O java.util é uma classe utilitária que contém métodos estáticos que podem operar em elementos como Lists da interface Collection. Usar o método swap é muito mais fácil do que o exemplo que discutimos anteriormente. O método swap() é um método estático e, portanto, você o invoca com o nome da classe como Collections.swap() . O tipo de retorno do método swap() é void, portanto não retornará nada. Você precisa passar três argumentos para o método swap() . Confira a nota abaixo.

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

Parâmetros:

• list — a lista contém os elementos que trocamos.
• a — índice de um elemento a ser trocado .
• b — índice de outro elemento a ser trocado .

Observe que esse método lançará um IndexOutOfBoundsException se a ou b estiver fora do intervalo do tamanho da lista. O índice máximo da lista é um a menos que o tamanho da lista. Qualquer valor de índice maior do que isso fará com que o IndexOutOfBoundsException seja lançado. Um exemplo de como usar o método swap em um ArrayList é mostrado abaixo.

método swap () em um 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);
        }
    }
}

O ArrayList de frutas contém seis elementos. Trocamos o 2º ^e 5º ^elementos usando o método swap() da função . A melhor prática é escrever o método swap() dentro de um bloco try-catch, pois ele pode gerar uma IndexOutOfBoundsException em tempo de execução. A saída: Se passarmos '2' e '8' como índices, o aplicativo lançará uma exceção, pois o tamanho da lista é seis.

Collections.swap(fruits, 2, 8);

A saída será:

Conclusão

Neste tutorial, discutimos algumas técnicas de troca usadas em Java. Um deles está usando uma classe wrapper e o outro está usando o método Collection.swap() . É importante lembrar que o tratamento de exceções deve ser feito ao usar a função swap() , pois ela lança uma exceção em tempo de execução.