Comment puis-je passer d'un type de données primitif par référence?

Comment puis-je passer d'un type primitif par référence en java? Par exemple, comment puis-je faire un int passés à une méthode modifiable?

Je pense que cela s'applique également à Integer

InformationsquelleAutor Neuquino | 2010-11-30

73

Il n'y a pas un moyen de passer d'une primitive directement par référence en Java.

Une solution de contournement est de plutôt passer une référence à une instance d'une classe wrapper, qui contient alors la primitive en tant que membre de champ. Une telle classe wrapper peut être extrêmement simple à écrire pour vous-même:
```
public class IntRef { public int value; }
```
Mais comment au sujet de certains pré-construit des classes wrapper, donc nous n'avons pas d'écrire notre propre? OK:

Apache commons-lang Mutable* classes:

Avantages: Bonne performance pour une seule utilisation multithread. L'exhaustivité.

Inconvénients: Introduit un tiers de la bibliothèque de la dépendance. Pas intégré dans la simultanéité des contrôles.

Représentant les classes: MutableBoolean, MutableByte, MutableDouble, MutableFloat, MutableInt, MutableLong, MutableObject, MutableShort.

La java.util.de façon concomitante.atomique Atomique* classes:

Avantages: Partie de la norme Java (1.5+) de l'API. Construit-dans la simultanéité des contrôles.

Inconvénients: Petit gain de performance lorsque utilisé dans un thread unique paramètre. Manque de soutien direct pour certains types de données, par exemple, il n'y a pas de AtomicShort.

Représentant les classes: AtomicBoolean, AtomicInteger, AtomicLong, et AtomicReference.

Note: en tant Qu'utilisateur ColinD montre dans sa réponse, AtomicReference peut être utilisé pour se rapprocher de certains de ces classes manquantes, par exemple AtomicShort.

Longueur 1 primitive de la matrice de

OscarRyz réponse illustre l'utilisation d'une longueur de 1 matrice pour "encapsuler" une valeur primitive.

Avantages: Rapide à écrire. Performant. Pas de 3ème partie de la bibliothèque nécessaire.

Inconvénients: Un peu sale. Pas intégré dans la simultanéité des contrôles. Résultats dans le code qui n'est pas (clairement) l'auto-document: est la matrice dans la signature de la méthode, donc je peux passer plusieurs valeurs? Ou s'agit-il ici comme un échafaudage pour les passer par référence de l'émulation?

Voir aussi

Les réponses à StackOverflow question "Mutable champ booléen en Java".

Mon Avis

En Java, vous devez vous efforcer d'utiliser les méthodes ci-dessus avec modération ou pas du tout. En C, il est courant d'utiliser une fonction de la valeur de retour pour vous transmettre un code de statut (SUCCÈS/ÉCHEC), tandis qu'une fonction de la production réelle est relayé par un ou plusieurs paramètres de sortie. En Java, il est préférable d'utiliser des Exceptions au lieu de codes de retour. Cela libère les valeurs de retour des méthodes pour être utilisé pour la réalisation de la méthode de sortie -- un modèle de conception qui la plupart des programmeurs Java trouver de plus naturel que de paramètres de sortie.
- Atomics sont très pratique pour passer d'un compteur à une fonction qui est appelée plusieurs fois, cependant, en particulier si l'augmentation du compteur est conditionnelle dans la fonction, mais n'augmentant pas, il n'a pas forcément les moyens, quelque chose a échoué. De toute façon, merci pour cette réponse. C'est très utile.
InformationsquelleAutor
13

Rien en java est passé par référence. C'est tous passés par valeur.

Edit: à la Fois primitifs et les types d'objets sont passés par valeur. Vous pouvez ne jamais modifier la valeur passée/de référence et d'attendre l'origine de la valeur de référence pour le changement. Exemple:
```
String a;
int b;

doSomething(a, b);

...

public void doSomething(String myA, int myB) {
   //whatever I do to "myA" and "myB" here will never ever ever change
   //the "a" and "b"
}
```
Le seul moyen de contourner cet obstacle, quel que soit l'être primitif ou de référence, est de passer d'un objet conteneur, ou utiliser la valeur de retour.

Avec un titulaire:
```
private class MyStringHolder {
  String a;
  MyStringHolder(String a) {
    this.a = a;
  }
}

MyStringHolder holdA = new MyStringHolder("something");

public void doSomething(MyStringHolder holder) {
   //alter holder.a here and it changes.
}
```
Avec la valeur de retour
```
int b = 42;
b = doSomething(b);

public int doSomething(int b) {
  return b + 1;
}
```
- techniquement correcte, mais pas très utile
- Ok, je vais préciser.
- “Correcte” est une condition booléenne, et n'admet pas les modificateurs de degré ou de nature.
- Vous pouvez faire une déclaration correcte sans réellement répondre à une question. Je peux dire que 1 + 1 = 2", ce qui est correct mais ne pas répondre à la question. L'original de la réponse ici est plus proche de la réponse à la question que cela, mais n'a toujours pas fournir tout type de réponse qui serait réellement utile à la personne.
InformationsquelleAutor Martin Algesten
13

Passer un AtomicInteger, AtomicBoolean, etc. au lieu de cela. Il n'y en a pas un pour chaque type primitif, mais vous pouvez utiliser, par exemple, un AtomicReference<Short> si nécessaire.

N'remarque: il doit très rarement besoin de faire quelque chose comme ça en Java. Quand vous voulez le faire, je vous recommande de repenser ce que vous essayez de faire et de voir si vous ne pouvez pas le faire d'une autre manière (à l'aide d'une méthode qui retourne un int, disons... qu'est-ce exactement la meilleure chose à faire est d'varient d'une situation à l').
- +1 même si je pense que cela pourrait être la main lourde contre seulement l'aide d'un wrapper/titulaire d'un objet.
- Si vous venez d'utiliser set(int) à muter, je ne pense pas qu'il y aurait un impact sur les performances est la peine de s'inquiéter à propos de... la création de votre propre mutable wrapper pour ce faire (ou de l'importation de commons-lang, d'ailleurs...) serait un bien pire offense à mon avis. Aussi, j'espère que ce n'est pas le fait très souvent, comme je ne pense pas qu'il existe de nombreux cas où c'est vraiment nécessaire.
- D'accord sur l'importation de commons-lang être une mauvaise idée. J'imagine que l'OP est un programmeur en C et qu'il veut continuer à utiliser le même paradigmes qui conduisent à la plupart de la complexité dans la compréhension d'un programme C, donc j'imagine qu'il va être à l'aide de ce "pass primitif, par référence" solution assez fréquemment.
- Je suis d'accord; en passant mutable primitives, de style C, est presque toujours la bonne chose à faire en Java. Il n'est de rendre le code inutilement compliqué.
InformationsquelleAutor ColinD
10

Ce n'est pas possible en Java, comme alternative, vous pouvez l'envelopper dans un seul élément de tableau.
```
void demo() { 
    int [] a = { 0 };
    increment ( a ) 
}
void increment( int [] v ) { 
     v[0]++;
}
```
Mais il y a toujours de meilleures options.

InformationsquelleAutor OscarRyz
3

Vous ne pouvez pas. Mais vous pouvez nous retourner un entier qui est une modification de la valeur
```
int i = 0;
i = doSomething(i);
```
Si vous êtes de passage en plus de celui que vous voudrez peut-être créer un Objet De Transfert De Données (une classe spécifiquement pour contenir un ensemble de variables qui peuvent être transmis à des classes).

InformationsquelleAutor peter.murray.rust
2

Passer un objet qui a de la valeur en tant que champ.

InformationsquelleAutor Dan D.
1

Ce n'est pas possible en Java

InformationsquelleAutor a_horse_with_no_name
-2

Une option est d'utiliser les classes comme le java.lang.Entier, alors vous n'êtes pas en passant d'une primitive à tous.

D'autre part, vous pouvez simplement utiliser le code:
```
int a = 5;
a = func(a);
```
et ont func renvoie la valeur modifiée.
- java.lang.Entier et les amis sont immuables. java.util.de façon concomitante.atomique.AtomicInteger et les amis sont mutables. Un autre (type de brut) est l'option que j'ai vu est à utiliser 1 élément de tableau.
- C'est une manière de l'atteindre, pour une valeur unique!
InformationsquelleAutor DGH

Vous devez vous connecter pour publier un commentaire.