Quelle est la différence entre == et equals() en Java?

En général, la réponse à votre question est "oui", mais...

• .equals(...) ne comparer ce qu'il est écrit pour comparer, pas plus, pas moins.
• Si une classe ne remplace pas la méthode equals, puis il prend par défaut la equals(Object o) méthode du plus proche parent de la classe qui a remplacé cette méthode.
• Si aucun parent n'classes ont fourni un remplacement, puis il prend par défaut la méthode de la société mère ultime de classe, d'Objet, et donc, vous êtes de gauche avec la Object#equals(Object o) méthode. Par l'Objet de l'API est la même que ==; en effet, elle renvoie true si et seulement si les deux variables font référence au même objet, si leurs références sont un et le même. Ainsi, vous serez en test pour objet d'égalité et pas fonctionnelle de l'égalité.
• Toujours n'oubliez pas de remplacer hashCode si vous remplacez equals afin de ne pas "casser le contrat". Comme par l'API, le résultat renvoyé à partir de la hashCode() méthode pour les deux objets doit être la même si leur equals méthodes montrent qu'ils sont équivalents. L'inverse est pas nécessairement vrai.

Il y a quelques petites différences selon que l'on parle de "primitives" ou "Types d'Objet"; la même chose peut être dit que si vous parlez de la "statique" ou "non-statique" membres; vous pouvez également mélanger tous les ci-dessus...

Voici un exemple (vous pouvez l'exécuter):

public final class MyEqualityTest
{
public static void main( String args[] )
{
String s1 = new String( "Test" );
String s2 = new String( "Test" );
System.out.println( "\n1 - PRIMITIVES ");
System.out.println( s1 == s2 ); //false
System.out.println( s1.equals( s2 )); //true
A a1 = new A();
A a2 = new A();
System.out.println( "\n2 - OBJECT TYPES /STATIC VARIABLE" );
System.out.println( a1 == a2 ); //false
System.out.println( a1.s == a2.s ); //true
System.out.println( a1.s.equals( a2.s ) ); //true
B b1 = new B();
B b2 = new B();
System.out.println( "\n3 - OBJECT TYPES /NON-STATIC VARIABLE" );
System.out.println( b1 == b2 ); //false
System.out.println( b1.getS() == b2.getS() ); //false
System.out.println( b1.getS().equals( b2.getS() ) ); //true
}
}
final class A
{
//static
public static String s;
A()
{
this.s = new String( "aTest" );
}
}
final class B
{
private String s;
B()
{
this.s = new String( "aTest" );
}
public String getS()
{
return s;
}
}

Vous pouvez comparer les explications de "==" (Opérateur d'Égalité) et ".est égal à(...)" (méthode en java.lang.La classe d'objet) par le biais de ces liens:

• ==: http://docs.oracle.com/javase/tutorial/java/nutsandbolts/op2.html
• .est égal à(...): http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#equals(java.lang.Objet)

La == opérateur teste si deux variables ont la mêmes références
(aka pointeur vers une adresse de mémoire).

String foo = new String("abc");
String bar = new String("abc");
if(foo==bar)
//False (The objects are not the same)
bar = foo;
if(foo==bar)
//True (Now the objects are the same)

Alors que la equals() méthode teste si deux variables se rapportent à des objets
qui ont la même état (valeurs).

String foo = new String("abc");
String bar = new String("abc");
if(foo.equals(bar))
//True (The objects are identical but not same)

Cheers 🙂

Les deux == et .equals() fait référence à l'objet même si vous ne la supplante pas .equals().

Son votre souhait que vous voulez faire une fois que vous remplacez .equals(). Vous pouvez comparer l'invocation de l'objet d'état avec le passé dans l'objet de l'état ou vous pouvez les appeler super.equals()

 String w1 ="Sarat";
String w2 ="Sarat";
String w3 = new String("Sarat");
System.out.println(w1.hashCode());   //3254818
System.out.println(w2.hashCode());   //3254818
System.out.println(w3.hashCode());   //3254818
System.out.println(System.identityHashCode(w1)); //prints 705927765
System.out.println(System.identityHashCode(w2)); //prints 705927765
System.out.println(System.identityHashCode(w3)); //prints 366712642
if(w1==w2)   // (705927765==705927765)
{
System.out.println("true");
}
else
{
System.out.println("false");
}
//prints true
if(w2==w3)   // (705927765==366712642)
{
System.out.println("true");
}
else
{
System.out.println("false");
}
//prints false
if(w2.equals(w3))   // (Content of 705927765== Content of 366712642)
{
System.out.println("true");
}
else
{
System.out.println("false");
}
//prints true

L'opérateur==:

L' == est un opérateur relationnel en Java qui est utilisé pour comparer deux opérandes. Il est utilisé pour déterminer si les deux opérandes sont égaux ou non. À l'aide de l'opérateur==, vous pouvez comparer n'importe quel type primitif tel que int, char, float et les Booléens. Après comparaison, l'opérateur == renvoie une valeur booléenne. Si les deux opérandes sont égaux, l'opérateur == renvoie la valeur true. Cependant, si les deux opérandes ne sont pas égaux, il renvoie une valeur false.
Lorsqu'il est utilisé avec des objets, l'opérateur == compare les deux références de l'objet et détermine si elles se réfèrent à la même instance.

L' .Méthode equals ()

equals() est une méthode de la classe String qui est utilisé pour comparer deux chaînes de caractères et de déterminer si elles sont égales. Cette méthode renvoie une valeur booléenne comme un résultat de la comparaison. Si les deux chaînes contiennent les mêmes caractères dans le même ordre, la méthode equals() renvoie la valeur true. Sinon, elle renvoie la valeur false.

Lorsque vous évaluez le code, il est très clair que (==) compare en fonction de l'adresse de mémoire, tandis que equals(Object o) compare hashCode() de la instances.
C'est pourquoi il est dit de ne pas rompre le contrat entre equals() et hashCode() si vous n'avez pas face à des surprises plus tard.

    String s1 = new String("Ali");
String s2 = new String("Veli");
String s3 = new String("Ali");
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println(s3.hashCode());
System.out.println("(s1==s2):" + (s1 == s2));
System.out.println("(s1==s3):" + (s1 == s3));
System.out.println("s1.equals(s2):" + (s1.equals(s2)));
System.out.println("s1.equal(s3):" + (s1.equals(s3)));
/*Output 
96670     
3615852
96670
(s1==s2):false
(s1==s3):false
s1.equals(s2):false
s1.equal(s3):true
*/

== peut être utilisé dans de nombreux types d'objets, mais vous pouvez utiliser Object.equals pour tout type , en particulier les Chaînes et Google Marqueurs de Carte.

public class StringPool {
public static void main(String[] args) {
String s1 = "Cat";//will create reference in string pool of heap memory
String s2 = "Cat";
String s3 = new String("Cat");//will create a object in heap memory
//Using == will give us true because same reference in string pool
if (s1 == s2) {
System.out.println("true");
} else {
System.out.println("false");
}
//Using == with reference and Object will give us False
if (s1 == s3) {
System.out.println("true");
} else {
System.out.println("false");
}
//Using .equals method which refers to value
if (s1.equals(s3)) {
System.out.println("true");
} else {
System.out.println("False");
}
}
}

----Sortie-----
vrai
faux
vrai

Ici est un général de pouce de la règle de la différence entre relational operator == et the method .equals().

object1 == object2 compare si les objets référencés par l'objet1 et objet2 voir til a même emplacement de mémoire dans le Tas.

object1.equals(object2) compare les valeurs de l'objet1 et objet2, peu importe où ils sont situés dans la mémoire.

Ceci peut être illustré à l'aide de la Chaîne de

Scénario 1

 public class Conditionals {
public static void main(String[] args) {
String str1 = "Hello";
String str2 = new String("Hello");
System.out.println("is str1 == str2 ? " + (str1 == str2 ));
System.out.println("is str1.equals(str2) ? " + (str1.equals(str2 )));
}
}
The result is
is str1 == str2 ? false
is str1.equals(str2) ? true 

Scénario 2

public class Conditionals {
public static void main(String[] args) {
String str1 = "Hello";
String str2 = "Hello";
System.out.println("is str1 == str2 ? " + (str1 == str2 ));
System.out.println("is str1.equals(str2) ? " + (str1.equals(str2 )));
}
}
The result is 
is str1 == str2 ? true
is str1.equals(str2) ? true

Cette chaîne de comparaison pourrait être utilisé comme une base pour la comparaison d'autres types d'objets.

Par exemple si j'ai une Personne de la classe, j'ai besoin de définir la critères de base sur lesquels je vais comparer les deux personnes. Disons que cette personne de la classe a les variables d'instance de la taille et du poids.

Afin de créer les objets de la personne person1 and person2 et pour comparer ces deux à l'aide de la .equals() j'ai besoin de remplacer la méthode equals de la classe personne de définir, sur la base desquelles les variables d'instance(hauteur ou le poids), la comparaison sera.

Cependant, la == operator will still return results based on the memory location of the two objects(person1 and person2).

Pour la facilité de la généralisation de cette personne objet de la comparaison, j'ai créé la suite de la classe de test. L'expérimentation sur ces concepts mettent en évidence des tonnes de faits.

package com.tadtab.CS5044;
public class Person {
private double height;
private double weight;
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
long temp;
temp = Double.doubleToLongBits(height);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
/**
* This method uses the height as a means of comparing person objects.
* NOTE: weight is not part of the comparison criteria
*/
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (Double.doubleToLongBits(height) != Double.doubleToLongBits(other.height))
return false;
return true;
}
public static void main(String[] args) {
Person person1 = new Person();
person1.setHeight(5.50);
person1.setWeight(140.00);
Person person2 = new Person();
person2.setHeight(5.70);
person2.setWeight(160.00);
Person person3 = new Person();
person3 = person2;
Person person4 = new Person();
person4.setHeight(5.70);
Person person5 = new Person();
person5.setWeight(160.00);
System.out.println("is person1 == person2 ? " + (person1 == person2)); //false;
System.out.println("is person2 == person3 ? " + (person2 == person3)); //true 
//this is because perosn3 and person to refer to the one person object in memory. They are aliases;
System.out.println("is person2.equals(person3) ? " + (person2.equals(person3))); //true;
System.out.println("is person2.equals(person4) ? " + (person2.equals(person4))); //true;
//even if the person2 and person5 have the same weight, they are not equal.
//it is because their height is different
System.out.println("is person2.equals(person4) ? " + (person2.equals(person5))); //false;
}
}

Résultat de cette classe d'exécution est:

is person1 == person2 ? false
is person2 == person3 ? true
is person2.equals(person3) ? true
is person2.equals(person4) ? true
is person2.equals(person4) ? false

Fondamentalement, == compare si deux objets ont la même référence sur le tas, donc à moins de deux références sont liés à un même objet, cette comparaison sera fausse.

equals() est une méthode héritée de Object classe. Cette méthode par défaut compare si deux objets ont la même referece. Cela signifie:

object1.equals(object2) <=> object1 == object2

Cependant, si vous souhaitez établir l'égalité entre les deux objets de la même classe que vous devez remplacer cette méthode. Il est également très important de substituer la méthode hashCode() si vous avez remplacé equals().

Mettre en œuvre hashCode() lors de l'établissement de l'égalité est une partie de l'Objet Java Contrat. Si vous travaillez avec des collections, et vous n'avez pas mis en œuvre hashCode(), Étrange, de Mauvaises Choses peuvent se produire:

HashMap<Cat, String> cats = new HashMap<>();
Cat cat = new Cat("molly");
cats.put(cat, "This is a cool cat");
System.out.println(cats.get(new Cat("molly"));

null sera imprimé après l'exécution du code précédent si vous n'avez pas mis en œuvre hashCode().

En bref, la réponse est "Oui".

En Java, le == opérateur compare les deux objets pour voir s'ils pointent vers le même emplacement de mémoire; tandis que le .equals() méthode réellement compare les deux objets pour voir si elles ont la même valeur de l'objet.