Discussion :

[three minute hero]

Bonjour à tous,

Venant de C++, il y a un comportement que je ne m'explique pas.
Je veux bien comprendre qu'on a plus à se soucier des pointeurs, mais pourquoi est ce que ce code… :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
Integer test = null;
propertyMap.put("int", test); //propertyMap est une hashtable d'Object
 
System.out.println(test);
System.out.println(propertyMap.get("int"));
 
test = new Integer(10);
 
System.out.println(test);
System.out.println(propertyMap.get("int"));

…me renvoie ceci :

Code :

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

1
2
3
4
null
null
10
null

?

C'est certainement que quelque chose m'échappe, ce doit être normal, mais je ne comprend pas pourquoi je n'obtiens pas ceci :

Code :

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

1
2
3
4
null
null
10
10

Une âme charitable pour m'expliquer ce comportement ? J'ai tenté des recherches sur le net, mais rien de fructueux…

Merci beaucoup !

[Billy14]

Salut,

Je pense que cela vient du fait que quand tu ajoute ton objet test dans ta Hashtable, il recrée une nouvelle instance de l'objet. Cela induit que ton objet test est indépendant de l'objet que tu as dans ta Hashtable et donc quand tu change le premier le deuxième ne change pas et reste à null

[three minute hero]

Merci pour vos réponses

@Billy14 + divxdede > Oui oui, c'est bien ce que j'ai interprété. Mais j'aimerais justement faire une affectation de l'instance et non une copie.

@Deadpool > Oops, j'ai écrit hashtable dans le commentaire, mais il s'agissait bien d'une hashmap (comme l'indiquait l'intitulé du topic) !

Il n'existe donc pas de moyen simple pour créer une map d'instances sans copie ?
Comme solution intermédiaire, je vais écrire une classe template Property ayant un champ String et un autre T. Mais bon, j'ai un peu l'impression de réinventer la roue…

[divxdede]

Tu peu effectivement passer par une classe intermediaire comme suit:

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
38
39
40
41
42
43
44
45
46
47
48
/**
 *
 * 
 */
public class MutableReference<T>  {
 
    /** reference holded
     */
    private T referent = null;
 
    /** Creates a new instance of MutableReference */
    public MutableReference(T ref) {
        this.referent = ref;
    }
 
    public T get() {
        return referent;
    }
 
    public void set(T referent) {
        this.referent = referent;
    }
 
    public void clear() {
        this.referent = null;
    }
 
    public String toString() {
        if( get() == null ) return "null";
        return get().toString();
    }
 
 
    public static void main(String[] args) {
 
        Map<String,MutableReference<Integer>> propertyMap = new HashMap<String,MutableReference<Integer>>();
 
        MutableReference<Integer> test = new MutableReference<Integer>(null);
        propertyMap.put("int", test); //propertyMap est une hashtable d'Object
 
        System.out.println(test);
        System.out.println(propertyMap.get("int"));
 
        test.set( new Integer(10) );
 
        System.out.println(test);
        System.out.println(propertyMap.get("int"));
    }

et tu obtient bien

Code :

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

1
2
3
4
null
null
10
10

[three minute hero]

Super, c'est bien mieux que ce que je m'apprêtais à faire

Merci beaucoup !

(C'est utile que je hurle C++ powa, ou c'est bon, j'me suis fait suffisamment comprendre ? )

[adiGuba]

Salut,

(C'est utile que je hurle C++ powa, ou c'est bon, j'me suis fait suffisamment comprendre ? )

Non car cela impliquerait qu'on se tape des constructeurs de copies et des copies de protection à tout bout de champ

a++

[Deadpool]

Ben tu affecte une nouvelle référence à ta variable test tandis que la Hashtable pointe encore sur l'ancienne, c'est un comportement logique.

En revanche considère le cas suivant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
StringBuffer test = new StringBuffer("abc");
		Hashtable propertyMap = new Hashtable();
		propertyMap.put("str", test); //propertyMap est une hashtable d'Object
 
		System.out.println(test);
		System.out.println(propertyMap.get("str"));
 
		test.append("cde");
 
		System.out.println(test);
		System.out.println(propertyMap.get("str"));

qui renvoie ceci.

Code :

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

1
2
3
4
5
 
abc
abc
abccde
abccde

Ici on a utilisé une méthode d'altération de ce fait le changement effectué sur la variable test est répercuté dans la hashtable.

PS: au passage, Hashtable est une vieillerie de Java 1.0 qu'il ne faudrait plus utiliser.

A la place on utilise traditionnellement une HashMap.

[divxdede]

Code :

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

1
2
Integer test = null;
propertyMap.put("int", test); //propertyMap est une hashtable d'Object

A ne pas confondre variables et objets !!

test est une variable (une zone mémoire contenant l'adresse mémoire vers un objet).
Dans le code précedent, la variable contient null, c'est à dire qu'elle ne réference aucun objet.

Quand tu insères dans ta Map l'association "int"/test, la map utilises ces propres variables.
De plus en java lorsque tu appelles une méthode comme put(...), les variables sont passées par valeur (C'est à dire que les parametres sont des nouvelles variables differentes de celles passées en parametre par l'appelant) dont le contenu à été recopié.

La map à donc associé null à la clé "int" quoique tu fasses aprés de ta variable test.

Je ne sais pas si j'ai été clair...