Java在比较字符串的时候，equals 与== 完全一样呀？

Question

完全一样，比较字符串equals与== 完全没有区别吗？

Answer 1

        String a1="a";
        String a2="a";
        String b1=new String("b");
        String b2=new String("b");
        System.out.println(a1 == a2);
        System.out.println(a1.equals(a2));
        System.out.println(b1 == b2);
        System.out.println(b1.equals(b2));

Résultat :

true
true
false
true

== compare si les variables pointées vers des objets sont cohérentes. La raison pour laquelle s et s2 sont égaux est que jvm optimise et que les deux variables pointent vers un seul objet.
equal compare si les chaînes stockées dans l'objet sont les mêmes.

Answer 2

Certaines questions ont en fait les meilleures réponses dans le code source

public boolean equals(Object anObject) {
    //如果引用的是同一个对象，返回真
    if (this == anObject) {
        return true;
    }
    //如果不是String类型的数据，返回假
    if (anObject instanceof String) {
        String anotherString = (String) anObject;
        int n = value.length;
        //如果char数组长度不相等，返回假
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            //从后往前单个字符判断，如果有不相等，返回假
            while (n-- != 0) {
                if (v1[i] != v2[i])
                        return false;
                i++;
            }
            //每个字符都相等，返回真
            return true;
        }
    }
    return false;

Answer 3

L'opérateur

== teste si deux références pointent vers le même objet. Si vous souhaitez tester si deux objets différents sont égaux, vous devez utiliser la méthode equals().

Si vous souhaitez en savoir plus, vous pouvez lire un article que j'ai écrit. Guide d'alphabétisation rapide Java

Answer 4

Je pense que votre question est très problématique. Comment avez-vous obtenu la conclusion décrite dans le texte à partir du code que vous avez publié ?
Je vais deviner votre intention et essayer d’y répondre à contrecœur.
En java, les méthodes == et égal sont différentes, une brève description est la suivante :

1. ==

   == est utilisé pour déterminer si deux références pointent vers le même objet, tel que
   Object a = new Object();
   Object b = a;
   a == b; =&gt ; vrai

2. égal

   La méthode égale est utilisée pour déterminer si deux objets sont égaux. Cette méthode a été définie dans la classe de niveau supérieur Object. L'implémentation de cette méthode dans Object utilise == pour comparer les références pour l'égalité. Si une sous-classe souhaite utiliser la méthode égale, il est préférable de remplacer la méthode égale de Object et de fournir sa propre logique d'égalité. Définissez une classe Person comme suit.

public class Person {
    private String name;
    private int age;
    // ...
    @Override
    public boolean equal(Object o) {
        if(o instanceof Person) {
            return o.getName().equal(name) && o.getAge() == age;
        } else {
            return false;
        }
    }
}

Answer 5

s et s2 sont tous deux des références directes à la constante "12". Le compilateur optimisera le code et créera uniquement un objet String "12", qui est référencé par deux variables, donc s == s2. Mais si votre autre « 12 » est créé d'une autre manière, comme new String("12") ou "1234".substring(0, 2), vous constaterez que == ne fonctionne pas et equals compare le contenu. En regardant le code original de equals, vous constaterez qu'il utilise également == d'abord pour comparer le

référencé

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

Answer 6

Ce sera différent quand du nouveau sortira

Answer 7

Tout d'abord, il faut considérer les fonctions de equals et == :
== équivaut à comparer les références de deux objets, alors que la méthode equals est définie dans la classe Object et a été réécrite par la String class Le code source peut être vu Dans l'analyse ci-dessus, == a d'abord été utilisé pour comparer les références, puis le contenu a été comparé.
Lorsque nous comparons deux chaînes, nous souhaitons principalement comparer le contenu, nous utilisons donc la méthode égale. Si vous utilisez ==, l'IDE lancera un avertissement.

Alors pourquoi vos méthodes == et equals ont-elles le même effet ? Cela dépend de la différence entre utiliser "=" pour créer un objet chaîne et utiliser new pour créer une chaîne.
Je ne sais pas si vous avez déjà compris le pool de cordes. Ma compréhension n'est pas approfondie. Vous pouvez y jeter un œil vous-même si nécessaire.
La première fois que vous utilisez "=" pour créer un objet chaîne, il vérifiera s'il y a "12" dans le pool de chaînes. Sinon, ajoutez-en un au pool et renvoyez la référence à s puis créez s2 When. , on constate qu'il y en a une dans le pool, alors cette référence est directement affectée à s2, donc les références de s et s2 sont les mêmes, ce qui fait que la comparaison == est vraie.
Vous pouvez utiliser new pour créer une chaîne et voir l'effet :

        String s1 = "12";
        String s2 = "12";
        String s3 = new String("12");

        System.out.println(s1 == s2);//true
        System.out.println(s1.equals(s2));//true
        System.out.println(s1 == s3);//false
        System.out.println(s1.equals(s3));//true

Lors de l'utilisation du mot-clé new pour créer un objet chaîne, un nouvel objet sera créé à chaque fois et la référence sera attribuée à la variable.

Answer 8

Tout est bien dit, je vous suggère de rechercher le pool de constantes de chaînes, cela vous donnera une compréhension approfondie

Answer 9

Le contenu de vos s1 et s2 est le même.
Votre méthode d'affectation est comme ceci
Tout d'abord, s1 mettra la chaîne "..." dans le pool constant de la machine virtuelle JVM <.>Lors de l'attribution de s2 pour la deuxième fois, il déterminera d'abord si le pool de constantes contient cette chaîne, et si c'est le cas, pointera vers elle.
Donc, même si vous utilisez ==, ce sera égal.
Si vous utilisez new string(123) dans s2, alors les adresses de référence sont différentes et elles ne sont pas égales.
Coder sur téléphone portable n'est pas facile.