Hur byter man objekt i Java?

Att byta objekt är en av de mest populära åtgärderna inom programmering. Det är särskilt användbart vid sortering. Vad som händer i swapping är två variabler som byter ut sina värden. I den här artikeln lär vi oss hur man byter objekt i Java i två olika fall. Den ena byter ut oberoende objekt och den andra byter två objekt i en lista eller en array. Låt oss först undersöka utbyte av oberoende objekt.

Att byta objekt skiljer sig från att byta primitiva datatyper

En av de vanligaste metoderna att använda för att byta primitiva värden är att använda en tidsvariabel. Men du vet att Java använder "Pass by Value" när parametrar skickas till en metod. Att byta objekt fungerar därför inte som du förväntade dig med den här metoden. Följande exempel kommer att visa 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;
        }
    }
}

Utgången: Det var inget byte! När vi anropar swapmetoden och skickar objekten skickar vi en kopia av objektet, med alla egenskapsvärden. Detta är anledningen till att det kallas "Pass by Value". Bytningsmetoden byter faktiskt objekten och påverkar endast kopian av originalobjektet. Så de ursprungliga föremålen hålls oförändrade. Lösningen på detta skulle vara att använda en omslagsklass för att linda de två objekten.

Byta objekt med en omslagsklass

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

Här använde vi en wrapper-klass som har en egenskap av den typ av objekt vi behöver byta. Genom att använda en enkel swap-metod byter den innehållet i InnerClass-objekten i wrapper-klassobjekten. För ytterligare implementering av de utbytta InnerClass-objekten kan vi använda wrapperObj1.xyz och wrapperObj2.xyz i enlighet därmed. Utgången:

Den inbyggda swap()-metoden i Java

Java Collections Frameworks klasser har en inbyggd metod för att byta element som kallas swap() . Java.util är en verktygsklass som innehåller statiska metoder som kan fungera på element som listor från samlingsgränssnittet. Att använda swapmetoden är mycket lättare än exemplet vi diskuterade tidigare. Metoden swap() är en statisk metod och därför anropar du den med klassens namn som Collections.swap() . Returtypen för swap() -metoden är ogiltig så den kommer inte att returnera någonting. Du måste skicka tre argument till swap() -metoden. Kontrollera anteckningen nedan.

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

Parametrar:

• list — lista innehåller de element vi byter.
• a — index för ett element som ska bytas .
• b — index för ett annat element som ska bytas .

Observera att den här metoden ger ett IndexOutOfBoundsException om antingen a eller b ligger utanför liststorlekens intervall. Det maximala indexet för listan är ett mindre än listans storlek. Varje indexvärde som är högre än det kommer att orsaka att IndexOutOfBoundsException kastas. Ett exempel på hur man använder swapmetoden på en ArrayList visas nedan.

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 innehåller sex element. Vi byter element 2 ^och 5 ^med funktionen swap()- metoden. Den bästa praxisen är att skriva swap() -metoden i ett try-catch-block eftersom det kan skicka ett IndexOutOfBoundsException under körning. Utdata: Om vi ​​skickar '2' och '8' som index kommer applikationen att skapa ett undantag eftersom storleken på listan är sex.

Collections.swap(fruits, 2, 8);

Utgången blir:

Slutsats

I den här handledningen diskuterade vi ett par bytestekniker som används i Java. En av dem använder en wrapper-klass och den andra använder metoden Collection.swap() . Det är viktigt att komma ihåg att undantagshantering bör göras när du använder funktionen swap() eftersom det skapar ett körtidsundantag.