String池(又名实习池)和Integer池进一步模糊了区别，并允许您在某些情况下对对象使用==而不是.equals

这可以为您提供更好的性能(?)，但代价是更大的复杂性。

例如:

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

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

复杂性权衡:以下内容可能会让你大吃一惊:

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

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

我建议你远离这样的微观优化，总是用.equals表示对象，用==表示原语:

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

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

根据你谈论的是“原语”还是“对象类型”，有一些小的区别;如果你在谈论“静态”或“非静态”成员，也可以这样说;你也可以混合上面所有的…

下面是一个例子(你可以运行它):

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

}

您可以比较“==”(相等运算符)和“.equals(…)”的解释。(java.lang.Object类中的方法)通过以下链接:

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

简而言之，答案是肯定的。

在Java中，==操作符比较两个对象，以确定它们是否指向相同的内存位置;而.equals()方法实际上是比较两个对象，看看它们是否具有相同的对象值。

由于Java不支持操作符重载，==的行为是相同的 除equals()外的每个对象都可以使用is方法，该方法可以在 可以根据业务更改用于比较对象的Java和逻辑 规则。

在Java中==和=的主要区别是“==”被用来 建议检查equals()方法时比较原语 对象相等。

字符串比较是同时使用==和equals()方法的常见场景。由于java.lang.String类重写等于方法，它 如果两个String对象包含相同的内容，但== will返回true 只有当两个引用指向同一个对象时才返回true。

下面是一个使用==和equals()方法比较Java中两个string是否相等的例子，这将消除一些疑问:

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

    }
    }

Equals()方法主要比较对象的原始内容。

如果我们写作

    String s1 = "Samim";
    String s2 = "Samim";
    String s3 = new String("Samim");
    String s4 = new String("Samim");

    System.out.println(s1.equals(s2));
    System.out.println(s2.equals(s3));
    System.out.println(s3.equals(s4));

输出将是

true 
true 
true

因为equals()方法比较对象的内容。 在first System.out.println()中，s1和s2的内容是相同的，这就是为什么它打印为真。 另外两个System.out.println()为真。

再一次,

    String s1 = "Samim";
    String s2 = "Samim";
    String s3 = new String("Samim");
    String s4 = new String("Samim");
    
    System.out.println(s1 == s2);
    System.out.println(s2 == s3);
    System.out.println(s3 == s4);

输出将是

true
false 
false

因为==运算符主要比较对象的引用，而不是对象的值。 在first System.out.println()中，s1和s2的引用是相同的，这就是为什么它返回true。

在第二个System.out.println()中，创建了s3对象，这就是为什么会创建另一个s3的引用，并且s2和s3的引用会有所不同，因此它返回“false”。

Third System.out.println()，遵循second System.out.println()的规则，这就是为什么它会返回"false"。

只需记住.equals(…)必须由您试图比较的类实现。否则，就没有什么意义了;Object类的方法版本所做的事情与比较操作相同:

唯一需要对对象使用比较运算符的时候是比较枚举的时候。这是因为一次只有一个Enum值的实例。例如，给定枚举

enum FooEnum {A, B, C}

你永远不会同时拥有一个以上的A实例，对于B和c也是如此。这意味着你实际上可以像这样编写一个方法:

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

你就不会有任何问题了。