Comment pouvez-vous échanger des valeurs primitives en Java, étant donné ses limites en matière de transmission par valeur ?

Échange de primitives en Java : résoudre les limites du passage par valeur

En Java, où les paramètres sont transmis par valeur, tenter d'échanger des primitives les valeurs utilisant l’approche traditionnelle peuvent être futiles. Examinons un extrait de code qui démontre ceci :

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

L'intention de ce code est d'échanger les valeurs de x et y, mais comme vous pouvez le constater à partir du résultat, les valeurs restent inchangées. En effet, Java transmet par valeur, ce qui signifie qu'une copie des valeurs primitives est créée et transmise à la fonction swap. Toute modification apportée à ces copies dans la fonction d'échange n'a aucun effet sur les variables d'origine.

Pour surmonter cette limitation et réaliser l'échange, nous pouvons utiliser une technique qui tire parti de la fonctionnalité de retour de méthode de Java. En ajoutant une instruction return à la fonction swap et en réattribuant le résultat à l'appelant, nous pouvons indirectement échanger les valeurs :

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

Dans ce code modifié, la fonction swap renvoie la valeur de a. Cependant, son objectif principal est de permettre à l'appelant de réaffecter la valeur renvoyée au premier argument (dans ce cas, x). Cela réalise efficacement l’échange de x et y. Le modèle d'utilisation de cette fonction peut être un peu contre-intuitif, mais il fournit une solution viable pour échanger des primitives en Java.

Si vous désirez une approche plus générique, vous pouvez créer une méthode capable d'échanger n'importe quel nombre d'objets. du même type :

<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
}</code>

En appliquant ces techniques, vous pouvez efficacement échanger des primitives en Java, malgré l'absence de passage par référence.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!