Hoe objecten in Java te wisselen?

Het verwisselen van objecten is een van de meest populaire acties bij het programmeren. Het is vooral handig bij het sorteren. Wat er gebeurt bij het ruilen, is dat twee variabelen hun waarden uitwisselen. In dit artikel leren we hoe we objecten in Java kunnen verwisselen in twee verschillende gevallen. De ene verwisselt onafhankelijke objecten en de andere verwisselt twee objecten in een lijst of een array. Laten we eerst eens kijken naar het verwisselen van onafhankelijke objecten.

Het verwisselen van objecten verschilt van het verwisselen van primitieve gegevenstypen

Een van de gebruikelijke methoden om primitieve waarden te verwisselen, is het gebruik van een tijdelijke variabele. U weet echter dat Java "Pass by Value" gebruikt bij het doorgeven van parameters aan een methode. Daarom werkt het verwisselen van objecten met deze methode niet zoals u had verwacht. Het volgende voorbeeld zal het laten zien.

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

De output: er was geen ruil! Wanneer we de swap-methode aanroepen en de objecten doorgeven, geven we een kopie van het object door, met alle eigenschapswaarden. Dit is de reden waarom het "Pass by Value" wordt genoemd. De swap-methode verwisselt eigenlijk de objecten die alleen van invloed zijn op de kopie van het originele object. Dus de originele objecten blijven ongewijzigd. De oplossing hiervoor zou zijn om een ​​wrapper-klasse te gebruiken om de twee objecten in te pakken.

Objecten verwisselen met een wrapper-klasse

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

Hier hebben we een wrapper-klasse gebruikt die een eigenschap heeft van het type objecten dat we moeten verwisselen. Door een eenvoudige swap-methode te gebruiken, verwisselt het de inhoud van de InnerClass-objecten van de wrapper-klasse-objecten. Voor elke verdere implementatie van de verwisselde InnerClass-objecten kunnen we wrapperObj1.xyz en wrapperObj2.xyz dienovereenkomstig gebruiken. Het resultaat:

De ingebouwde methode swap() in Java

De klassen van het Java Collections Framework hebben een ingebouwde methode om elementen te wisselen , genaamd swap() . De java.util is een hulpprogrammaklasse die statische methoden bevat die kunnen werken op elementen zoals Lists van de Collection-interface. Het gebruik van de swap-methode is veel eenvoudiger dan het voorbeeld dat we eerder hebben besproken. De methode swap() is een statische methode en daarom roept u deze aan met de klassenaam Collections.swap() . Het retourtype van de methode swap() is ongeldig, dus er wordt niets geretourneerd. U moet drie argumenten doorgeven aan de methode swap() . Controleer de opmerking hieronder.

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

Parameters:

• lijst — lijst bevat de elementen die we verwisselen.
• a — index van een te verwisselen element .
• b — index van een ander te verwisselen element .

Merk op dat deze methode een IndexOutOfBoundsException genereert als a of b buiten het bereik van de lijstgrootte valt. De maximale index van de lijst is één minder dan de grootte van de lijst. Elke hogere indexwaarde zorgt ervoor dat de IndexOutOfBoundsException wordt gegenereerd. Hieronder ziet u een voorbeeld van het gebruik van de swap-methode op een ArrayList.

swap() op een 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);
        }
    }
}

De ArrayList van fruit bevat zes elementen. We verwisselen het 2e ^en 5e ^element met behulp van de functie swap() methode. Het is het beste om de methode swap() binnen een try-catch-blok te schrijven, omdat deze tijdens runtime een IndexOutOfBoundsException kan genereren. De uitvoer: als we '2' en '8' als indexen doorgeven, genereert de toepassing een uitzondering omdat de lijst zes is.

Collections.swap(fruits, 2, 8);

De uitvoer zal zijn:

Conclusie

In deze zelfstudie hebben we een aantal ruiltechnieken besproken die in Java worden gebruikt. Een van hen gebruikt een wrapper-klasse en de andere gebruikt de methode Collection.swap() . Het is belangrijk om te onthouden dat de afhandeling van uitzonderingen moet worden uitgevoerd wanneer de functie swap() wordt gebruikt , omdat deze een runtime-uitzondering genereert.