在 java.lang 包中有很多类，其中一些类和前面学过的基本数据类型有关，叫做包装器类（Wrapper)。
java 使用简单的数据类型，例如整型（int ) 和字符型 （char )。这些数据类型不是对象层次结构的组成部分。他们通过值传递给方法而不能直接通过引用传递。 有时需要对这些简单的类型建立对象表达式，例如，当把数据放到集合中时，需要包装成对象。为了能够用对象的形式代表简单数据类型， java提供了与 每一个 简单类型相应的类。从本质上讲，这些类中包装了(Wrap)简单类型的数据。因此，它们通常被称作类型包装器或者包装类。
Number
抽象类 Number 定义了一个数字包装器类型的超类。
字节型（byte)、短整型（short) 、整型（int）、长整型（long)、浮点型（float) 和 双精度（double) 等简单基本类型的包装器都是它的子类。
Number 有返回不同数字格式的值的抽象方法。例如 doubleValue() 方法从包装器类返回双精度（double)值， floatValue() 方法返回浮点（float) 值等。
Number 中定义的方法
| 方法 | 描述 |
|---|---|
| byte byteValue() | 返回包装器对象中的值(字节型） |
| short shortValue() | 返回包装器对象中的值(短整型） |
| int intValue() | 返回包装器对象中的值(整型） |
| long longValue() | 返回包装器对象中的值(长整型） |
| float floatValue() | 返回包装器对象中的值(浮点型） |
| double doubleValue() | 返回包装器对象中的值(双精度） |
Number 有 6个具体的子类，包含了 6种类型的显示值：字节型（byte)、短整型（short) 、整型（int）、长整型（long)、浮点型（float) 和 双精度（double) 。这些类都实现了 Compareable接口，可以比较包装器对象的大小。
Byte 、Short、Integer、Long
Byte 、Short、Integer、Long 类分别是 字节型（byte)、短整型（short) 、整型（int）、长整型（long) 整数类型的包装器。它们的构造函数如下：
Byte( byte value) ; Byte( String str)
Short(short value); Short(String str)
Integer(int value); Integer(String str)
Long(long value); Long(String str)正如所看到的，这些对象可以由数值或表示有效整数值得字符串创建。
由这些类定义一些方法以便从字符串解析整数和将字符串转换为整数。为了方便起见，这些方法提供的变量可以用来指定 radix,也称为基数。如通常 二进制（Binary)的基数是2.
在这些类中定义了两个常量：MAX_VALUE 和 MIN_VALUE,分别表示每种数据类型表示的最大值和最小值。
这些类中定义了几种类型的方法。
1）基本类型到包装器类型的转换。
static Byte valueOf(byte b)
static Short valueOf(short i)
static Integer valueOf(int i)
static Long valueOf(short i)2)包装器类型到基本类型的转换
byteValue()
shortValue()
intValue()
longValue()3) 字符串到数字类型转换
parseByte()
parseShort()
parseInt()
parseLong()4)数字类型到字符串的转换
包装器 类 Integer 中定义了下面的方法：
static String toString(int i, int radix) //按照 radix 进制把整数 i转换成字符串，转换结果含符号字符。
static String toBinaryString( int value) //按照二进制转换成字符串（补码方式），转换结果不含符号字符，即最高位为1表示负数。
static String toOctalString(int value) //按照八进制转换成字符串，转换结果不含符号字符。
static String toHexString(int Value) //按照十六进制转换成字符串，转换结果不含符号字符。Byte 、Short、Long 中都有对应的方法，只是方法的参数类型为对应的简单类型。
5）包装器类型到字符串的转换
String toString()6)字符串到包装器类型的转换
static Integer ValueOf(String s, int radix) //按照 radix 进制把字符串 s 转换成 Integer类型。Byte 、Short、Long 中都有对应的方法
数字和字符串转换
String s1 = "12";
String s2 = "34";
String s = null;
int i1 = 0,i2 = 0, sum = 0;
i1 = Integer.parseInt(s1);
i2 = new Integer(s2).intValue();
sum = i1 +i2;
s = Integer.toString(sum);
System.out.println(s); //46用不同进制把数字和字符串转换
int i = -34567;
String s = null;
System.out.println("二进制字符串："+Integer.toBinaryString(i));
System.out.println("八制字符串："+Integer.toOctalString(i));
System.out.println("十六制字符串："+Integer.toHexString(i));
s = Integer.toString(i,8);
System.out.println("带符号，八进制字符串："+ s);
Integer I = Integer.valueOf(s,8);
System.out.println("Integer对象的值："+I.intValue());
// 二进制字符串：11111111111111110111100011111001
// 八制字符串：37777674371
// 十六制字符串：ffff78f9
// 带符号，八进制字符串：-103407
// Integer对象的值：-34567Float 和 Double
双精度（Double) 和 浮点 (Float) 分别是对类型 double 和类型 float 的浮点值得包装器。
浮点（Float)的构造函数如下所示：
Float(double value)
Float(float value)
Float(String s)浮点 对象可以由 类型 float,或 类型 double的值创建。它们也能由浮点的字符串表达式创建。
双精度构造函数如下：
Double (double value)
Double(String s)双精度对象可以被双精度值或浮点值的字符串创建。
浮点和双精度都定义了如下常量
| 常量 | 描述 |
|---|---|
| MAX_VALUE | 最大值值 |
| MIN_VALUE | 最小正值 |
| POSITIVE_INFINITY | 正无穷 |
| NEGATIVE_INFINITY | 负无穷 |
| NaN | 非数字 |
Float类中定义的方法
| 方法 | 描述 |
|---|---|
| int compareTo(Float f) | 将调用 对象的数值与参数 f 中的数值进行比较，如果两者相等，则返回0；如果调用对象的值小于f的值，则返回负值；如果调用对象的值大于f的值，则返回正值 |
| static float parseFloat(String s)throws NumberFormatException | 以 10 位基数，把字符串 s 解析成浮点数。s 中的字符应该是有效的数字字符。 |
| static String toString(float value) | 把一个浮点转换成字符串 |
| static Float valueOf(String s)throws NumberFormatException | 把字符串 s 转化成 Float 对象。s 中的字符应该是有效的数字字符。 |
Double 类中定义的方法
| 方法 | 描述 |
|---|---|
| int compareTo(Double d) | 将调用 对象的数值与参数 f 中的数值进行比较，如果两者相等，则返回0；如果调用对象的值小于f的值，则返回负值；如果调用对象的值大于f的值，则返回正值 |
| static double parseDouble(String s)throws NumberFormatException | 以 10 位基数，把字符串 s 解析成双精度。s 中的字符应该是有效的数字字符。 |
| static String toString(double value) | 把一个双精度转换成字符串 |
| static Double valueOf(String s)throws NumberFormatException | 把字符串 s 转化成 Double 对象。s 中的字符应该是有效的数字字符。 |
Character
Character 是针对字符型 （char）的一个简单的包装器。
其构造函数如下：
Character(char ch)这里 ch 指定了被创建的 Character 对象所包装的字符。
调用如下的 charValue()方法可以获得包含在 Character 对象中的字符型（char）值。
Character 类定义了很多常数和静态方法
| 方法 | 描述 |
|---|---|
| static boolean isDefined(char ch) | 如果 ch 是由 Unicode定义的，则返回true,否则返回 false |
| static boolean isDigit(char ch) | 如果 ch 是一个数字，则返回 true,否则返回 false |
| static boolean isIdentifierIgnorable(char ch) | 如果在一个标识符中ch应被忽略，则返回true,否则返回false |
| static boolean isJavaIdentifierPart(char ch) | 如果 ch 可以被作为 java标识符的一部分（除了第一个字符），则返回true,否则返回 false |
| static boolean isJavaIdentifierStart(char ch) | 如果 ch 可以被作为 java标识符的首字符，则返回true,否则返回 false |
| static boolean isLetter(char ch) | 如果 ch 是一个字母，则返回 true,否则返回 false |
| static Boolean isLetterOrDigit(char ch) | 如果 ch 是一个字母或一个数字，则返回 true,否则返回 false |
| static boolean isLowerCase(char ch) | 当 ch 是小写字母时，返回 true,否则返回 false |
| static boolean isSpaceChar(char ch) | 如果 ch 是Unicode编码的空格字符，则返回true,否则返回 false |
| static boolean isTitleCase(char ch) | 如果 ch 是 Unicode编码的标题字符，则返回true,否则返回false |
| static boolean isUpperCase(char ch) | 如果 ch 是一个大写字母，则返回 true,否则返回 false |
| static boolean isWhitespace(char ch) | 如果 ch 是一个空白符，则返回 true,否则返回 false |
| static char toLowerCase(char ch) | 返回 ch 的小写等价形式 |
| static char toTitleCase(char ch) | 返回 ch 的标题等价形式 |
| static char toUpperCase(char ch) | 返回 ch 的大写等价形式 |
| static String toString(char ch) | 把字符转化成字符串 |
Boolean
Boolean 是一个针对布尔（boolean）值得非常细小的包装器，主要用在通过引用传递布尔（boolean）变量的场合。它包含了常数 true和 false ，这些常数定义了Boolean 对象的真与假。Boolean 也定义了 type 域，它是 boolean 的 Class对象。在 Boolean 中定义了如下的构造函数
Boolean(boolean boolValue)
Boolean(String boolString)在第一种形式中，boolValue 要么是 true,要么是 false。在第二种形式中 如果在
boolString 中包含了字符串 “true”(不论是大写形式还是小写形式），则新的Boolean对象将为真；否则为假。
Boolean定义如下方法
| 方法 | 描述 |
|---|---|
| boolean booleanValue() | 返回调用对象的 boolean 值 |
| boolean equals(Object obj) | 如果调用对象与 obj 相等则返回 true,否则返回 false |
| int hashCode | 返回调用对象的散列值 |
| static Boolean valueOf(String str) | 把字符串 str 转化为Boolean对象 |
String s ="true";
boolean b =true;
if(b==new Boolean(s).booleanValue()){
System.out.println("两个布尔变量相等");
}
System.out.println(Boolean.valueOf(s).hashCode());
//两个布尔变量相等
//1231自动装箱与拆箱
自 JDK 5.0 开始，基本类型的变量能够自动转换为它的包装器类型的对象，这种自动转换被称为 自动装箱。 包装器对象就像 ‘箱子’ 一样，其中存放着相应的基本类型的值。其反向转换，即自动把包装器类的对象转换为基本类型的值，被称为 自动拆箱。
自动装箱：
Integer objval = 9;语句自动把 int 型的 9 装箱转换为 Integer 对象。objVal引用一个Integer对象，对象中的值为 9 。等价于：
Integer objVal = new Integer(9);自动拆箱
int i = objVal;自动拆箱 转换自动提取包装器对象中的基本类型值。objVal引用一个Integer对象，i 的值为 9 。等价于：
int i = objVal.intValue();自动装箱 与 自动拆箱 转换在许多上下文环境中会被应用，例如在赋值 和传递引用的时候。类集合中只能存放对象，不能存放基本类型的值，当把基本类型的值放入集合时，就会发生自动装箱转换，把基本类型值转换为对应的包装器对象。
这种自动转换不是在任何时候都能进行的，特别是不能像处理对象那样直接使用基本类型的变量或值得引用。例如：给定一个 int 型变量，表达式 i.toString()是不能通过编译的，但是可以对其先进行强制转换来解决问题:
((Object)j).toString();
装箱转换可能需要一个包装器类的对象，这将小号内存。由于包装器对象中的值是不可变的。所以拥有相同的值得对象是可以互相使用的，因此，实际上不需要创建有用相同值的两个不同的包装器类的对象。Java对于某些类型，在某些值域范围内相同值的装箱总是产生相同的对象。