Hvordan bytter man objekter i Java?

At bytte objekter er en af ​​de mest populære handlinger inden for programmering. Det er især nyttigt til sortering. Det, der sker ved at bytte, er to variable, der udveksler deres værdier. I denne artikel lærer vi, hvordan man bytter objekter i Java i to forskellige tilfælde. Den ene bytter uafhængige objekter, og den anden bytter to objekter i en liste eller et array. Lad os først undersøge udskiftning af uafhængige objekter.

At bytte objekter er forskelligt fra at bytte primitive datatyper

En af de almindelige metoder til at bruge til at bytte primitive værdier er at bruge en tidsvariabel. Du ved dog, at Java bruger "Pass by Value", når du overfører parametre til en metode. Derfor vil udskiftning af objekter ikke fungere som forventet med denne metode. Følgende eksempel vil vise det.

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

Output: Der var ingen ombytning! Når vi kalder swap-metoden og sender objekterne videre, sender vi en kopi af objektet med alle egenskabsværdierne. Dette er grunden til, at det kaldes "Pass by Value". Swap-metoden bytter faktisk objekterne, hvilket kun påvirker kopien af ​​det originale objekt. Så de originale genstande holdes uændrede. Løsningen på dette ville være at bruge en wrapper-klasse til at indpakke de to objekter.

Udskiftning af objekter med en indpakningsklasse

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

Her brugte vi en wrapper-klasse, der har en egenskab af den type objekter, vi skal bytte. Ved at bruge en simpel swap-metode bytter den indholdet af InnerClass-objekterne i wrapper-klasseobjekterne. Til enhver yderligere implementering af de ombyttede InnerClass-objekter kan vi bruge wrapperObj1.xyz og wrapperObj2.xyz tilsvarende. Udgangen:

Den indbyggede swap()-metode i Java

Java Collections Frameworks klasser har en indbygget metode til at bytte elementer kaldet swap() . Java.util er en hjælpeklasse, der indeholder statiske metoder, der kan fungere på elementer som Lister fra samlingsgrænsefladen. At bruge swap-metoden er meget nemmere end det eksempel, vi diskuterede tidligere. swap ()- metoden er en statisk metode, og derfor kalder du den med klassenavnet som Collections.swap() . Returtypen for swap()- metoden er ugyldig, så den vil ikke returnere noget. Du skal sende tre argumenter til swap() -metoden. Tjek bemærkningen nedenfor.

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

Parametre:

• list — liste indeholder de elementer, vi bytter.
• a — indeks for et element, der skal byttes .
• b — indeks for et andet element, der skal byttes .

Bemærk, at denne metode vil kaste en IndexOutOfBoundsException, hvis enten a eller b er uden for rækkevidden af ​​listestørrelsen. Det maksimale indeks på listen er én mindre end listens størrelse. Enhver indeksværdi mere end det vil forårsage, at IndexOutOfBoundsException bliver kastet. Et eksempel på hvordan man bruger swap-metoden på en ArrayList er vist nedenfor.

swap()-metoden på en 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);
        }
    }
}

ArrayList of fruits indeholder seks elementer. Vi bytter 2. ^og 5. ^element ved hjælp af funktionen swap() -metoden. Den bedste praksis er at skrive swap()- metoden i en try-catch-blok, da den kan kaste en IndexOutOfBoundsException under kørsel. Output: Hvis vi sender '2' og '8' som indekser, vil applikationen give en undtagelse, da størrelsen på listen er seks.

Collections.swap(fruits, 2, 8);

Outputtet vil være:

Konklusion

I denne tutorial diskuterede vi et par bytteteknikker, der bruges i Java. En af dem bruger en wrapper-klasse, og den anden bruger metoden Collection.swap() . Det er vigtigt at huske, at undtagelseshåndtering skal udføres, når du bruger funktionen swap() , da den kaster en runtime-undtagelse.