Wie können Sie in Java angesichts der Einschränkungen bei der Wertübergabe primitive Werte austauschen?

Austauschen von Grundelementen in Java: Beheben der Einschränkungen der Wertübergabe

In Java wird versucht, Grundelemente auszutauschen, wenn Parameter als Wert übergeben werden Werte mit dem traditionellen Ansatz können zwecklos sein. Sehen wir uns einen Codeausschnitt an, der dies demonstriert:

<code class="java">public class SwapPrimitives {

    public static void swap(int a, int b) {
        int temp = a;
        a = b;
        b = temp;
    }

    public static void main(String[] args) {
        int x = 5;
        int y = 10;
        swap(x, y);
        System.out.println("x: " + x); // Output: 5
        System.out.println("y: " + y); // Output: 10
    }
}</code>

Die Absicht dieses Codes besteht darin, die Werte von x und y zu vertauschen, aber wie Sie der Ausgabe entnehmen können, bleiben die Werte unverändert. Dies liegt daran, dass Java Werte übergibt, was bedeutet, dass eine Kopie der Grundwerte erstellt und an die Swap-Funktion übergeben wird. Alle Änderungen, die innerhalb der Swap-Funktion an diesen Kopien vorgenommen werden, haben keine Auswirkungen auf die Originalvariablen.

Um diese Einschränkung zu überwinden und den Austausch zu erreichen, können wir eine Technik anwenden, die die Methodenrückgabefunktionalität von Java nutzt. Indem wir der Swap-Funktion eine Return-Anweisung hinzufügen und das Ergebnis dem Aufrufer erneut zuweisen, können wir die Werte indirekt austauschen:

<code class="java">public static int swap(int a, int b) {  // usage: y = swap(x, x=y);
    return a;
}

public static void main(String[] args) {
    int x = 5;
    int y = 10;
    y = swap(x, x = y);
    System.out.println("x: " + x); // Output: 10
    System.out.println("y: " + y); // Output: 5
}</code>

In diesem modifizierten Code gibt die Swap-Funktion den Wert von a zurück. Sein Hauptzweck besteht jedoch darin, dem Aufrufer zu ermöglichen, den zurückgegebenen Wert dem ersten Argument (in diesem Fall x) neu zuzuweisen. Dadurch wird effektiv der Austausch von x und y erreicht. Das Verwendungsmuster für diese Funktion kann etwas kontraintuitiv sein, bietet aber eine praktikable Lösung für den Austausch von Grundelementen in Java.

Wenn Sie einen allgemeineren Ansatz wünschen, können Sie eine Methode erstellen, die eine beliebige Anzahl von Objekten austauschen kann des gleichen Typs:

<code class="java">public static <t> T swap(T... args) {   // usage: z = swap(a, a=b, b=c, ... y=z);
    return args[0];
}

public static void main(String[] args) {
    int x = 5;
    int y = 10;
    int z = 15;
    z = swap(x, x = y, y = z);
    System.out.println("x: " + x); // Output: 15
    System.out.println("y: " + y); // Output: 10
    System.out.println("z: " + z); // Output: 5
}</t></code>

Durch die Anwendung dieser Techniken können Sie Primitiven in Java effektiv austauschen, obwohl es keine Referenzübergabe gibt.

Das obige ist der detaillierte Inhalt vonWie können Sie in Java angesichts der Einschränkungen bei der Wertübergabe primitive Werte austauschen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!