Question

我无法理解在以下代码中创建obj和obj2对象的方式的区别。特别是，我不确定如何将一个原语强制转换为一个对象。看看这里的其他一些问题，我认为这是不可能的。但是以下程序编译并运行正常。在第一种情况下，输出为假，在第二种情况下，它是真的。

public class Test {

    public static void main(String args[]){

        Integer num = new Integer(3) ;
        Object obj = num;
        Integer[] integerArr = {1, 2, 3, 4};
        Object[] objArr = integerArr;
        boolean contains = false;

        for (int i = 0; i < objArr.length; i++){
            if (objArr[i] == obj){
                contains = true;
                break;
            }
        }

        System.out.println(contains);

        int num2 = 3 ;
        Object obj2 = num2;
        Integer[] integerArr2 = {1, 2, 3, 4};
        Object[] objArr2 = integerArr2;
        boolean contains2 = false;

        for (int i = 0; i < objArr2.length; i++){
            if (objArr2[i] == obj2){
                contains2 = true;
                break;
            }
        }

        System.out.println(contains2);
    }

}

Answer 1

对象之间的==运算符测试标识（如果两个对象完全相同），而equals()方法测试相等（两个对象是否具有相同的值）。

大多数时候，你会对平等感兴趣。一个偶然的机会，您在问题中提供的示例实际上工作，因为Integer对象被缓存（通常在-127到127范围内，尽管这是可配置的），但如果您测试了使用更大数字的身份，测试很可能会失败。

例如，这将评估为true：

Integer a = 127;
Integer b = 127;
a == b // true

这将评估为false！

Integer a = 128;
Integer b = 128;
a == b // false

底线：安全地播放并始终使用equals()来测试对象之间的相等性。

Answer 2

您必须从java.lang.Integer

了解此方法

public static Integer valueOf(int i) {
    assert IntegerCache.high >= 127;
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

在第一种情况下，您创建一个新的Integer对象，而在第二种情况下，编译器通过使用缓存为您进行转换。

/**
 * Cache to support the object identity semantics of autoboxing for values between
 * -128 and 127 (inclusive) as required by JLS.
 *
 * The cache is initialized on first usage.  The size of the cache
 * may be controlled by the -XX:AutoBoxCacheMax=<size> option.
 * During VM initialization, java.lang.Integer.IntegerCache.high property
 * may be set and saved in the private system properties in the
 * sun.misc.VM class.
 */

以下是相关的字节码，了解它最终如何调用Integer构造函数或Integer.valueOf：

0: new #2; //class java/lang/Integer
3: dup
4: iconst_3
5: invokespecial #3; //Method java/lang/Integer."<init>":(I)V
8: astore_1
9: aload_1
10: astore_2
11: iconst_4
12: anewarray #2; //class java/lang/Integer
15: dup
16: iconst_0
17: iconst_1
18: invokestatic #4; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
21: aastore
...
90: iconst_3
91: istore 6
93: iload 6
95: invokestatic #4; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
98: astore 7
100: iconst_4
101: anewarray #2; //class java/lang/Integer
104: dup
105: iconst_0
106: iconst_1
107: invokestatic #4; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
110: aastore
111: dup
...

Answer 3

== 如果object1和object2是引用类型，则==检查object1和object2是否都是对同一对象的引用。

等于如果使用object1.equals（object2），则会比较对象的实际值

示例：

使用 String.equals（String other）函数来比较字符串，而不是==运算符。

该函数检查字符串的实际内容，==运算符检查对象的引用是否相等。

Answer 4

在第二种情况下，您将原始int与对象Integer数组进行比较。 JVM“展开”对象Integer并与原语进行比较..因此在这种情况下你会获得相等的匹配。

在第一种情况下，您总是将对象与另一个对象进行比较，在您的示例中，这些对象永远不会相等。

==运算符在Java中的对象

4 个答案: