Tableau passé par valeur ou passé par référence en Java

1. Qu’est-ce qui est transmis par valeur en Java
2. Qu’est-ce qui est passé par référence en Java

Ce tutoriel présente un tableau passé par valeur ou référence en Java.

Lorsque nous appelons une méthode, ses arguments peuvent être passés comme valeur ou comme référence. Avant de discuter de ces deux éléments, comprenons deux termes :

• callee : c’est la méthode appelée par une autre méthode
• caller : c’est la méthode qui appelle une autre méthode

Apprenons maintenant ce que signifient passer par valeur et passer par référence.

Qu’est-ce qui est transmis par valeur en Java

Lorsque nous disons que les arguments sont passés par valeur, une copie de la valeur réelle du paramètre est faite en mémoire.

L’appelant et l’appelé maintiennent deux variables indépendantes avec la même valeur. Si l’appelé modifie la valeur du paramètre, nous ne pouvons pas voir le changement chez l’appelant.

Les points importants:

• L’appelé n’a pas accès à l’élément d’origine dans le code appelant.
• Une copie des données (valeurs des paramètres) est envoyée à l’appelé.
• Les modifications apportées à la variable transmise n’affectent pas la valeur finale.

Qu’est-ce qui est passé par référence en Java

Lorsque nous disons que les arguments sont passés par référence (également appelé passage par adresse), cela signifie passer la référence d’un argument dans la fonction appelante au paramètre formel correspondant.

Une copie de l’adresse de l’argument réel est faite dans cette situation. L’appelant et l’appelé utilisent la même variable pour le paramètre, et donc, si l’appelé modifie la variable de paramètre, nous pouvons voir le changement dans la variable de l’appelant.

Les points importants:

• L’appelé donne une référence à l’élément de programmation dans le code appelant.
• L’adresse mémoire des données stockées est transmise à la place de la valeur.
• Toute modification de la valeur affectera les données d’origine

Java est passé par valeur

Contrairement à C++, en Java, nous ne pouvons transmettre des arguments que sous forme de valeurs. Mais il y a un hic : lorsque des objets sont passés en arguments, leur référence est passée en valeur à l’appelé.

En d’autres termes, même si Java est strictement passé par valeur, il se comporte comme passé par référence pour les objets. Prenons quelques exemples pour mieux comprendre ce concept.

Passage de types de données primitifs en Java

Dans le code ci-dessous, nous passons deux entiers comme arguments à une fonction, puis nous modifions leurs valeurs.

Comme les arguments sont passés par valeur en Java, la fonction conserve une copie séparée des arguments. Toute modification que nous apportons aux arguments est effectuée dans la copie de la fonction uniquement et non dans la copie que la fonction principale (appelant) maintient.

Par conséquent, nous obtenons les valeurs d’origine lorsque nous imprimons les valeurs une fois l’appel de fonction terminé. Regardez l’exemple de code ci-dessous :

public class SimpleTesting {
  static void JE_function(int n1, int n2) {
    n1 = -232;
    n2 = -90;
  }

  public static void main(String args[]) {
    int JE_numa = 6932;
    int JE_numb = 8934;
    System.out.println("Numbers before function call :" + JE_numa + " and " + JE_numb);
    JE_function(JE_numa, JE_numb);
    System.out.println("Numbers after the JE_function call :" + JE_numa + " and " + JE_numb);
  }
}

Production :

Numbers before function call:6932 and 8934
Numbers after the JE_function call:6932 and 8934

Passer un tableau en Java

Lorsqu’il s’agit d’objets, la référence à l’objet est passée par valeur en tant qu’argument.

Dans le code ci-dessous, nous passons un tableau comme argument, et lorsque nous imprimons la valeur de l’objet (tableau), un emplacement mémoire est imprimé. Cela a à voir avec le fait qu’une variable objet stocke l’emplacement de la mémoire où l’objet est stocké.

Regardez l’exemple de code ci-dessous :

public class SimpleTesting {
  static void JE_function(String[] sentence) {
    System.out.println(sentence);
  }

  public static void main(String args[]) {
    String[] sent = {"I", "Love", "Delftstack"};
    JE_function(sent);
  }
}

Production :

[Ljava.lang.String;@442d9b6e

En utilisant le code ci-dessus, nous essayons de transmettre une référence au tableau passé en argument. Ainsi, si nous modifions la valeur du tableau (pas l’emplacement de la mémoire), le changement sera reflété dans l’appelé.

Regardez l’exemple de code ci-dessous :

public class SimpleTesting {
  static void JE_function(String[] sentence) {
    sentence[1] = "Visit";
  }

  public static void main(String args[]) {
    String[] sent = {"I", "Love", "Delftstack"};
    System.out.println("Sentence before calling the function");
    for (String word : sent) {
      System.out.println(word);
    }
    JE_function(sent);
    System.out.println("Sentence after calling the function");
    for (String word : sent) {
      System.out.println(word);
    }
  }
}

Production :

Sentence before calling the function
I
Love
Delftstack
Sentence after calling the function
I
Visit
Delftstack

Comme le montre le code ci-dessus, toute modification apportée au tableau est reflétée dans le bloc principal.

Pensez-y comme si deux amis travaillaient sur un projet. Tout travail effectué par l’un des amis se reflétera dans le projet global.

La fonction, dans ce cas, fait référence au même tableau que celui utilisé par le bloc principal.