Discussion :

[psycho_xn]

Bonjour,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
public class c_test {
 
    public c_test() {
    }
 
    public void function1(Integer v){
        v +=1;
        System.out.println("function1...........   "+v+"  ....................");
    }
 
    public void function2(Integer v){
        v +=10;
        System.out.println("function2...........   "+v+"  ....................");
    }
 
 
    public static void main(String[] args){
        c_test C = new c_test();
 
        Integer v;
        v=0;
 
        System.out.println("1 = "+v);
        C.function1(v);
        System.out.println("2 = "+v);
        C.function2(v);
        System.out.println("3 = "+v);
    }
}

ceci me donne le résultat

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
1 = 0
function1...........   1  ....................
2 = 0
function2...........   10  ....................
3 = 0

je chercher à faire un passage par référence à la variable v, qu'est-ce qui est erroné dans mon code qui fait que ceci ne marche pas ??

Merci bcp

[Uther]

Le problème viens du fait que Integer n'est pas un type primitif, mais un objet immuable : il n'existe aucune méthode permettant de modifier sa valeur.

Jusqu'en java 1.4, on ne pouvait pas faire le moindre calcul avec les objets.

Depuis java 1.5 et l'arrivée de l'autoBoxing/autoUnboxing, les Objets représentant un type(Integer/Byte/Long...) sont automatiquement convertis en leur type primitif équivalent, mais ce n'est jamais que du sucre syntaxique : v étant immuable, si tu lui affecte une valeur, il est créé un nouvel objet.

Par exemple dans ton code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
v += 1
// équivaut en fait a un 
v = new Integer(v.intValue()++);

L'objet auquel v faisait référence n'est donc pas modifié.

[psycho_xn]

Le problème viens du fait que Integer n'est pas un type primitif, mais un objet immuable : il n'existe aucune méthode permettant de modifier sa valeur.

Jusqu'en java 1.4, on ne pouvait pas faire le moindre calcul avec les objets.

Depuis java 1.5 et l'arrivée de l'autoBoxing/autoUnboxing, les Objets représentant un type(Integer/Byte/Long...) sont automatiquement convertis en leur type primitif équivalent, mais ce n'est jamais que du sucre syntaxique : v étant immuable, si tu lui affecte une valeur, il est créé un nouvel objet.

Par exemple dans ton code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
v += 1
// équivaut en fait a un 
v = new Integer(v.intValue()++);

L'objet auquel v faisait référence n'est donc pas modifié.

en gros il n'est pas possible de garder la valeur modifiée d'une variable en dehors de la fonction.

j'ai essayé avec un type StringBuffer et la valeur est bel et bien sauvegardée, je conclus donc que le problème vient des types. une idée sur les types qui permettent le référencement des objets ?? j'utiliseré le StrinBuffer au lieu du String, mais qu'en est-il de mon Integer ??

[Uther]

Les objets Integer,Short, Byte, String, ... sont immuables : leur valeur interne est initialisée dans le constructeur et aucune de leur méthodes ne permet de la modifier.

StringBuffer est en quelque sorte une version mutable de la classe String. Comme String, elle contient en interne une chaine de caractères, mais ses méthodes permettent de la modifier.

Il n'y a pas de version mutable des type primitifs numériques en java. Il te faudra les créer toi même.
par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class c_test{
 
    public c_test() {
    }
 
    public void function1(MutableInteger v){
        v.put( v.get() + 1);
        System.out.println("function1...........   "+v+"  ....................");
    }
 
    public void function2(MutableInteger v){
        v.put( v.get() + 10);
        System.out.println("function2...........   "+v+"  ....................");
    }
 
 
    public static void main(String[] args){
        Testd C = new Testd();
 
        MutableInteger v = new MutableInteger(0);
 
        System.out.println("1 = "+v);
        C.function1(v);
        System.out.println("2 = "+v);
        C.function2(v);
        System.out.println("3 = "+v);
    }
}
class MutableInteger{
    private int i;
 
    public int get() {return this.i;}
    public void put(int i) {this.i = i;}
    public MutableInteger(int i) {this.i = i;}
    @Override public String toString() { return new Integer(i).toString();}
 
}

[thelvin]

Il n'y a pas de version muttable des type primitifs numériques en java. Il te faudra les créer toi même.

En fait, il est possible de détourner les AtomicInteger et consorts pour faire exactement ça : ça marche aussi.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
AtomicInteger i = new AtomicInteger(1);
System.out.println(i.get());
i.set(2);
System.out.println(i.get());

À aucun moment on n'a créé de nouvel objet AtomicInteger, pourtant la valeur du premier change quand on lui demande.

[psycho_xn]

En fait, il est possible de détourner les AtomicInteger et consorts pour faire exactement ça : ça marche aussi.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
AtomicInteger i = new AtomicInteger(1);
System.out.println(i.get());
i.set(2);
System.out.println(i.get());

À aucun moment on n'a créé de nouvel objet AtomicInteger, pourtant la valeur du premier change quand on lui demande.

Merci pour la piste, je vais voir si ça me fera l'affaire avec les Integer.
je pense que g v utiliser StringBuffer au lieu du String,
AtomicInteger au lieu du Integer,
et pour les Short et char ??

[Uther]

En fait, il est possible de détourner les AtomicInteger et consorts pour faire exactement ça : ça marche aussi.

En effet. Je n'avais pas pensé à utiliser l'AtomicInteger parce que comme tu le dis, c'est un usage détourné. Cette classe est conçue pour résoudre certaines problématiques de concurrence.
L'utilisation de la classe à cette fin ne devrait cependant pas poser de problème, sauf peut-être des performance légèrement moindre dans certains cas.

je pense que g v utiliser StringBuffer au lieu du String,
AtomicInteger au lieu du Integer,
et pour les Short et char ??

Il n'existe pas de AtomicShort ou AtomicChar, mais tu peux évidement les stoquer dans un AtomicInteger.
Sinon tu peux coder des MutableShort et MutableChar sur le modèle de mon exemple.

[psycho_xn]

Sinon tu peux coder des MutableShort et MutableChar sur le modèle de mon exemple.

si j'adopte la méthode pour coder mes propres types, je serais dans l'obligation de n'utiliser que ces types là. j'ai juste un soucis côté taille de la mémoire occupée par ces types, est-ce qu'il seront toujours codés sur la même taille ??

[merill]

En ce qui concerne le passage par référence, en général on le fait via un tableau à une dimension.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
/**
 * @param entierInOut tableau d'un entier, modifié.
 */
void monPlusPlus( int[] entierInOut){
  entierInOut[0]++;
}

Perso j'aime pas, ca prête à confusion

Il y a aussi la possibilité d'utiliser une classe pointeur, je trouve ca déjà plus "propre" (car générique et explicite).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
class Pointeur<Type>{
  private Type data;
  Pointeur(){ this.data = null; }
  Pointeur(Type data){ this.data = data; }
  Type get(){ return data; }
  void set(Type data){ this.data = data; }
}

Enfin, dans ton cas on peut effectivement utiliser le MutableInteger de Uther dans la mesure où il utilise un type primitif et est donc plus performant (si il y a un gros besoin sur ce niveau là)

Si il n'y a qu'une valeur à renvoyer, fait une fonction au lieu d'une procédure.

En général, si l'on a besoin de passer un truc par référence, il se situe déjà dans un autre objet, et c'est donc celui-la que l'on passe en paramètre.

[tchize_]

dans le code donné, la méthode la plus propre, c'est de retourner la nouvelle valeur. Ca marche pas si il y en a plusieurs, mais dans le cas présent c'est la méthode la plus propre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class c_test {
 
    public c_test() {
    }
 
    public Integer function1(Integer v){
        v +=1;
        System.out.println("function1...........   "+v+"  ....................");
        return v;
    }
 
    public Integer function2(Integer v){
        v +=10;
        System.out.println("function2...........   "+v+"  ....................");
        return v;
    }
 
 
    public static void main(String[] args){
        c_test C = new c_test();
 
        Integer v;
        v=0;
 
        System.out.println("1 = "+v);
        v=C.function1(v);
        System.out.println("2 = "+v);
        v=C.function2(v);
        System.out.println("3 = "+v);
    }
}

[psycho_xn]

dans le code donné, la méthode la plus propre, c'est de retourner la nouvelle valeur. Ca marche pas si il y en a plusieurs, mais dans le cas présent c'est la méthode la plus propre:

il s'agissait juste d'un simple exemple, mais j'ai des cas où j'ai besoin de faire référence à plusieurs variables

[ep31]

il s'agissait juste d'un simple exemple, mais j'ai des cas où j'ai besoin de faire référence à plusieurs variables

Bonjour, il te suffirait de stocker tes Integer et consorts dans une collection, la passer en paramètre de ta méthode et de modifier les valeurs des différents objets en modifiant donc ta collection avec les nouveaux éléments