Java基础教程——包装类

Java出道之时，自诩为“纯面向对象的语言”，意思是之前的所谓“面向对象语言”不纯。
但是，有人指责Java也不纯——8种基本类型并非类类型。为此，Java为他们提供可对应的类类型，是为“包装类”。

包装类

Java的八种基本数据类型用起来很方便，但不支持面向对象的编程机制，不属于Object继承体系，没有成员方法可调用。某些场合下，只能使用对象类型，不能使用基本类型，因此基本类型需要对应的包装类。

比如集合的定义：List<Integer> list;
写为List<int> list;就错了

Java提供了基本类型对应的包装类（Wrapper Class）：

包装类一般就是把基本类型的首字母小写变为大写，但是int和char除外，它们的包装类要用全称。
下表中将int和char的写法加粗。

基本类型	包装类
byte	Byte
int	Integer
short	Short
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

另有一种说法，说Java中有9种基本类型，还要加一个void，其包装类是Void，但这种说法没有被普遍接受。

装箱和拆箱的概念

基本类型→（转为）→包装类，是为装箱
包装类→（转为）→基本类型，是为拆箱

JDK 1.5开始就提供了自动装箱、自动拆箱功能。借助该功能，开发者可以把基本类型当做对象使用，也可以把包装类的实例当做基本类型变量使用。

public class Test包装类 {public static void main(String[] args) {int a1 = 1000;// 定义基本类型Integer objA = a1; // 自动装箱:Integer←intint a2 = objA; // 自动拆箱:int←IntegerSystem.out.println(a2);}
}

上述代码的解析：
| | int a1 = 1000; | | |
| -------- | -------------------------- | ----------- | -------------------------------- |
| 自动装箱 | Integer objA =a1; | Integer←int | 本质上调用了Integer.valueOf(...) |
| 自动拆箱 | int a2 = objA; | int←Integer | 本质上调用了objA.intValue() |

包装类可以通过new实例化来构造
除Character类外，其它的包装类都有parseXxx方法：字符串→基本数据类型值
包装类有valueOf方法：字符串→包装类对象

示例代码（比较枯燥，瞅一眼就行）：

public class Test构造包装类 {public static void main(String[] args) {构造包装类();parseXxx_str_to_基本类型();valueOf_str_to_Wrapper();}static void 构造包装类() {System.out.println("---new 包装类---");Boolean objBool = new Boolean(true);Character objChar = new Character('X');Byte objByte = new Byte((byte) 10);Short objS = new Short((short) 50);Integer objInt = new Integer(100);Long objLong = new Long(1000);Float objF = new Float(3.14);Double objD = new Double(3.1415);System.out.println(objBool);System.out.println(objChar);System.out.println(objByte);System.out.println(objS);System.out.println(objInt);System.out.println(objLong);System.out.println(objF);System.out.println(objD);}static void parseXxx_str_to_基本类型() {String str = "123";System.out.println("---除Character类外，包装类都有parseXxx方法");System.out.println("---parseXxx：字符串→基本数据类型值");byte b = Byte.parseByte(str);short s = Short.parseShort(str);int i = Integer.parseInt(str);long l = Long.parseLong(str);float f = Float.parseFloat(str);double d = Double.parseDouble(str);boolean bl = Boolean.parseBoolean("TruE");System.out.println(i);System.out.println(s);System.out.println(b);System.out.println(l);System.out.println(f);System.out.println(d);System.out.println(bl);}static void valueOf_str_to_Wrapper() {String str = "123";System.out.println("---valueOf方法：字符串→包装类对象");Byte objByte = Byte.valueOf(str);Short objShort = Short.valueOf(str);Integer objInt = Integer.valueOf(str);Long objLong = Long.valueOf(str);Float objF = Float.valueOf(str);Double objD = Double.valueOf(str);Boolean objB = Boolean.valueOf("true");Character obkChar = Character.valueOf('C');System.out.println(objByte);System.out.println(objShort);System.out.println(objInt);System.out.println(objLong);System.out.println(objF);System.out.println(objD);System.out.println(obkChar);System.out.println(objB);}
}

Java中100等于100,1000不等于1000

public class Java1000 {public static void main(String[] args) {Integer a1 = 100;Integer a2 = 100;System.out.println(a1 + "==" + a2 + ":" + (a1 == a2));a1 = 1000;a2 = 1000;System.out.println(a1 + "==" + a2 + ":" + (a1 == a2));}
}

100==100:true
1000==1000:false

---

原因：JDK源码的Integer类中，将-128~127做了缓存处理。
看看这段缓存：

package java.lang;
……
public final class Integer extends Number implements Comparable<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 propertyint h = 127;……high = h;……// range [-128, 127] must be interned (JLS7 5.1.7)assert IntegerCache.high >= 127;}private IntegerCache() {}}……
}

改改这段缓存：（看懂大概即可）

import java.lang.reflect.Field;
import java.util.Arrays;
public class TestInteger {public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {// 说明：IntegerCache是Integer中的一个内部类// 源码：private static class IntegerCache{...}// 1.取出Integer中定义的内部类(包括公共、私有、保护)Class<?>[] classes = Integer.class.getDeclaredClasses();System.out.println("Class数组：" + Arrays.toString(classes));Class<?> classCache = classes[0];System.out.println("IntegerCache:" + classCache);// 2.取成员变量：cache// 源码：static final Integer cache[];Field fieldCache = classCache.getDeclaredField("cache");System.out.println("Integer cache[]：" + fieldCache);fieldCache.setAccessible(true);// 3.取出cache的值// field.get(obj):返回指定对象上由此Field表示的字段的值Integer[] newCache = (Integer[]) fieldCache.get(classCache);System.out.println("Integer[]:" + Arrays.toString(newCache));// 0 ： -128// 1 ： -127// 2 ： -126// ...// 127 ： -1// 128 ： 0// 129 ： 1// 130 ： 2// 131 ： 3// 132 ： 4// 133 ： 5newCache[132] = newCache[133];int a = 2;int b = a + a;// public PrintStream printf(String format, Object ... args)// 用的是Object类型，取包装类System.out.println("println:" + a + "+" + a + "=" + b); // 2+2=4System.out.printf("printf:%d + %d = %d\n", a, a, b); // 2+2=5newCache[132] = 1999;System.out.println("println:b = " + b);// println:正常的4System.out.printf("printf:b = %d", b);// printf:新值1999}
}

为什么System.out.printf的结果都是我们修改的值呢？可以推测，printf一定是到缓存中去取值了。

看看printf的源码：

public PrintStream printf(String format, Object ... args)

第二个参数是Object类型的（还是个可变参数），包装类是Object的子类，这里正是用的多态，用Object代表包装类的对象，取的正是Integer中的值，在-128~127范围内，取的正是缓存里的值。

最大值和最小值

通过包装类，我们可以取出数值类型的最大值和最小值，这些值在范围判断的时候很重要，但是非天才是记不住的，包装类可以帮我们快速找出来。

public class MAX_MIN {public static void main(String[] args) {System.out.println(Integer.MAX_VALUE);System.out.println(Integer.MIN_VALUE);System.out.println(Long.MAX_VALUE);System.out.println(Long.MIN_VALUE);System.out.println(Double.MAX_VALUE);System.out.println(Double.MIN_VALUE);}
}

2147483647
-2147483648
9223372036854775807
-9223372036854775808
1.7976931348623157E308
4.9E-324

*Java7增加的包装类功能：compare比较值的大小

public class TestIntegercompare {public static void main(String[] args) {Integer a1 = 100;Integer a2 = 100;System.out.println(a1 + "==" + a2 + ":" + (a1 == a2));// FALSEa1 = 1000;a2 = 1000;System.out.println(a1 + "==" + a2 + ":" + (a1 == a2));// FALSE// 包装类.compare方法：比较值的大小（大于:1/等于:0/小于:-1）System.out.println(a1 + "==" + a2 + ":" + Integer.compare(a1, a2));System.out.println("1 VS 2 : " + Integer.compare(1, 2));System.out.println("2 VS 1 : " + Integer.compare(2, 1));System.out.println("1 VS 1 : " + Integer.compare(1, 1));}
}

*Java8增强的包装类，主要是支持无符号运算。

无符号数的最高位不再被当做符号位（不支持负数，最小值为0）

public class Java8Wapper {public static void main(String[] args) {byte b = -1;int unsignedInt = Byte.toUnsignedInt(b);System.out.println(unsignedInt);long unsignedLong = Byte.toUnsignedLong(b);System.out.println(unsignedLong);}
}

255
255