Java, 一杯浓浓的咖啡伴你到深夜

《Java 5.0 Tiger》Chapter 4

Chapter 4. Autoboxing and Unboxing

4.1 Converting Primitives to Wrapper Types

Integer i = 0;

Behind the scenes, primitive values are boxed. Boxing refers to the conversion from a primitive to its corresponding wrapper type: Boolean, Byte, Short, Character, Integer, Long, Float, or Double. Because this happens automatically, it's generally referred to as autoboxing.

It's also common for Java to perform a widening conversion in addition to boxing a value:

Number n = 0.0f;

Here, the literal is boxed into a Float, and then widened into a Number.

Additionally, the Java specification indicates that certain primitives are always to be boxed into the same immutable wrapper objects. These objects are then cached and reused, with the expectation that these are commonly used objects. These special values are the boolean values true and false, all byte values, short and int values between -128 and 127, and any char in the range \u0000 to \u007F.

4.2 Coverting Wrapper Types to Primitives

// Boxing
int foo = 0;
Integer integer 
= foo;

// Simple Unboxing
int bar = integer;

Integer counter 
= 1;     // boxing
int counter2 = counter;  // unboxing

...null value assignment? Since null is a legal value for an object, and therefore any wrapper type, the following code is legal:

Integer i = null;
int j = i; 

i is assigned null (which is legal), and then i is unboxed into j. However, null isn't a legal value for a primitive, so this code throws a NullPointerException.

4.3 Incrementing and Decrementing Wrapper Types

Suddenly, every operation available to a primitive should be available to its wrapper-type counterpart, and vice versa.

Integer counter = 1;
while (true{
"Iteration %d%n", counter++);
if (counter > 1000)

Remember that counter is an Integer. So the value in counter was first auto-unboxed into an int, as that's the type required for the ++ operator. Once the value is unboxed, it is incremented. Then, the new value has to be stored back in counter, which requires a boxing operation. All this in a fraction of a second!

4.4 Boolean Versus boolean

Any time you have an expression that uses !, ||, or &&, any Boolean values are unboxed to boolean primitive values, and evaluated accordingly:

        Boolean case1 = true;
        Boolean case2 
= true;
boolean case3 = false;
        Boolean result 
= (case1 || case2) && case3;

For inquiring minds, primitives are boxed up to wrapper types in equality comparisons. For operators such as <, >=, and so forth, the wrapper types are unboxed to primitive types.

Atten! object comparison?

You can't depend on the result; it's merely used as an illustration. Some JVMs may choose to try and optimize this code, and create one instance for both Integer objects, and in that case, the == operator would return a true result.

        Integer i1 = 256;
        Integer i2 
= 256;
        Integer i3 
= 100;
        Integer i4 
= 100;
== i2); // false
        System.out.println(i3 == i4); // true

If you wonder the result above, check the last paragraph in 4.1 Converting Primitives to Wrapper Types.

4.5 Conditionals and Unboxing

Ternary operator --- [conditional expression] ? [expression1] : [expression2]

[expression1] and [expression2] had to either be of the same type, or one had to be assignable to the other.

Another addition to Tiger is automatic casting of reference to their intersection type. That's a mouthful, so here's an example:

        String s = "hello";
        StringBuffer sb 
= new StringBuffer("world");
boolean mutable = true;
        CharSequence cs 
= mutable ? sb : s;

In pre-Tiger environments, this would generate an error, as sb (a StringBuffer) and s (a String) cannot be assigned to each other, unless you explicitly cast both to CharSequence.

As a side effect of this, note that two reference types (objects) always share java.lang.Object as a common ancestor, so any result of a ternary operation involving non-primitive operands can be assigned to java.lang.Object.

4.6 Control Statements and Unboxing

if/else, while, and do all are affected by Tiger's ability to unbox Boolean values to boolean values.

Another statement that benefits from unboxing is switch. In pre-Tiger JVMs, the switch statement accepts int, short, char, or byte values. With unboxing in play, you can now supply it with Integer, Short, Char, and Byte values as well, in addition to the introduction of enums.

4.7 Method Overload Resolution

In Tiger, method resolution is a three-pass process:

  1. The compiler attempts to locate the correct method without any boxing, unboxing, or vararg invocations. This will find any method that would have been invoked under Java 1.4 rules.

  2. If the first pass fails, the compiler tries method resolution again, this time allowing boxing and unboxing conversions. Methods with varargs are not considered in this pass.

  3. If the second pass fails, the compiler tries method resolution one last time, allowing boxing and unboxing, and also considers vararg methods.

These rules ensure that consistency with pre-Tiger environments is maintained.

posted on 2005-12-31 17:17 Scott@JAVA 阅读(413) 评论(0)  编辑  收藏 所属分类: Java 5.0 Tiger