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←int
int a2 = objA; // 自动拆箱:int←Integer
System.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));
}
}
100100:true
10001000: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 property
int 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 ： 5
newCache[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=4
System.out.printf("printf:%d + %d = %d\n", a, a, b); // 2+2=5
newCache[132] = 1999;
System.out.println("println:b = " + b);// println:正常的4
System.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));// FALSE
a1 = 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
