Java'da == ve equals () arasındaki fark nedir?

Bunu doğru anladıysam açıklığa kavuşturmak istedim:

• == bir referans karşılaştırmasıdır, yani her iki nesne de aynı bellek konumuna işaret eder
• .equals() nesnelerdeki değerlerin karşılaştırılmasını değerlendirir

Genel olarak, sorunuzun cevabı "evet" dir, ancak ...

• .equals(...) sadece karşılaştırmak için yazılanları karşılaştırır, daha fazla, daha az değil.
• Bir sınıf eşittir yöntemini geçersiz kılmazsa, varsayılan olarak bu equals(Object o)yöntemi geçersiz kılan en yakın üst sınıf yöntemini kullanır.
• Hiçbir üst sınıf geçersiz kılma sağlamadıysa, varsayılan olarak üst üst sınıf olan Object öğesinden yönteme geçer ve böylece Object#equals(Object o)yöntemden ayrılırsınız. Object API'sine göre bu ==; başka bir deyişle, yalnızca her iki değişken de aynı nesneye başvuruyorsa, başvuruları bir ve aynı ise true değerini döndürür . Böylece, işlevsel eşitlik için değil , nesne eşitliği için test yapacaksınız .
• "Sözleşmeyi bozmamak" için geçersiz kılmanız hashCodedurumunda her zaman geçersiz kılmayı unutmayın equals. API'ye göre, hashCode()iki nesne için yöntemden döndürülen sonuç , yöntemleri eşdeğer olduklarını gösteriyorsa aynı olmalıdırequals . Bunun tersi doğru olmayabilir .

String sınıfıyla ilgili olarak:

Equals () yöntemi , iki nesne başvurusunun aynı String örneğine başvurup başvurmadığından bağımsız olarak, String örnekleri içindeki (yığın üzerinde) "value" değerini karşılaştırır. String türünden herhangi iki nesne başvurusu aynı String örneğine başvuruyorsa great! İki nesne başvurusu iki farklı String örneğine başvuruyorsa .. fark etmez. Karşılaştırılan her String örneğindeki "değer" (yani: karakter dizisinin içeriği).

Öte yandan, "==" işleci , aynı String örneğine gönderme yapıp yapmadığını görmek için iki nesne başvurusunun değerini karşılaştırır . Her iki nesne başvurusunun değeri de aynı String örneğine "başvuruyorsa", boole ifadesinin sonucu "true" olur. Duh. Öte yandan, her iki nesne başvurusunun değeri " farklı String örnekleri " (her iki String örneği aynı "değerlere sahip olsa da, yani her String örneğinin karakter dizilerinin içeriği aynı olsa da) boole ifadesinin sonucu "yanlış" olur.

Herhangi bir açıklamada olduğu gibi içeri girmesine izin verin.

Umarım bu biraz şeyleri temizler.

"İlkel" veya "Nesne Türleri" hakkında konuşmanıza bağlı olarak bazı küçük farklılıklar vardır; "statik" veya "statik olmayan" üyelerden bahsediyorsanız aynı şey söylenebilir; Yukarıdakilerin tümünü de karıştırabilirsiniz ...

İşte bir örnek (çalıştırabilirsiniz):

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

}

"==" (Eşitlik İşleci) ve ".equals (...)" (java.lang.Object sınıfındaki yöntem) ile ilgili açıklamaları şu bağlantılarla karşılaştırabilirsiniz:

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

== ve eşittir arasındaki fark, daha yakından bakmaya karar verene kadar beni bir süre karıştırdı. Birçoğu dize karşılaştırmak için kullandığınız gerektiğini söylemek equalsdeğil ==. Umarım bu cevapta farkı söyleyebilirim.

Bu soruyu cevaplamanın en iyi yolu kendinize birkaç soru sormak olacaktır. Haydi başlayalım:

Aşağıdaki programın çıktısı nedir:

String mango = "mango";
String mango2 = "mango";
System.out.println(mango != mango2);
System.out.println(mango == mango2);

Eğer öyle diyorsan,

false
true

Ben söyleyene olacak doğru ama bunu neden söyledim ? ve çıktı olduğunu söylerseniz,

true
false

Yanlış olduğunu söyleyeceğim ama sana hala soracağım, bunun neden doğru olduğunu düşünüyorsun?

Tamam, buna cevap vermeye çalışalım:

Aşağıdaki programın çıktısı nedir:

String mango = "mango";
String mango3 = new String("mango");
System.out.println(mango != mango3);
System.out.println(mango == mango3);

Şimdi derseniz,

false
true

Yanlış olduğunu söyleyeceğim ama neden şimdi yanlış ? bu program için doğru çıktı

true
false

Lütfen yukarıdaki programı karşılaştırın ve düşünmeye çalışın.

Tamam. Şimdi bu yardımcı olabilir (lütfen bunu okuyun: nesnenin adresini yazdırın - mümkün değil ama yine de kullanabiliriz.)

String mango = "mango";
String mango2 = "mango";
String mango3 = new String("mango");
System.out.println(mango != mango2);
System.out.println(mango == mango2);
System.out.println(mango3 != mango2);
System.out.println(mango3 == mango2);
// mango2 = "mang";
System.out.println(mango+" "+ mango2);
System.out.println(mango != mango2);
System.out.println(mango == mango2);

System.out.println(System.identityHashCode(mango));
System.out.println(System.identityHashCode(mango2));
System.out.println(System.identityHashCode(mango3));

sadece yukarıdaki koddaki son üç satırın çıktısını düşünmeye çalışabilirsiniz: benim için ideone bunu yazdırdı ( kodu buradan kontrol edebilirsiniz ):

false
true
true
false
mango mango
false
true
17225372
17225372
5433634

Ah! Şimdi, IdentityHashCode (mango) kimliğine eşit olduğunu görüyorsunuzHashCode (mango2) Ama identityHashCode (mango3) ile aynı değil

Tüm dize değişkenleri - mango, mango2 ve mango3 - aynı değere sahip olsa da, "mango" identityHashCode()olan herkes için hala aynı değildir.

Şimdi bu satırı açmaya çalışın // mango2 = "mang";ve bu sefer tekrar çalıştırın, üçünün identityHashCode()de farklı olduğunu göreceksiniz . Hmm bu yararlı bir ipucu

biliyoruz ki hashcode(x)=Nve hashcode(y)=N=>x is equal to y

Java'nın dahili olarak nasıl çalıştığından emin değilim ama şunu söylediğimde bu olduğunu varsayıyorum:

mango = "mango";

java "mango", değişken tarafından mangoböyle bir şey tarafından işaret edilen (başvurulan) bir dize oluşturdu

mango ----> "mango"

Şimdi bir sonraki satırda dedim ki:

mango2 = "mango";

Aslında "mango"böyle bir şeye benzeyen aynı dizeyi tekrar kullandı

mango ----> "mango" <---- mango2

Hem mango hem de mango2 aynı referansı gösteriyor Şimdi söylediğimde

mango3 = new String("mango")

Aslında "mango" için tamamen yeni bir referans (string) yarattı. böyle bir şeye benziyor,

mango -----> "mango" <------ mango2

mango3 ------> "mango"

ve bu yüzden değerlerini mango == mango2ortaya koyduğumda ortaya çıktı true. ve değerini verdiğimde ortaya mango3 == mango2koydu false(değerler aynı olsa bile).

Ve çizgi uncommented zaman // mango2 = "mang"; Aslında bizim grafik böyle döndü bir "mang" dizesi yarattı:

mango ---->"mango"
mango2 ----> "mang"
mango3 -----> "mango"

Bu yüzden identityHashCode herkes için aynı değildir.

Umarım bu size yardımcı olur. Aslında, == başarısız ve equals () geçtiği bir test senaryosu oluşturmak istedim. Lütfen yorum yapmaktan çekinmeyin ve yanılıyorsam bana bildirin.

== iki değişken olup operatör testleri sahiptir (bir hafıza adresine işaretçi olarak da bilinir), aynı referans .

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)

Equals () yöntemi ise iki değişkenin aynı duruma (değerlere) sahip nesnelere karşılık gelip gelmediğini test eder .

String foo = new String("abc");
String bar = new String("abc");

if(foo.equals(bar))
// True (The objects are identical but not same)

Şerefe :-)

Özel sınıflarla kullanmak için eşittir işlevini (diğerleriyle birlikte) geçersiz kılmanız gerekir.

Equals yöntemi nesneleri karşılaştırır.

==İkili operatör bellek adreslerini karşılaştırır.

.Equals () öğesini geçersiz kılmazsanız, hem == hem de .equals () aynı nesneyi belirtir.

Bu .equals () değerini geçersiz kıldığınızda yapmak istediğiniz şeydir. Çağıran nesnenin durumunu, iletilen nesnenin durumuyla karşılaştırabilir veya yalnızca super.equals () yöntemini çağırabilirsiniz.

==bir operatör ve equals()bir yöntemdir .

Operatörler genellikle ilkel tip karşılaştırmalar ==için kullanılır ve bu nedenle bellek adres karşılaştırması equals()için kullanılır ve nesneleri karşılaştırmak için yöntem kullanılır .

 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

Bunun .equals(...), karşılaştırmaya çalıştığınız sınıf tarafından uygulanması gerektiğini unutmayın . Aksi takdirde, pek bir anlamı yoktur; Object sınıfı yönteminin sürümü karşılaştırma işlemiyle aynı şeyi yapar: Object # eşittir .

Nesneler için karşılaştırma işlecini gerçekten kullanmak istediğiniz tek şey, Numaralandırmaları karşılaştırdığınız zamandır. Bunun nedeni, aynı anda bir Enum değerinin yalnızca bir örneğinin olmasıdır. Örneğin, numaralandırma göz önüne alındığında

enum FooEnum {A, B, C}

Birden fazla örneğini zorunda kalmayacaksınız Abir anda ve aynı Bve C. Bu, aslında şöyle bir yöntem yazabileceğiniz anlamına gelir:

public boolean compareFoos(FooEnum x, FooEnum y)
{
    return (x == y);
}

Ve hiçbir sorun yaşamayacaksınız.

Kodu değerlendirdiğinizde, (==) öğesinin bellek adresine göre karşılaştırdığı açıktır; eşittir (Object o) ise örneklerin hashCode () yöntemini karşılaştırır. Bu nedenle, daha sonra sürprizlerle karşılaşmazsanız equals () ve hashCode () arasındaki sözleşmeyi bozmadığı söylenir.

    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
    */

İşte relational operator ==ve arasındaki fark için genel bir kural the method .equals().

object1 == object2object1 ve object2 tarafından başvurulan nesnelerin Yığın'da aynı bellek konumuna başvurup başvurmadığını karşılaştırır .

object1.equals(object2)bellekte nerede bulunduklarına bakılmaksızın object1 ve object2 değerlerini karşılaştırır .

Bu, String kullanılarak iyi gösterilebilir

Senaryo 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 

Senaryo 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

Bu dize karşılaştırması, diğer nesne türlerini karşılaştırmak için bir temel olarak kullanılabilir.

Örneğin, eğer bir Person sınıfım varsa , iki kişiyi karşılaştıracağım kriter tabanını tanımlamam gerekir . Diyelim ki bu kişi sınıfı boy ve kilo örnek değişkenlerine sahip.

Kişi nesneleri oluşturmak person1 and person2ve bu iki karşılaştırmak için person sınıf eşittir yöntemini.equals() geçersiz kılmak gerekir hangi örnek değişkenleri (yükseklik veya ağırlık) dayalı tanımlamak karşılaştırmak için.

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

Bu kişinin nesne karşılaştırmasını genelleme kolaylığı için, aşağıdaki test sınıfını oluşturdum. Bu kavramları denemek tonlarca gerçeği ortaya çıkaracaktır .

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

}

Bu sınıf uygulamasının sonucu:

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

Ayrıca , iki nesnenin eşit olup olmadığını test etmek isteyip istemediğinizi test etmek istediğiniz ilk şey olduğu için .equals()normalde ==test için içerdiğini unutmayın .

Ve ==aslında ilkel tiplerin değerlerine bakar, nesneler için referansı kontrol eder.

== operatör her zaman referans karşılaştırılır. Ancak

equals () yöntemi

geçersiz kılma yöntemine göre geçersiz kılınmış olmamız, geçersiz kılınan yöntemde verilen temel uygulama nesnesini karşılaştırmaya göre değişir.

 class A
 {
   int id;
   String str;

     public A(int id,String str)
     {
       this.id=id;
       this.str=str;
     }

    public static void main(String arg[])
    {
      A obj=new A(101,"sam");
      A obj1=new A(101,"sam");

      obj.equals(obj1)//fasle
      obj==obj1 // fasle
    }
 }

yukarıdaki kodda hem obj hem de obj1 nesnesi aynı verileri içerir, ancak başvuru aynı değildir, bu nedenle eşittir return false ve ==. ama eşittir yöntemine göre

 class A
 {
   int id;
   String str;

     public A(int id,String str)
     {
       this.id=id;
       this.str=str;
     }
    public boolean equals(Object obj)
    {
       A a1=(A)obj;
      return this.id==a1.id;
    }

    public static void main(String arg[])
    {
      A obj=new A(101,"sam");
      A obj1=new A(101,"sam");

      obj.equals(obj1)//true
      obj==obj1 // fasle
    }
 }

biliyorum biz sadece geçersiz kılındı ​​aynı durumda doğru ve yanlış dönecektir

eşittir yöntemi.

nesnenin temel içeriği (id) üzerindeki nesneyi karşılaştırır

ama ==

hala nesnenin referanslarını karşılaştırır.

== ve equals () arasındaki en büyük fark

1) == ilkelleri karşılaştırmak için kullanılır.

Örneğin :

        String string1 = "Ravi";
        String string2 = "Ravi";
        String string3 = new String("Ravi");
        String string4 = new String("Prakash");

        System.out.println(string1 == string2); // true because same reference in string pool
        System.out.println(string1 == string3); // false

2) eşittir () nesneleri karşılaştırmak için kullanılır. Örneğin :

        System.out.println(string1.equals(string2)); // true equals() comparison of values in the objects
        System.out.println(string1.equals(string3)); // true
        System.out.println(string1.equals(string4)); // false

==birçok nesne türünde kullanılabilir, ancak Object.equalsözellikle Dizeler ve Google Harita İşaretçileri olmak üzere her tür için kullanabilirsiniz .

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

    }
  }

---- Çıktı ----- doğru yanlış doğru

İlkel tipler için sarma nesneleri için - örneğin Int, Long, Double - ==, iki değer eşitse true değerini döndürür.

Long a = 10L;
Long b = 10L;

if (a == b) {
    System.out.println("Wrapped primitives behave like values");
}

Buna karşılık, yukarıdaki iki Uzunluğu iki ayrı ArrayListe koymak, eşittir onları aynı görür, ancak == yapmaz.

ArrayList<Long> c = new ArrayList<>();
ArrayList<Long> d = new ArrayList<>();

c.add(a);
d.add(b);
if (c == d) System.out.println("No way!");
if (c.equals(d)) System.out.println("Yes, this is true.");

Dize havuzu (aka interning ) ve tamsayı havuz bulanıklık daha da fark ve kullanmak için izin verebilir ==bazı durumlarda nesneler için yerine.equals

Bu size daha fazla karmaşıklık pahasına daha yüksek performans (?) Verebilir.

Örneğin:

assert "ab" == "a" + "b";

Integer i = 1;
Integer j = i;
assert i == j;

Karmaşıklık dengesi: aşağıdakiler sizi şaşırtabilir:

assert new String("a") != new String("a");

Integer i = 128;
Integer j = 128;
assert i != j;

Bu tür mikro optimizasyondan uzak durmanızı ve her zaman.equals nesneler ve ==ilkel öğeler için kullanmanızı tavsiye ederim :

assert (new String("a")).equals(new String("a"));

Integer i = 128;
Integer j = 128;
assert i.equals(j);

Kısacası, cevap "Evet".

Java'da, ==operatör iki nesneyi aynı bellek konumuna işaret edip etmediklerini karşılaştırır; ise .equals()yöntem, aslında iki nesne karşılaştırır aynı nesne değerine sahip olup olmadığını görmek için.

Temel olarak, ==iki nesne öbek üzerinde aynı referansa sahipse karşılaştırır, bu nedenle iki referans aynı nesneye bağlı değilse, bu karşılaştırma yanlış olur.

equals()Objectsınıftan miras alınan bir yöntemdir . Bu yöntem, varsayılan olarak iki nesnenin aynı referansa sahip olup olmadığını karşılaştırır. Anlamı:

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

Ancak, aynı sınıftaki iki nesne arasında eşitlik oluşturmak istiyorsanız bu yöntemi geçersiz kılmalısınız. Yöntemi geçersiz kılmak için de çok önemli hashCode()sen overriden varsaequals() .

Uygulamak hashCode()eşitliğinin oluşturulması Java nesne sözleşmenin parçası olduğunda. Koleksiyonlarla çalışıyorsanız ve uygulamadıysanız hashCode(), Garip Kötü Şeyler olabilir:

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"));

nulluygulamadıysanız önceki kod yürütüldükten sonra yazdırılır hashCode().

Java, operatörün aşırı yüklenmesini desteklemediğinden, == her nesne için özdeş davranır ancak Java'da geçersiz kılınabilen ve nesneleri karşılaştırmak için mantık iş kurallarına göre değiştirilebilir.

Java'da == ve eşittir arasındaki temel fark, ilkelleri karşılaştırmak için "==" kullanılması, nesnelerin eşitliğini kontrol etmek için equals () yönteminin kullanılmasıdır.

Dize karşılaştırması, == ve eşittir yöntemini kullanmanın yaygın bir senaryosudur. Java.lang.String sınıfı geçersiz kılma yöntemi eşittir, İki String nesnesi aynı içeriği içeriyorsa true değerini döndürür, ancak == yalnızca iki başvuru aynı nesneye işaret ediyorsa true değerini döndürür.

Java'daki iki Dizeyi eşitlik açısından karşılaştırarak bazı şüpheleri giderecek == ve equals () yöntemini kullanarak bir örnek :

public class TEstT{

    public static void main(String[] args) {

String text1 = new String("apple");
String text2 = new String("apple");

//since two strings are different object result should be false
boolean result = text1 == text2;
System.out.println("Comparing two strings with == operator: " + result);

//since strings contains same content , equals() should return true
result = text1.equals(text2);
System.out.println("Comparing two Strings with same content using equals method: " + result);

text2 = text1;
//since both text2 and text1d reference variable are pointing to same object
//"==" should return true
result = (text1 == text2);
System.out.println("Comparing two reference pointing to same String with == operator: " + result);

}
}