java包装_Java_包装类

包装类

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

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

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

|:-----:|:-----:|

| 基本数据类型 | 包装类 |

| byte | Byte |

| boolean | Boolean |

| short | Short |

| char | Character |

| int | Int |

| long | Long |

| float | Float |

| double | Double |

除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

*/