包装类

在实际应用中, 经常需要把基本数据类型转化为对象以便操作. 因此, Java在设计类时, 为每个基本数据类型设计了一个对应的类进行包装,

这样八个和基本数据类型对应的类统称为包装类(Wrapper Class).

包装类---------> java.lang包中

除Character和Boolean类外, 其他的都是"数字型", "数字型"都是java.lang.Number的子类. Number类是抽象类, 因此它的抽象方法都需要在其子类当中实现. Number类提供了抽象方法:intValue(), langValue(), floatValue(), doubleValue(), 意味着所有的"数字型"包装类里都可以互相转型

包装类主要用途:

1.作为和基本数据类型对应的数据类型存在, 方便设计到对象的操作, 如Object[], 集合等操作

2.包含每种基本数据类型的相关属性, 如最大值, 最小值, 以及相关的操作方法(这些操作方法的作用是在基本数据类型, 包装类对象, 字符串三者之间提供相互之间的转化方法)

/*********************其他包装类用法类似*****************************/

public class WrapperClass {

	void testInteger() {

		// 基本类型转化成Integer对象

		Integer int_1 = new Integer(10);		// JDK9之后好像过时了

		Integer int_2 = Integer.valueOf(20);	// 官方推荐写法 

		// 包装对象之间的转化

		Short int1 = int_1.shortValue();

		Double int2 = int_1.doubleValue();

		// Integer对象转化为int

		int a = int_1.intValue();

		// 字符串转化成Integer对象

		Integer int_3 = Integer.parseInt("3334");

		Integer int_4 = new Integer("99");

		// Integer对象转化成字符串

		String str_1 = int_3.toString();

		// 一些常见int类型相关的常量

		System.out.println("int能表示的最大整数: " + Integer.MAX_VALUE);

		System.out.println("int能表示的最小整数: " + Integer.MIN_VALUE);

		System.out.print("int_3: ");

		System.out.println(int_3);

		System.out.print("int_4: ");

		System.out.println(int_4);

	}

	public static void main(String[] srgs) {

		WrapperClass test = new WrapperClass();

		test.testInteger();

	}

}

/*

int能表示的最大整数: 2147483647

int能表示的最小整数: -2147483648

int_3: 3334

int_4: 99

*/

自动装/拆箱

自动装箱和拆箱就是将基本数据类型和包装类之间进行自动的互换

JDK1.5之后, Java引入自动装/拆箱

自动装箱

基本类型的数据处于需要对象的环境中时, 会自动转换为对象

Integer i = 4在JDK1.5之前是非法的, 必须使用Integer i = new Integer(4)来实现基本数据类型转换为包装对象(new方法好像过时了)

JDK1.5之后Integer i = 4是正确的, 自动执行Integer i = Integer.valueof(5)

自动拆箱

每当需要一个值是, 对象会自动转换成基本类型, 没必要再显式调用intValue(), doubleValue()等转型方法

Integer i = 4;	// 自动装箱

int j = i;		// 自动拆箱

总结

Integer i = 13;		// 自动装箱

// 相当于编译器自动执行下面语句

Integer i = Integer.valueOf(13);	// 调用的是valueOf(13), 而不是new Integer(13)

int j = i;	// 自动拆箱

// 相当于编译器自动执行下面语句

int j = i.intValue();

自动装箱通过调用包装类的xxxx.ValueOf()方法实现(xxxx代表Integer, Short等)
自动拆箱通过调用包装类的VarName.xxxxValue()方法实现(xxxx代表int, short等)

自动装/拆箱的功能实际上是通过编译器来帮忙实现的, 编译器在编译时所依据的语法, 决定是否装箱

自动装/拆箱功能就是所谓的"编译器蜜糖", 虽然使用这个功能很方便, 但在程序运行过程中需了解Java语义, 注意包装类空指针异常

/***************包装类空指针异常****************/

public static void main(String[] srgs) {

	Integer i = null; 	// 空指针

	int j = i;

}

/********************报错***********************

Exception in thread "main" java.lang.NullPointerException

	at zyb.cn.WrapperClass.main(WrapperClass.java:37)

*/

包装类的缓存

整型, char类型所对应的包装类, 在自动装箱时, 对于-128~127之间的值会进行缓存处理, 其目的是为了提高效率

缓存处理的原理: 如果数据在-128~127之间, 那么在类加载时, 就已经为该类区间的每个数值创建了对象, 并将这256个对象存放到一个名为cache数组中. 每当自动装箱过程发生时(或者手动调用valueOf()), 就会先判断数据是否在该区间内, 如果在, 则直接获取数组中对应的包装类对象的引用, 如果不在, 则会通过new调用包装类的构造方法来创建对象

/********************Integer相关源码************************/

@HotSpotIntrinsicCandidate

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为内部类的一个静态属性, 相关源码如下

*/

/********************IntegerCache相关源码************************/

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 =

            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 static void main(String[] args) {

/*

 * 缓存[-128, 127]之间的数字, 实际是系统初始的时候, 创建了[-128, 127]之间的一个缓存数组

 * 当调用valueOf()时, 首先检查是否在[-128, 127]之间, 如果在这个范围则直接从缓存数组中拿出已经建好的对象

 *如果不在这个范围, 则创建新的Integer()对象

 */

	Integer in1 = -128;

	Integer in2 = Integer.valueOf(-128);

	System.out.println(in1 == in2);	// true, 因为128在缓存内

	System.out.println(in1.equals(in2));

	System.out.println("############分隔符#############");

	Integer in3 = 1280;

	Integer in4 = 1280;

	System.out.println(in3 == in4);	// false, 因为1280不在缓存内

	System.out.println(in3.equals(in4));

}

/*

true

true

############分隔符#############

false

true

*/

巴特西

Java_包装类

包装类

自动装/拆箱

自动装箱

自动拆箱

总结

包装类的缓存

最新文章

热门文章