Comportement que je comprends pas

Bonjour,

Je ne comprend pas pourquoi si
Code:

1 2 3 String a = new String("toto"); String b = new String("toto");
a == b n'est pas vrai .... Pourtant toto c'est toto ...

Alors que si
Code:

1 2 3 int a = 0; int b = 0;
Alors là, a == 0 est vrai ... Normal 0 c'est 0

Citation:
Envoyé par elvorpholif
Bonjour,

Je ne comprend pas pourquoi si
Code:

1 2 3 String a = new String("toto"); String b = new String("toto");
a == b n'est pas vrai .... Pourtant toto c'est toto ...

Alors que si
Code:

1 2 3 int a = 0; int b = 0;
Alors là, a == 0 est vrai ... Normal 0 c'est 0
En java, on compare pas deux String avec "==" mais avec des fonctions
Code:

1 2 3 4 5 6 String a,b; a = "toto"; b = "toto"; if(a.equals(b)) System.out.println("a et b sont égaux !");
Donc toujours pour les String, il faut utiliser les fonctions.

Pour les entiers(int), double... on utilisent les "=="

Citation:
Envoyé par seanbean
En java, on compare pas deux String avec "==" mais avec des fonctions
Code:

1 2 3 4 5 6 String a,b; a = "toto"; b = "toto"; if(a.equals(b)) System.out.println("a et b sont égaux !");
Donc toujours pour les String, il faut utiliser les fonctions.

Pour les entiers(int), double... on utilisent les "=="
Faudrait lui expliquer le pourquoi du comment.

Un String c'est une classe. Donc ta string c'est une instance de classe. Alors que int, double, etc ... sont des types primitifs, qui n'obéissent pas aux mêmes règles.

Donc quand tu fais a == b avec des String, ça ne peut que renvoyer faux puisque tu compares les adresses mémoire dans la JVM et pas les valeurs.

Je sais pas si je suis clair.

Évidemment pour comprendre il faut connaitre les règles de gestion des références en Java.

Tu pourras utiliser
Code:

1 2 3 if (a.compareTo(b)==0) { .... }

Pour être précis :

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
49
50
51
52
53
54
55
56
import static java.lang.System.out;
 
public class Machin
{
    public static void main(String[] arguments) {
 
        int int1 = 0;
        int int2 = 0;
        out.println(int1 == int2); // true
 
        Integer integer1 = new Integer(0);
        Integer integer2 = integer1;
        out.println(integer1 == integer2); // true
 
        integer2 = new Integer(0);
        out.println(integer1 == integer2); // false
 
        // Unboxing automatique.
        int1 = integer1;
        int2 = integer2;
        out.println(int1 == int2); // true
 
        // Certains types wrappers font de l'optimisation.
        integer1 = Integer.valueOf(0);
        integer2 = Integer.valueOf(0);
        out.println(integer1 == integer2); // true
 
        // Jusqu'à un certain point...
        integer1 = Integer.valueOf(128);
        integer2 = Integer.valueOf(128);
        out.println(integer1 == integer2); // false
 
        // Le boxing automatique n'est que du sucre syntaxique pour faire la même chose.
        integer1 = 0;
        integer2 = 0;
        out.println(integer1 == integer2); // true
 
        // Idem.
        integer1 = 128;
        integer2 = 128;
        out.println(integer1 == integer2); // false
 
        String string1 = new String("toto");
        String string2 = new String("toto");
        out.println(string1 == string2); // false
 
        string1 = new String("toto");
        string2 = string1;
        out.println(string1 == string2); // true
 
        // Sorte de boxing qui existait avant Java 1.5 pour les valeurs littérales.
        string1 = "toto";
        string2 = "toto";
        out.println(string1 == string2); // true
    }
}

La seule règle pertinente reste cependant de savoir ce qu'on veut comparer. Avec les types primitifs, seule leur valeur est comparable. Avec tous les autres, c'est à dire les références d'objets, on peut comparer leur identité (opérateur ==) ou bien leur contenu (méthode equals). Typiquement, lorsqu'on clone un objet, on obtient un nouvel objet identique (identité différente), mais de même contenu. Le C++ est peut-être plus explicite à ce sujet puisqu'on voit bien la différence entre un et un "string *", un "string &" et un "string" (ce dernier n'existant pas en Java où seuls les types primitifs sont accessibles par valeur).

Citation:

Envoyé par Chatanga

Pour être précis :

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
49
50
51
52
53
54
55
56
import static java.lang.System.out;
 
public class Machin
{
    public static void main(String[] arguments) {
 
        int int1 = 0;
        int int2 = 0;
        out.println(int1 == int2); // true
 
        Integer integer1 = new Integer(0);
        Integer integer2 = integer1;
        out.println(integer1 == integer2); // true
 
        integer2 = new Integer(0);
        out.println(integer1 == integer2); // false
 
        // Unboxing automatique.
        int1 = integer1;
        int2 = integer2;
        out.println(int1 == int2); // true
 
        // Certains types wrappers font de l'optimisation.
        integer1 = Integer.valueOf(0);
        integer2 = Integer.valueOf(0);
        out.println(integer1 == integer2); // true
 
        // Jusqu'à un certain point...
        integer1 = Integer.valueOf(128);
        integer2 = Integer.valueOf(128);
        out.println(integer1 == integer2); // false
 
        // Le boxing automatique n'est que du sucre syntaxique pour faire la même chose.
        integer1 = 0;
        integer2 = 0;
        out.println(integer1 == integer2); // true
 
        // Idem.
        integer1 = 128;
        integer2 = 128;
        out.println(integer1 == integer2); // false
 
        String string1 = new String("toto");
        String string2 = new String("toto");
        out.println(string1 == string2); // false
 
        string1 = new String("toto");
        string2 = string1;
        out.println(string1 == string2); // true
 
        // Sorte de boxing qui existait avant Java 1.5 pour les valeurs littérales.
        string1 = "toto";
        string2 = "toto";
        out.println(string1 == string2); // true
    }
}

La seule règle pertinente reste cependant de savoir ce qu'on veut comparer. Avec les types primitifs, seule leur valeur est comparable. Avec tous les autres, c'est à dire les références d'objets, on peut comparer leur identité (opérateur ==) ou bien leur contenu (méthode equals). Typiquement, lorsqu'on clone un objet, on obtient un nouvel objet identique (identité différente), mais de même contenu. Le C++ est peut-être plus explicite à ce sujet puisqu'on voit bien la différence entre un et un "string *", un "string &" et un "string" (ce dernier n'existant pas en Java où seuls les types primitifs sont accessibles par valeur).

Bonjour...
Alors, pour être plus clair

Code:

1
2
3
4
String string1 = new String("toto");
        String string2 = new String("toto");
        out.println(string1.compareTo(string2)==0); // false

en String, dire S1==S2 c'est a dire avoir la même adresse, et bien sûr tu auras un false comme résultat

Un plus pour toi
http://leepoint.net/notes-java/data/...reobjects.html

; )