关于java:Java复习包装类

8次阅读

共计 2854 个字符，预计需要花费 8 分钟才能阅读完成。

Java 中根本数据类型不是对象，然而咱们在理论利用中常常须要把根本数据转换成对象。所以 Java 在设计类时为每个根本数据类型设计了一个对应的类进行代表，这样八个和根本数据类型对应的类统称为包装类（Wrapper Class）

包装类均位于 java.lang 包中

在这八个类中，除了 Character 和 Boolean 以外，其余都是“数字型”，“数字型”都是 java.lang.Number 的子类，Number 类是抽象类，因而它的所有子类都须要实现它的形象办法。

Number 类提供了形象办法有 intValue(),longValue(),floatValue(),doubleValue(), 意味着 所有数字型包装类都能够相互转型。

1、作为和根本数据类型对应的存在，不便波及到对象的操作，如 Object[]、汇合等的操作。

2、蕴含每种根本数据类型的相干属性如最大值、最小值等，以及相干的操作方法（这些操作方法的作用是在根本数据类型、包装类对象、字符串之间提供互相的转化！）

public static void main(String[] args) {
    // 根本类型转换成 Integer 对象
    Integer int1 = new Integer(10);
    Integer int2 = Integer.valueOf(20);// 官网举荐这种写法
    //Integer 对象转换成 int
    int a = int1.intValue();
    // 字符串转换成根本数据类型
    int int3 = Integer.parseInt("333");
    // 字符串转换成 Integer 对象
    Integer int4 = new Integer("444");
    //Integer 对象转换成字符串
    String s = int4.toString();}

主动装箱和拆箱就是 将根本数据类型和包装类进行主动的相互转换。

主动装箱

根本数据类型处于须要对象的环境中时，会主动转为“对象”。

Integer i = 5 这样的语句就能实现根本数据类型转换成包装类，因为 JVM 为咱们执行了 Integer i = Integer.valueOf(5) 这样的操作，这就是 Java 的主动装箱。

主动拆箱

每当须要一个值时，对象会主动转换成根本数据类型，没必要再去显示调用 intValue()、doubleValue()的转型办法。

如 Integer i = 5; int j = i; 这样的过程就是主动拆箱。

总结：

主动装箱过程是通过调用包装类的 valueOf() 办法 实现的，而主动拆箱过程是通过调用包装类的 xxxValue() 办法 实现的。

主动装箱和拆箱的性能事实上是 编译器 来帮的忙，编译器在编译时依据所编写的语法，决定是否进行装箱或拆箱动作。

// 主动装箱
Integer i = 100;
// 相当于上面的代码
Integer i = Integer.valueOf(100);// 调用的是 valueOf(100), 而不是 new Integer(100)

// 主动拆箱
int j = i;
// 相当于上面代码
int j = i.intValue();

整形、char 类型 所对应的包装类，在主动装箱时，对于 -128~127 之间的值 会进行缓存解决，目标是提高效率。

缓存原理为：如果数据在 -128~127 这个区间，那么在类加载时就曾经为该区间的每个数值创立了对象，并将这 256 个对象寄存到一个名为 cache 的数组中。每当主动装箱产生时（或者调用 valueOf 办法时），就会先判断数据是否在该区间，如果在间接获取数组中对应的包装类对象的援用，如果不在该区间，则会通过 new 调用包装类的构造方法来创建对象。

Integer 类相干源码如下

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

1、IntegerCache 类为 Integer 类的一个动态外部类，仅供 Integer 类应用

2、个别状况下 IntegerCache.low 为 -128，IntegerCache.high 为 127, IntegerCache.cache 为外部类的一个动态属性，代码如下

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() {}
}

由下面的源码能够看到，动态代码块的目标就是初始化 cache 数组的，这个过程会在类加载时实现。

测试代码：

public class Test {public static void main(String[] args) {
        Integer int1 = 123;
        Integer int2 = 123;
        System.out.println(int1 == int2);//true，因为 123 在缓存范畴内
        System.out.println(int1.equals(int2));//true
        Integer int3 = 1234;
        Integer int4 = 1234;
        System.out.println(int3 == int4);//false，因为 1234 不在缓存范畴内
        System.out.println(int3.equals(int4));//true
    }
}

正文完