Un hashmap de pointeurs ?

Version imprimable

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:

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:

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:

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 !

26/05/2008, 14h38
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

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:

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:

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. ;)

26/05/2008, 14h54
divxdede
Code:

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...
26/05/2008, 15h11
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…

Tu peu effectivement passer par une classe intermediaire comme suit:

Code:

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:

1
2
3
4
null
null
10
10

26/05/2008, 15h44
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 ? :roll:)
26/05/2008, 15h51
adiGuba

Salut,

Citation:

Envoyé par three minute hero

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

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

a++