==和之间的差异。Java中的equals（）方法-yiteyi-C++库

equals（）方法和==运算符都用于比较Java中的两个对象是运算符，equals（）是方法。但是==运算符比较堆中对象的引用或内存位置，无论它们是否指向同一位置。每当我们使用new操作符创建一个对象时，它都会为该对象创建一个新的内存位置。所以我们使用==运算符来检查两个对象的内存位置或地址是否相同。

null

一般来说，Java中的equals（）和“==”运算符都用于比较对象以检查相等性，但这两者之间有一些区别：

两者之间的主要区别。equals（）方法和==运算符是一个是方法，另一个是运算符。
我们可以使用==运算符进行引用比较( 地址比较 )还有。函数的equals（）方法 内容比较 .简单地说，==检查两个对象是否指向同一个内存位置。equals（）计算对象中值的比较。
如果一个类没有重写equals方法，则默认情况下，它使用已重写此方法的最近父类的equals（Object o）方法。看见为什么要重写equals（Object）和hashCode（）方法？详细地

JAVA

                         // Java program to understand                       
                         // the concept of == operator                       
           
                         public                                     class                                     Test {                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 String s1 =                                     "HELLO"                                     ;                       
                                                 String s2 =                                     "HELLO"                                     ;                       
                                                 String s3 =                                     new                                     String(                                     "HELLO"                                     );                       
           
                                                 System.out.println(s1 == s2);                                     // true                       
                                                 System.out.println(s1 == s3);                                     // false                       
                                                 System.out.println(s1.equals(s2));                                     // true                       
                                                 System.out.println(s1.equals(s3));                                     // true                       
                                                 }                       
                         }                       

输出

truefalsetruetrue

说明： 在这里，我们创建两个对象，即s1和s2。

s1和s2都指相同的对象。
当我们使用==运算符进行s1和s2比较时，结果为真，因为两者在字符串常量池中具有相同的地址。
使用equals，结果是真的，因为它只比较s1和s2中给出的值。

Java字符串池

s1=“你好”

s2=“你好”

Java堆

s3=“你好”

让我们详细了解这两个运营商：

相等运算符（=）

我们可以对每种基本类型应用相等运算符，包括布尔类型。我们还可以对对象类型应用相等运算符。

JAVA

                         // Java program to illustrate                       
                         // == operator for compatible data                       
                         // types                       
           
                         class                                     Test {                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 // integer-type                       
                                                 System.out.println(                                     10                                     ==                                     20                                     );                       
           
                                                 // char-type                       
                                                 System.out.println(                                     'a'                                     ==                                     'b'                                     );                       
           
                                                 // char and double type                       
                                                 System.out.println(                                     'a'                                     ==                                     97.0                                     );                       
           
                                                 // boolean type                       
                                                 System.out.println(                                     true                                     ==                                     true                                     );                       
                                                 }                       
                         }                       

输出

falsefalsetruetrue

如果我们对对象类型应用==那么 应该是参数类型之间的兼容性 （子对象到父对象或父对象到子对象或相同类型）。否则，我们将得到一个编译时错误。

JAVA

                           // Java program to illustrate                         
                           // == operator for incompatible data types                         
            
                           class                                        Test {                         
                                                     public                                        static                                        void                                        main(String[] args)                         
                                                     {                         
                                                     Thread t =                                        new                                        Thread();                         
                                                     Object o =                                        new                                        Object();                         
                                                     String s =                                        new                                        String(                                        "GEEKS"                                        );                         
            
                                                     System.out.println(t == o);                         
                                                     System.out.println(o == s);                         
            
                                                     // Uncomment to see error                         
                                                     System.out.println(t==s);                         
                                                     }                         
                           }                         

输出：

falsefalse// error: incomparable types: Thread and String

.equals（）方法

在Java中，String equals（）方法根据字符串的数据/内容比较两个给定的字符串。如果两个字符串的所有内容都相同，则返回true。如果所有字符都不匹配，则返回false。

JAVA

                         public                                     class                                     Test {                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 Thread t1 =                                     new                                     Thread();                       
                                                 Thread t2 =                                     new                                     Thread();                       
                                                 Thread t3 = t1;                       
           
                                                 String s1 =                                     new                                     String(                                     "GEEKS"                                     );                       
                                                 String s2 =                                     new                                     String(                                     "GEEKS"                                     );                       
           
                                                 System.out.println(t1 == t3);                       
                                                 System.out.println(t1 == t2);                       
                                                 System.out.println(s1 == s2);                       
           
                                                 System.out.println(t1.equals(t2));                       
                                                 System.out.println(s1.equals(s2));                       
                                                 }                       
                         }                       

输出

truefalsefalsefalsetrue

说明： 这里，我们使用的是。equals方法检查两个对象是否包含相同的数据。

在上面的示例中，我们创建了3个线程对象和2个字符串对象。
在第一次比较中，我们检查t1==t3。我们都知道 t1和t3指向 同一个物体 .这就是为什么它会变成真的。
在第二个比较中，我们使用运算符“==”来比较字符串对象，而不是对象的内容。在这里，两个对象是不同的，因此这种比较的结果是“错误的”
当我们比较两个字符串对象时。equals（）运算符，然后我们检查两个对象是否包含相同的数据。
这两个对象都包含相同的字符串，即极客。这就是为什么它会变成真的。

本文由 Veturi Lakshmi Prathyusha .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java