Discussion :

[Pragmateek]

Salut!

On peut lire dans la javadoc:

Strings are constant; their values cannot be changed after they are created.

Pourtant:

Code :

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

1
2
3
4
String s1="azerty";
s1="az";
s1="azertyuiop";
s1=s1.replace('a','b');

est tout à fait valide.

Que signifie exactement le terme "constant" et "cannot be changed".

Merci de vos explications.

[adiGuba]

Salut,

Que signifie exactement le terme "constant" et "cannot be changed".

Cela signifie qu'une fois qu'un objet String est crée, il ne peut plus être modifié (on parle aussi de classe immuable). Tu n'a pas de méthode setValue() qui modifie l'objet courant, mais uniquement des méthodes qui renvoient un nouvel objet...

En fait a chaque fois que tu modifies la String dans ton code, tu affectes une nouvelle référence, et donc il s'agit d'un nouvel objet. Tu peux vérifier cela en utilisant la méthode System.identityHashCode() qui te renvoit un identifiant unique par objet :

Code :

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

1
2
3
4
5
6
7
8
        String s1="azerty";
        System.out.println( "s1 = " + System.identityHashCode(s1) );
        s1="az";
        System.out.println( "s1 = " + System.identityHashCode(s1) );
        s1="azertyuiop";
        System.out.println( "s1 = " + System.identityHashCode(s1) );
        s1=s1.replace('a','b');
        System.out.println( "s1 = " + System.identityHashCode(s1) );

Tu verras que tu obtiens 4 valeurs différentes...



Ce principe de classe immuable est très présent en Java et permet de gérer simplement les données. Par exemple lorsque tu récupères un objet immuable en paramètre d'une méthode, tu sais qu'il ne pourra pas être modifié de "l'extérieur" et tu peux donc le conserver tel quel...

Par exemple la classe Long est immuable, alors que la classe Date ne l'est pas car elle comporte une méthode setTime() qui permet de modifier sa valeur (d'ailleurs plusieurs personnes pensent que Date aurait du être immuable également).
Ainsi si tu écris la classe suivante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Test {
    Long longValue;
    Date dateValue;
 
    public Test(Long l, Date d){
        this.longValue = l;
        this.dateValue = d;
    }
 
    @Override
    public String toString() {
        return "(Long=" + longValue + ", Date=" + dateValue.getTime() + ")";
    }
}

Tu sais que son attribut longValue ne pourra pas être modifié après la création de l'objet. Par contre rien n'est sûr en ce qui concerne l'attribut dateValue...

Le code suivant le montre très bien :

Code :

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

1
2
3
4
5
6
7
8
9
10
        Long l1 = new Long(100);
        Date d1 = new Date(100);
        Test t = new Test(l1, d1);
        
        System.out.println(t); // Affiche (Long=100, Date=100)
        
        l1 = new Long(200); // Cree un nouvel objet Long
        d1.setTime(200);    // Modifie l'objet courant et celui de l'objet 'Test'
        
        System.out.println(t); // Affiche (Long=100, Date=200)

La valeur du champs dateValue est modifié de l'extérieur de la classe, ce qui peut poser problème dans certain cas...

Du coup tu es obligé de créer un nouvel objet Date si tu veux pouvoir le protéger des modifications depuis l'extérieur :

Code :

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

1
2
3
4
    public Test(Long l, Date d){
        this.longValue = l;
        this.dateValue = new Date(d.getTime());
    }

a++

[Pragmateek]

OK merci.
Le GC est il invoqué à chaque nouvelle affectation pour détruire "l'ancienne" "s1" et y a t'il création d'un nouvel objet "String" à chaque fois ou est-ce plus subtil?

[Baptiste Wicht]

OK merci.
Le GC est il invoqué à chaque nouvelle affectation pour détruire "l'ancienne" "s1" et y a t'il création d'un nouvel objet "String" à chaque fois ou est-ce plus subtil?

Je crois pas que ce soit beaucoup plus subtil.

Lors d'une opération comme celle-ci :

Code :

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

1
2
String chaine1 = "Chaine 1";
chaine1 = "Chaine 2";

Ca va faire quelque chose comme ca :

• Création d'un nouvel objet pointant sur Chaine 1
• On fait pointer chaine1 sur Chaine 2
• Il n'y a donc plus aucune référence pointant sur Chaine 1, il devient donc candidat au ramasse-miettes
• Ca fait donc un objet qui sert à rien qui prend de la mémoire tant que le ramasse-miettes n'est pas passé

[Ricky81]

Pour information, dans le cas d'une concaténation :

Code :

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

1
2
3
public String getString(String str1,String str2) {
            return str1+str2;
}

se transforme après compilation en :

Code :

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

1
2
3
public String getString(String str1,String str2) {
           return new StringBuffer().append(str1).append(str2).toString();
}

[Pragmateek]

Merci à tous de vos réponses.