在Java中，运算符是否对原始类型和原始包装器类执行相同的操作？

Question

As we all know, primitives in java have mathematical and logical operators you can use on them. My question is does the same operational logic apply to their cousins, the primitive wrapper class.

Integer a = new Integer(2);
Integer b = new Integer(2);

Integer c = a * b;  //Does c.integerValue() returns 4?
boolean d = a == b; //Is d true? 
Integer e = a | c;  //Does e.integerValue() return 6?
Integer f = c % a;  //Does f.integerValue() return 0?
a++;                //Does a.integerValue() return 3?

Will all operators perform identically on primitive types and primitive wrapper classes? If not, what subset of operators work on both primitives and their Object wrappers?

Answer 1

Equality operators ( == and != ) are not reliable when working with wrapper classes.

First, generally they compare object references, not object values. For example:

Integer a = new Integer(24);
Integer b = new Integer(24);
System.out.println(a == b); // Prints false
System.out.println(a != b); // Prints true

Second, how the wrapper class is created matters, for example:

Integer a = 24;
Integer b = 24;
System.out.println(a == b); // Prints true
System.out.println(a != b); // Prints false

In this case, when unboxed, Integer uses Integer.valueOf that in turn uses a cache ( IntegerCache ) for numbers between -128 and 127. That implementation is responsible for this weird behavior.

Actually, the implementation of the IntegerCache class allows the upper bound to be configurable via the property java.lang.Integer.IntegerCache.high when you run your program.

This applies to Long also.

Lesson learned, you better use the equals() method with wrappers.

The rest of the operators should work because the value in the object is autoboxed before the operator is applied.

Answer 2

No, in particular == and != compare references.

This means that new Integer(1) != new Integer(1)

All other operations are basically the same.

Answer 3

In addition to above given answer I would like to add the following: Be careful when you do math operations on wrapped types. Because you can get NullPointerException . Consider this example:

    Double a = 5.0;
    Double b = null;

    System.out.println(a + b);