Autoboxing（自动装箱）

As any Java programmer knows, you can’t put an int (or other primitive value) into a collection. Collections can only hold object references, so you have to box primitive values into the appropriate wrapper class (which is Integer in the case of int ). When you take the object out of the collection, you get the Integer that you put in; if you need an int , you must unbox the Integer using the intValue method. All of this boxing and unboxing is a pain, and clutters up your code. The autoboxing and unboxing feature automates the process, eliminating the pain and the clutter.

 

每个 Java 程序员都知道，不可能把一个 int( 或其它基本类型的值 ) 放入一个 collection 中去。集合只能存放对象的引用，所以您必须把基本类型值装箱成适合的包装类 (int 对应的包装类是 integer) 。当您想从集合中取出对象时，您获取的是您放入的 Integer ；如果您需要的是一个 int ，您就必须用 intValue 方法。装箱出箱是一件很痛苦的事情，也把代码弄得乱糟糟的。自动装箱出箱特性使这一过程变得自动化，消除这种痛苦，并可以保持代码整洁。

 

The following example illustrates autoboxing and unboxing, along with generics and the for-each loop. In a mere ten lines of code, it computes and prints an alphabetized frequency table of the words appearing on the command line.

 

下面的例子演示了自动装箱和出箱，同时也用到了范型和 for-each 循环。在仅有的十行代码中，计算并按字母顺序打印出命令行中每个单词的出现频率。

 

import java.util.*;

 

// Prints a frequency table of the words on the command line

public class Frequency {

   public static void main(String[] args) {

      Map<String, Integer> m = new TreeMap<String, Integer>();

      for (String word : args) {

          Integer freq = m.get(word);

          m.put(word, (freq == null ? 1 : freq + 1));

      }

      System.out.println(m);

   }

}

 

java Frequency if it is to be it is up to me to do the watusi

{be=1, do=1, if=1, is=2, it=2, me=1, the=1, to=3, up=1, watusi=1}

The program first declares a map from String to Integer , associating the number of times a word occurs on the command line with the word. Then it iterates over each word on the command line. For each word, it looks up the word in the map. Then it puts a revised entry for the word into the map. The line that does this (highlighted in green) contains both autoboxing and unboxing. To compute the new value to associate with the word, first it looks at the current value ( freq ). If it is null, this is the first occurrence of the word, so it puts 1 into the map. Otherwise, it adds 1 to the number of prior occurrences and puts that value into the map. But of course you cannot put an int into a map, nor can you add one to an Integer . What is really happening is this: In order to add 1 to freq , it is automatically unboxed, resulting in an expression of type int . Since both of the alternative expressions in the conditional expression are of type int , so too is the conditional expression itself. In order to put this int value into the map, it is automatically boxed into an Integer .

 

程序首先声明一个 String 到 Integer 的 map 来关联命令行中每个单词出现在次数。然后遍历每个单词。程序在 map 中查找每个单词，然后把修改过的 entry 放入 map 中。绿色高亮显示的代码既包含自动装箱又包含自动出箱。为了计算与每个单词相关联的新值，首先程序查看当前值，如果它是 null 的话，此时是该单词第一次出现的情况，在 map 中放入 1 。否则就在前次出现的次数基础上加 1 ，然后再放到 map 中去。当然，您既可能把 int 放入 map 中，也不可能把 1 加到 Integer 上去。到底发生了什么呢？为了使 freq 加 1 ，程序自动进行出箱，产生一个 int 类型的表达式。因为在条件表达式两边都是 int 类型，条件表达式自身也当然是。为了能把 int 类型值放入 map ，程序自动地把它装箱成 Integer 。

 

The result of all this magic is that you can largely ignore the distinction between int and Integer , with a few caveats. An Integer expression can have a null value. If your program tries to autounbox null, it will throw a NullPointerException . The == operator performs reference identity comparisons on Integer expressions and value equality comparisons on int expressions. Finally, there are performance costs associated with boxing and unboxing, even if it is done automatically.

 

这样您就可以忽略 int 与 Integer 间的区分，只是会有一些警告。整型可包含 null 值。如果您的程序试图把一个 null 值出箱，就会抛出一个 NullPointerException 异常。对于 Integer 类型 == 操作符进行引用的比较，而对于 int 类型，进行值的比较。最后要提一下，即使装箱出箱是自动完成的，也是有很大的性能损耗的。

 

Here is another sample program featuring autoboxing and unboxing. It is a static factory that takes an int array and returns a List of Integer backed by the array. In a mere ten lines of code this method provides the full richness of the List interface atop an int array. All changes to the list write through to the array and vice-versa. The lines that use autoboxing or unboxing are highlighted in green:

 

这里还有一个用到装箱出箱的程序。接收一个 int 类型数组并返回 Integer 类型链表。在十几行代码中，这个方法提供从数组到链表的丰富内容。绿色高亮部分是装箱出箱：

 

// List adapter for primitive int array

public static List<Integer> asList(final int[] a) {

    return new AbstractList<Integer>() {

        public Integer get(int i) { return a[i]; }

        // Throws NullPointerException if val == null

        public Integer set(int i, Integer val) {

            Integer oldVal = a[i];

            a[i] = val;

            return oldVal;

        }

        public int size() { return a.length; }

    };

}

 

The performance of the resulting list is likely to be poor, as it boxes or unboxes on every get or set operation. It is plenty fast enough for occasional use, but it would be folly to use it in a performance critical inner loop.

 

结果链表的性能可能是很差的，因为每一个 get 或 set 操作都执行了出箱或装箱。对于间歇性的使用它是足够快的，但在内循环中会严重影响性能。

 

So when should you use autoboxing and unboxing? Use them only when there is an “impedance mismatch” between reference types and primitives, for example, when you have to put numerical values into a collection. It is not appropriate to use autoboxing and unboxing for scientific computing, or other performance-sensitive numerical code. An Integer is not a substitute for an int ; autoboxing and unboxing blur the distinction between primitive types and reference types, but they do not eliminate it.

 

那什么时候该使用自动装箱和出箱呢？仅在引用类型和基本型间出现了“类型不匹配”错误时才用，例如，当您必须把一个数值型放入一个集合中去时。在使用科学计数法或其它敏感性数字代码中不宜使用自动装箱和出箱。 Integer 并不是 int 的替代品；自动装箱和出箱使基本型和引用类型间的区别变得模糊起来，但并没有消除。