Analyse sur == et égal en Java

Analyse de

==

1 Pour les types de données de base, ce qui est comparé est de savoir si leur contenu spécifique est le même et leur mémoire. l'adresse n'a pas d'importance.

Par exemple :

public class Test{
	
	public static void main(String[] args) {
		int i = 10;
		double j = 10.0;
		float m = 10.0f;
		char k = 10;
		boolean b = true;
		
		System.out.println(i == j);
		System.out.println(i == m);
		System.out.println(m == k);
		System.out.println("*******************");
		//System.out.println(i == b);  很明显，布尔型不能和其他基本数据类型比较，编译报错.
		System.out.println(System.identityHashCode(i));
		System.out.println(System.identityHashCode(j));
		System.out.println(System.identityHashCode(m));
		System.out.println(System.identityHashCode(k));
		System.out.println(System.identityHashCode(b));
	}
}

Sortie :

true
true
true
*******************
366712642
1829164700
2018699554
1311053135
118352462

Recommandation de didacticiel vidéo associé : Tutoriel vidéo gratuit Java

Analyse :

① Selon les résultats de la comparaison et les adresses mémoire, le contenu est le même mais les adresses mémoire sont différentes, mais les résultats renvoyés sont tous vrais, ce qui signifie que lors de la comparaison, nous regardons uniquement si le contenu stockés dans les variables sont les mêmes et cela n’a rien à voir avec l’adresse mémoire.

②== Les données des deux côtés de la comparaison doivent être forcées au même type. Par exemple, la comparaison entre int et double sera forcée de doubler.

③Les types booléens ne peuvent pas être comparés aux types de données de base tels que int, float, double, char, etc., et une erreur sera signalée lors de la compilation.

2. Pour comparer les types de données de référence :

public class Test{
	
	public static void main(String[] args) {
		Test t1 = new Test();
		Test t2 = new Test();
        String name1 = "琼宝";
		String name2 = "琼宝";
		
		System.out.println(name1 == name2);						 // true
		System.out.println(System.identityHashCode(name1));		 //366712642	
		System.out.println(System.identityHashCode(name2));		 //366712642
		
		System.out.println(t1 == t2);                             //false
		System.out.println(System.identityHashCode(t1));          //366712642
		System.out.println(System.identityHashCode(t2));          //1829164700
        System.out.println(System.identityHashCode(new Test()));  //2018699554
		System.out.println(System.identityHashCode(new Test()));  //1311053135
        System.out.println(new Test() == new Test());
	}
}

Sortie :

true
366712642
366712642
false
366712642
1829164700
2018699554
1311053135
false

Analyse :

①Pour les types de données de référence, à ce moment Cela implique deux morceaux de mémoire, et la comparaison consiste à savoir si les adresses mémoire sont les mêmes. Par exemple, lors de l'exécution de l'instruction :

Test t1 = new Test() Test t2 = new Test(), deux morceaux de mémoire seront ouverts, un pour stocker t1 t2. et un pour en stocker deux new Test(). Il est évident que les adresses mémoire de t1 et t2 sont différentes, et même les adresses des deux nouveaux Test() sont différentes, donc lorsque vous utilisez == pour comparer à ce moment, le résultat doit être faux.

(Supplément : ce qui est stocké dans t1 et t2 est en fait la première adresse de la mémoire utilisée par le nouvel objet Test().)

②Pour le type String, lorsque le contenu est la même chose, les adresses mémoire sont également les mêmes et les adresses sont également examinées lors de la comparaison.

Si vous souhaitez comparer si le contenu stocké dans l'objet est le même (sans comparer les adresses), alors == ne peut pas être implémenté et égal est requis.

Analyse d'égaux

1. Regardons un exemple de comparaison d'égaux :

public class TestEquals {
	public static void main(String[] args) {
		
		TestEquals t1 = new TestEquals();
		TestEquals t2 = new TestEquals();
		System.out.println(t1.equals(t2));  //false
		
		String s1 = new String();
		String s2 = new String();		
	
        System.out.println(System.identityHashCode(s1));
		System.out.println(System.identityHashCode(s2));
		System.out.println(System.identityHashCode(new String()));
		System.out.println(System.identityHashCode(new String()));
        System.out.println(s1.equals(s2));  // true
	}
}

输出结果：
false
366712642
1829164700
2018699554
1311053135
true

2 Analyse :

①t1. et La comparaison de t2 est fausse, et la comparaison de s1 et s2 est vraie. Cela implique la réécriture de la méthode equals. Tout d'abord, regardez le code source d'equals dans la classe Object :

public boolean equals(Object obj) {
        return (this == obj);
    }

② Pour. s1.equals(s2) , c'est s1, obj est s2 et la comparaison dans le code source utilise ==, qui est évidemment une comparaison des types de données de référence, en regardant les adresses mémoire de s1 et s2. On sait déjà que leurs adresses sont différentes. Donc le résultat est naturellement faux

③ Et le résultat de la comparaison entre s1 et s2 est vrai parce que dans la classe String, la méthode equals a été réécrite. code source :

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;
    }

④ Passé En le comparant avec le code source égal dans l'objet, nous pouvons voir que la méthode égale dans String ne compare plus l'adresse de l'objet, mais regarde le contenu des deux objets, ou si les attributs des deux objets sont les mêmes.

⑤Les classes telles que String, Date, File... etc. réécrivent toutes la méthode égale.

Résumé :

1.== ​​​​Lors de la comparaison des types de données de base, ce qui est comparé est de savoir si les contenus sont égaux. types de données de référence, cela dépend si les adresses mémoire sont égales.

2.equals ne peut comparer que les types de données de référence (objets). Avant d'être réécrit, == est utilisé pour comparer les adresses mémoire. Après la réécriture, la comparaison consiste à savoir si le contenu et les attributs spécifiques des objets sont cohérents.

Pour plus d'articles et de didacticiels connexes, veuillez visiter : Introduction à la programmation Java

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!