包装类wrapper

• 针对八种基本数据类型定义相应的引用类型—包装类（封装类）
• 有了类的特点，就可以调用类中的方法，Java才是真正的面向对象

有了包装类以后，才能使用多态，能以多态的方式作为参数传输。

基本数据类型转换为包装类

装箱：包装类使得一个基本数据类型的数据变成了类。

基本数据类型包装成包装类的实例---装箱

通过包装类的构造器实现：

int i = 500;
Integer t = new Integer(i);

还可以通过字符串参数构造包装类对象：

Float f = new Float(“4.56”);
Long l = new Long(“asdf”);  //NumberFormatException

有了类的特点，可以调用类中的方法：

String s = f.toString();

包装类转换为基本数据类型

拆箱：将数字包装类中内容变为基本数据类型。

获得包装类对象中包装的基本类型变量---拆箱

调用包装类的.xxxValue()方法:

boolean b = bObj.booleanValue();

int j = t.intValue();

包装类不适合运算，需要转换为基本数据类型才适合运算。

自动装箱与自动拆箱

JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。

Integer i = 100;//自动装箱
Boolean b = false;//自动装箱
int num = i;//自动拆箱

注意Boolean默认为null，不是false。

基本数据类型包装类与String的相互转换

字符串转换成基本数据类型

通过包装类的构造器实现：

int i = new Integer("12");

包装类在实际开发中用的最多的在于字符串变为基本数据类型。

通过包装类的parseXxx(String s)静态方法：

Float f = Float.parseFloat("12.1");

基本数据类型转换成字符串

调用字符串重载的valueOf()方法：

String fstr= String.valueOf(2.34f);

更直接的方式：

String intStr = 5 + "";

连接字符串。

包装类常见面试题

面试题1

Object o1 = true ? new Integer(1) : new Double(2.0);
System.out.println(o1);

结果是1.0。

为什么结果不是1，编译的时候，三元运算符要求数据类型一致，整数类型自动提升为浮点型了。

面试题2

Object o2;
if (true) {
    o2 = new Integer(1);
}else{
    o2 = new Double(2.0);
}
System.out.println(o2);

结果是1。

这里没要求数据类型是一致，所以不会发生数据类型的自动提升

面试题3

Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j);//false

Integer m = 1;
Integer n = 1;
System.out.println(m == n);//true

Integer x = 128;
Integer y = 128;
System.out.println(x == y);//false

第一个是false，因为比较的引用地址。

第二个是true，第三个是false

来看看Integer源码：

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

在Integer源码中，有一个内部类IntegerCache，内部类里面有个数组，这个数组缓存了-128到127，目的是提高效率。

所以当Integer为1时，直接引用缓存中的值，两个对象的引用地址都是一样的，所以返回true，当Integer为128时，它不在缓存范围内，所以每次都要去new一个对象，两个对象的引用地址不一样，所以返回false。

总结