Question sur = = opérateur en java

== ne vérifie pas les modèles de bits, il comparera l'adresse mémoire des objets. Seulement le même objet a la même adresse mémoire.

La réponse de Clint est correcte mais je vais la développer davantage et l'expliquer au niveau du compilateur.

Comme vous le savez, s1 et s2 finiront par être des références à la même instance de chaîne, "Hello".

Pour s5 et s6, le compilateur voit des expressions constantes. C'est, il voit une opération entre deux constantes (les littéraux de chaîne). Le compilateur sait comment ajouter des chaînes et quel serait le résultat. Puisque les valeurs sont connues immédiatement au moment de la compilation, il fait le outre pour vous, résultant dans la chaîne littérale "Hello". Par conséquent, il a la même valeur que s1 et s2 donc chacun fera également référence à la même instance.

s7 ne peut pas être simplifié de la même manière. s7 commence initialement par "He" bien sûr. La différence ici est que s7 = s7.concat("llo"); comme réaffectant s7 au résultat d'un appel de fonction. Cela n'a pas pu être simplifié tel quel. En ce qui concerne le compilateur Java, les résultats de tous les appels de fonction ne sont pas connus au moment de la compilation. Comme il ne connaît pas la valeur résultante, il ne peut pas être simplifié et est laissé tel quel. L'appel résultant renvoie une nouvelle instance d'une chaîne "Hello" qui n'est pas la même instance que l'instance de compilation (que s8 partage).

s10 ne peut pas être simplifié de la même manière. s10 commence initialement par "He" bien sûr. Puis est réaffecté s10 = s10 + "llo"; Cela n'a pas pu être simplifié. Pourquoi me demanderez-vous? Eh bien s10 est une expression de variable non finale. Signification techniquement, l' le compilateur ne connaît pas sa valeur car ce n'est pas une constante. Si s10 a été déclaré a final String, alors cela pourrait être plié constant (lorsqu'il est affecté à une variable différente).

Alors considérez cette version de votre code de test:

public static void main(String[] args)
{
    String s1 = "Hello";
    String s2 = "Hello";
    System.out.println("1: s1 == s2 " + (s1 == s2));    // 1

    String s3 = "Hel" + "lo";
    String s4 = "Hel".concat("lo");
    System.out.println("2: s1 == s3 " + (s1 == s3));    // 2
    System.out.println("3: s1 == s4 " + (s1 == s4));    // 3

    String he = "He";
    String s5 = he + "llo";
    String s6 = he.concat("llo");
    System.out.println("4: s1 == s5 " + (s1 == s5));    // 4
    System.out.println("5: s1 == s6 " + (s1 == s6));    // 5

    final String fhe = "He";
    String s7 = fhe + "llo";
    String s8 = fhe.concat("llo");
    System.out.println("6: s1 == s7 " + (s1 == s7));    // 6
    System.out.println("7: s1 == s8 " + (s1 == s8));    // 7
}

Pouvez-vous déterminer quelles lignes sont vraies?

_{vrai, vrai, faux, faux, faux, vrai, faux
Vous vous demandez peut-être pourquoi les 3 et 7 ne sont pas vrais. Réponse courte, le compilateur Java n'a pas été programmé}
^{être assez intelligent pour reconnaître l'appel concat () est donc traité comme un appel de fonction régulier.}

L'opérateur = teste si les références sont les mêmes (c'est à dire pointant vers le même objet), pas si les valeurs de références sont les mêmes. Si vous devez tester si une chaîne est égale à une autre, vous devez utiliser le intégré .méthode equals. Cela fera une comparaison de valeur d'objet. par exemple

final String expectedValue = "Foo";
final String actualValue = "F" + "oo";
if (expectedValue.equals(actualValue)) {
  // This will trigger where == would not
}

De plus, pour des raisons de sécurité, si vous comparez deux chaînes et que l'une est une constante, il est généralement préférable d'invoquer equals sur la constante, c'est-à-dire

String myValue = getMyValue;
boolean theSame = "Some value".equals(myValue);

Plutôt que

String myValue = getMyValue;
boolean theSame = myValue.equals("Some Value");

Le la raison en est que la deuxième forme risque une exception de pointeur null qui peut être évitée en appelant equals() sur la chaîne constante qui est garantie d'être là.

Vous ne pouvez pas faire d'hypothèse sur les objets string.

Une machine virtuelle pourrait travailler dur pour s'assurer qu'aucun objet chaîne contenant exactement le même tableau de caractères n'existe en même temps, alors que d'autres machines virtuelles autoriseraient les doublons.

Le == exploitant vérifie si deux objets ont la même adresse (pointeur). Uniquement pour les types primitifs qui ne sont pas une référence (comme int, char, etc.) le fait de comparer la valeur.

Vous devez utiliser quelque chose comme s1.equals(s2) pour comparer le contenu de deux chaînes.

Dans l'exemple que vous avez fourni, voici ce qui se passe:

String s7 = “He”;    //s7 is an object referencing a part of memory holding “He”
String s8 = “Hello”;   //s8 is an object referencing a part of memory holding “Hello”
s7 = s7.concat(“llo”); //s7.concat(“llo”) created a new object in memory that contains “Hello” and s7 now references this now object 

(s7==s8)             //checks if the equality of the object reference and this is false since they reference different memory addresses.

(s7.equals(s8))         //this will compare s7 and s8 however way the String class compares two String objects.