Wie tausche ich Objekte in Java aus?

Der Austausch von Objekten ist eine der beliebtesten Aktionen in der Programmierung. Es ist besonders nützlich beim Sortieren. Was beim Tauschen passiert, ist, dass zwei Variablen ihre Werte austauschen. In diesem Artikel lernen wir, wie man Objekte in Java in zwei verschiedenen Fällen austauscht. Einer tauscht unabhängige Objekte aus und der andere tauscht zwei Objekte in einer Liste oder einem Array aus. Betrachten wir zunächst den Austausch unabhängiger Objekte.

Der Austausch von Objekten unterscheidet sich vom Austausch primitiver Datentypen

Eine der gebräuchlichsten Methoden zum Austauschen primitiver Werte ist die Verwendung einer zeitlichen Variablen. Sie wissen jedoch, dass Java beim Übergeben von Parametern an eine Methode „Pass by Value“ verwendet. Daher funktioniert das Austauschen von Objekten mit dieser Methode nicht wie erwartet. Das folgende Beispiel soll es zeigen.

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

Die Ausgabe: Es gab keinen Austausch! Wenn wir die Swap-Methode aufrufen und die Objekte übergeben, übergeben wir eine Kopie des Objekts mit allen Eigenschaftswerten. Aus diesem Grund wird es „Pass by Value“ genannt. Die Swap-Methode tauscht tatsächlich die Objekte aus und wirkt sich nur auf die Kopie des Originalobjekts aus. Die Originalobjekte bleiben also unverändert erhalten. Die Lösung hierfür wäre die Verwendung einer Wrapper-Klasse zum Verpacken der beiden Objekte.

Objekte mit einer Wrapper-Klasse austauschen

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 haben wir eine Wrapper-Klasse verwendet, die eine Eigenschaft des Objekttyps hat, den wir austauschen müssen. Mithilfe einer einfachen Swap-Methode wird der Inhalt der InnerClass-Objekte der Wrapper-Klassenobjekte ausgetauscht. Für jede weitere Implementierung der ausgetauschten InnerClass-Objekte können wir entsprechend wrapperObj1.xyz und wrapperObj2.xyz verwenden. Die Ausgabe:

Die integrierte swap()-Methode in Java

Die Klassen des Java Collections Framework verfügen über eine integrierte Methode zum Austauschen von Elementen namens swap() . Die java.util ist eine Dienstprogrammklasse, die statische Methoden enthält, die mit Elementen wie Listen aus der Collection-Schnittstelle arbeiten können. Die Verwendung der Swap-Methode ist viel einfacher als das zuvor besprochene Beispiel. Die swap()- Methode ist eine statische Methode und daher rufen Sie sie mit dem Klassennamen Collections.swap() auf . Der Rückgabetyp der swap()- Methode ist void, sodass nichts zurückgegeben wird. Sie müssen drei Argumente an die swap()- Methode übergeben. Überprüfen Sie den Hinweis unten.

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

Parameter:

• Liste – Liste enthält die Elemente, die wir austauschen.
• a – Index eines auszutauschenden Elements .
• b – Index eines anderen Elements, das ausgetauscht werden soll .

Beachten Sie, dass diese Methode eine IndexOutOfBoundsException auslöst, wenn entweder a oder b außerhalb des Bereichs der Listengröße liegt. Der maximale Index der Liste ist um eins kleiner als die Größe der Liste. Jeder Indexwert, der darüber liegt, führt dazu, dass die IndexOutOfBoundsException ausgelöst wird. Ein Beispiel für die Verwendung der Swap-Methode für eine ArrayList ist unten dargestellt.

swap()-Methode für eine 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);
        }
    }
}

Die ArrayList der Früchte enthält sechs Elemente. Wir tauschen das 2. ^und 5. ^Element mit der Funktion swap()- Methode aus. Die beste Vorgehensweise besteht darin, die Methode swap() in einen Try-Catch-Block zu schreiben, da sie zur Laufzeit eine IndexOutOfBoundsException auslösen kann. Die Ausgabe: Wenn wir „2“ und „8“ als Indizes übergeben, löst die Anwendung eine Ausnahme aus, da die Größe der Liste sechs beträgt.

Collections.swap(fruits, 2, 8);

Die Ausgabe wird sein:

Abschluss

In diesem Tutorial haben wir einige in Java verwendete Austauschtechniken besprochen. Einer von ihnen verwendet eine Wrapper-Klasse und der andere die Methode Collection.swap() . Es ist wichtig zu bedenken, dass bei Verwendung der Funktion swap() eine Ausnahmebehandlung durchgeführt werden sollte, da diese eine Laufzeitausnahme auslöst.