Comment échanger des objets en Java ?

L'échange d'objets est l'une des actions les plus populaires en programmation. C'est particulièrement utile pour le tri. Ce qui se passe dans l'échange, c'est que deux variables échangent leurs valeurs. Dans cet article, nous apprenons à échanger des objets en Java dans deux cas différents. L'un échange des objets indépendants et l'autre échange deux objets dans une liste ou un tableau. Examinons d'abord l'échange d'objets indépendants.

L'échange d'objets est différent de l'échange de types de données primitifs

L'une des méthodes courantes à utiliser pour échanger des valeurs primitives consiste à utiliser une variable temporelle. Cependant, vous savez que Java utilise "Passer par valeur" lors de la transmission de paramètres à une méthode. Par conséquent, l'échange d'objets ne fonctionnera pas comme prévu avec cette méthode. L'exemple suivant le montrera.

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

Le résultat : il n'y a pas eu d'échange ! Lorsque nous appelons la méthode swap et passons les objets, nous passons une copie de l'objet, avec toutes les valeurs de propriété. C'est la raison pour laquelle on l'appelle « Pass by Value ». La méthode swap permute en fait les objets impactant uniquement la copie de l'objet d'origine. Ainsi, les objets d'origine sont conservés inchangés. La solution à cela serait d'utiliser une classe wrapper pour envelopper les deux objets.

Échange d'objets avec une 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;
        }
    }
}

Ici, nous avons utilisé une classe wrapper qui a une propriété du type d'objets que nous devons échanger. En utilisant une simple méthode d'échange, il échange le contenu des objets InnerClass des objets de la classe wrapper. Pour toute autre implémentation des objets InnerClass échangés, nous pouvons utiliser wrapperObj1.xyz et wrapperObj2.xyz en conséquence. Le résultat:

La méthode swap() intégrée en Java

Les classes de Java Collections Framework ont ​​une méthode intégrée pour échanger des éléments appelée swap() . Le java.util est une classe utilitaire qui contient des méthodes statiques pouvant fonctionner sur des éléments tels que les listes de l'interface Collection. L'utilisation de la méthode d'échange est beaucoup plus facile que l'exemple dont nous avons parlé précédemment. La méthode swap() est une méthode statique et vous l'invoquez donc avec le nom de classe comme Collections.swap() . Le type de retour de la méthode swap() est void donc elle ne retournera rien. Vous devez passer trois arguments à la méthode swap() . Vérifiez la note ci-dessous.

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

Paramètres:

• list — la liste contient les éléments que nous échangeons.
• a — index d'un élément à permuter .
• b — index d'un autre élément à permuter .

Notez que cette méthode lèvera une IndexOutOfBoundsException si a ou b est hors de la plage de la taille de la liste. L'index maximum de la liste est un de moins que la taille de la liste. Toute valeur d'index supérieure à celle-ci entraînera la levée de l'exception IndexOutOfBoundsException. Un exemple d'utilisation de la méthode swap sur une ArrayList est présenté ci-dessous.

méthode swap() sur une 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 fruits contient six éléments. Nous échangeons les 2 ^ème et 5 ^ème éléments en utilisant la méthode function swap() . La meilleure pratique consiste à écrire la méthode swap() dans un bloc try-catch car elle peut lever une exception IndexOutOfBoundsException au moment de l'exécution. La sortie : si nous transmettons '2' et '8' comme index, l'application lèvera une exception car la taille de la liste est de six.

Collections.swap(fruits, 2, 8);

La sortie sera :

Conclusion

Dans ce tutoriel, nous avons discuté de quelques techniques d'échange utilisées en Java. L'un d'eux utilise une classe wrapper et l'autre utilise la méthode Collection.swap() . Il est important de se rappeler que la gestion des exceptions doit être effectuée lors de l'utilisation de la fonction swap() car elle lève une exception d'exécution.