Discussion :

[elvorpholif]

Bonjour,

Je ne comprend pas pourquoi si

Code :

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

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 :

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

1
2
3
 
int a = 0;
int b = 0;

Alors là, a == 0 est vrai ... Normal 0 c'est 0

[seanbean]

Bonjour,

Je ne comprend pas pourquoi si

Code :

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

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 :

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

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 :

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

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 "=="

[Marco46]

En java, on compare pas deux String avec "==" mais avec des fonctions

Code :

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

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.

[javaNavCha]

Tu pourras utiliser

Code java :

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

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

[Chatanga]

Pour être précis :

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

[javaNavCha]

Pour être précis :

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
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 java :

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

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

[javaNavCha]

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

; )