包装类
Java有八种基本类型，每种基本类型都有一个对应的包装类。
包装类是什么呢？它是一个类，内部有一个实例变量，保存对应的基本类型的值，这个类一般还有一些静态方法、静态变量和实例方法，以方便对数据进行操作。
Java中，基本类型和对应的包装类如下表所示：
| 基本类型 | 包装类 |
| boolean | Boolean |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
包装类也都很好记，除了Integer和Character外，其他类名称与基本类型基本一样，只是首字母大写。
包装类有什么用呢？Java中很多代码(比如后续文章介绍的集合类）只能操作对象，为了能操作基本类型，需要使用其对应的包装类，另外，包装类提供了很多有用的方法，可以方便对数据的操作。
包装类的基本使用是比较简单的，但我们不仅会介绍其基本用法，还会介绍一些平时用的相对较少的功能，同时剖析其实现代码，内容比较多，我们会分三节来介绍，本节主要介绍各个包装类的基本用法及其共同点，后两节我们会进一步介绍高级功能，并剖析实现代码。
让我们逐步来介绍。
基本类型和包装类
我们先来看各个基本类型和其包装类是如何转换的，我们直接看代码：
Boolean
boolean b1 = false; Boolean bObj = Boolean.valueOf(b1); boolean b2 = bObj.booleanValue();
Byte
byte b1 = 123; Byte byteObj = Byte.valueOf(b1); byte b2 = byteObj.byteValue();
Short
short s1 = 12345; Short sObj = Short.valueOf(s1); short s2 = sObj.shortValue();
Integer
int i1 = 12345; Integer iObj = Integer.valueOf(i1); int i2 = iObj.intValue();
Long
long l1 = 12345; Long lObj = Long.valueOf(l1); long l2 = lObj.longValue();
Float
float f1 = 123.45f; Float fObj = Float.valueOf(f1); float f2 = fObj.floatValue();
Double
double d1 = 123.45; Double dObj = Double.valueOf(d1); double d2 = dObj.doubleValue();
Character
char c1 = ‘A‘; Character cObj = Character.valueOf(c1); char c2 = cObj.charValue();
这些代码结构是类似的，每种包装类都有一个静态方法valueOf()，接受基本类型，返回引用类型，也都有一个实例方法xxxValue()返回对应的基本类型。
将基本类型转换为包装类的过程，一般称为"装箱"，而将包装类型转换为基本类型的过程，则称为"拆箱"。装箱/拆箱写起来比较啰嗦，Java 1.5以后引入了自动装箱和拆箱技术，可以直接将基本类型赋值给引用类型，反之亦可，如下代码所示：
Integer a = 100; int b = a;
自动装箱/拆箱是Java编译器提供的能力，背后，它会替换为调用对应的valueOf()/xxxValue()，比如说，上面的代码会被Java编译器替换为：
Integer a = Integer.valueOf(100); int b = a.intValue();
每种包装类也都有构造方法，可以通过new创建，比如说：
Integer a = new Integer(100); Boolean b = new Boolean(true); Double d = new Double(12.345); Character c = new Character(‘马‘);
那到底应该用静态的valueOf方法，还是使用new呢？一般建议使用valueOf。new每次都会创建一个新对象，而除了Float和Double外的其他包装类，都会缓存包装类对象，减少需要创建对象的次数，节省空间，提升性能，后续我们会分析其具体代码。
重写Object方法
所有包装类都重写了Object类的如下方法：
boolean equals(Object obj) int hashCode() String toString()
我们逐个来看下。
equals
equals用于判断当前对象和参数传入的对象是否相同，Object类的默认实现是比较地址，对于两个变量，只有这两个变量指向同一个对象时，equals才返回true，它和比较运算符(==)的结果是一样的。
但，equals应该反映的是对象间的逻辑相等关系，所以这个默认实现一般是不合适的，子类需要重写该实现。所有包装类都重写了该实现，实际比较用的是其包装的基本类型值，比如说，对于Long类，其equals方法代码是：
public boolean equals(Object obj) {
if (obj instanceof Long) {
return value == ((Long)obj).longValue();
}
return false;
}
对于Float，其实现代码为：
public boolean equals(Object obj) {
return (obj instanceof Float)
&& (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
}
Float有一个静态方法floatToIntBits()，将float的二进制表示看做int。需要注意的是，只有两个float的二进制表示完全一样的时候，equals才会返回true。在第5节的时候，我们提到小数计算是不精确的，数学概念上运算结果一样，但计算机运算结果可能不同，比如说，看下面代码：
Float f1 = 0.01f; Float f2 = 0.1f*0.1f; System.out.println(f1.equals(f2)); System.out.println(Float.floatToIntBits(f1)); System.out.println(Float.floatToIntBits(f2));
输出为:
false 1008981770 1008981771
也就是，两个浮点数不一样，将二进制看做整数也不一样，相差为1。
Double的equals方法与Float类似，它有一个静态方法doubleToLongBits，将double的二进制表示看做long，然后再按long比较。
hashCode
hashCode返回一个对象的哈希值，哈希值是一个int类型的数，由对象中一般不变的属性映射得来，用于快速对对象进行区分、分组等。一个对象的哈希值不能变，相同对象的哈希值必须一样。不同对象的哈希值一般应不同，但这不是必须的，可以有不同对象但哈希值相同的情况。
比如说，对于一个班的学生对象，hashCode可以是学生的出生月日，出生日期是不变的，不同学生生日一般不同，分布比较均匀，个别生日相同的也没关系。
hashCode和equals方法联系密切，对两个对象，如果equals方法返回true，则hashCode也必须一样。反之不要求，equal返回false时，hashCode可以一样，也可以不一样，但应该尽量不一样。hashCode的默认实现一般是将对象的内存地址转换为整数，子类重写equals时，也必须重写hashCode。之所以有这个规定，是因为Java API中很多类依赖于这个行为，尤其是集合中的一些类。
包装类都重写了hashCode，根据包装的基本类型值计算hashCode，对于Byte, Short, Integer, Character，hashCode就是其内部值，代码为：
public int hashCode() {
return (int)value;
}
对于Boolean，hashCode代码为:
public int hashCode() {
return value ? 1231 : 1237;
}
根据基类类型值返回了两个不同的数，为什么选这两个值呢？它们是质数，即只能被1和自己整除的数，后续我们会讲到，质数比较好，但质数很多，为什么选这两个呢，这个就不得而知了，大概是因为程序员对它们有特殊的偏好吧。
对于Long，hashCode代码为：
public int hashCode() {
return (int)(value ^ (value >>> 32));
}
是高32位与低32位进行位异或操作。
对于Float，hashCode代码为：
public int hashCode() {
return floatToIntBits(value);
}
与equals方法类似，将float的二进制表示看做了int。
对于Double，hashCode代码为：
public int hashCode() {
long bits = doubleToLongBits(value);
return (int)(bits ^ (bits >>> 32));
}
与equals类似，将double的二进制表示看做long，然后再按long计算hashCode。
关于equals和hashCode，我们还会在后续的章节中碰到，并进行进一步说明。
toString
每个包装类也都重写了toString方法，返回对象的字符串表示，这个一般比较自然，我们就不赘述了。
Comparable
每个包装类也都实现了Java API中的Comparable接口，Comparable接口代码如下：
public interface Comparable<T> {
public int compareTo(T o);
}
<T>是泛型语法，我们后续文章介绍，T表示比较的类型，由实现接口的类传入。接口只有一个方法compareTo，当前对象与参数对象进行比较，在小于、等于、大于参数时，应分别返回-1，0，1。
各个包装类的实现基本都是根据基本类型值进行比较，不再赘述。对于Boolean，false小于true。对于Float和Double，存在和equals一样的问题，0.01和0.1*0.1相比的结果并不为0。
包装类和String
除了toString方法外，包装类还有一些其他与String相关的方法。
除了Character外，每个包装类都有一个静态的valueOf(String)方法，根据字符串表示返回包装类对象，如：
Boolean b = Boolean.valueOf("true");
Float f = Float.valueOf("123.45f");
也都有一个静态的parseXXX(String)方法，根据字符串表示返回基本类型值，如：
boolean b = Boolean.parseBoolean("true");
double d = Double.parseDouble("123.45");
都有一个静态的toString()方法，根据基本类型值返回字符串表示，如：
System.out.println(Boolean.toString(true)); System.out.println(Double.toString(123.45));
输出：
true 123.45
对于整数类型，字符串表示除了默认的十进制外，还可以表示为其他进制，如二进制、八进制和十六进制，包装类有静态方法进行相互转换，比如：
System.out.println(Integer.toBinaryString(12345)); //输出2进制
System.out.println(Integer.toHexString(12345)); //输出16进制
System.out.println(Integer.parseInt("3039", 16)); //按16进制解析
输出为：
11000000111001 3039 12345
常用常量
包装类中除了定义静态方法和实例方法外，还定义了一些静态变量。
Boolean类型：
public static final Boolean TRUE = new Boolean(true); public static final Boolean FALSE = new Boolean(false);
所有数值类型都定义了MAX_VALUE和MIN_VALUE，表示能表示的最大/最小值，比如，对Integer：
public static final int MIN_VALUE = 0x80000000; public static final int MAX_VALUE = 0x7fffffff;
Float和Double还定义了一些特殊数值，比如正无穷、负无穷、非数值，如Double类：
public static final double POSITIVE_INFINITY = 1.0 / 0.0; public static final double NEGATIVE_INFINITY = -1.0 / 0.0; public static final double NaN = 0.0d / 0.0;
Number
六种数值类型包装类有一个共同的父类Number，Number是一个抽象类，它定义了如下方法：
byte byteValue() short shortValue() int intValue() long longValue() float floatValue() double doubleValue()
通过这些方法，包装类实例可以返回任意的基本数值类型。
不可变性
包装类都是不可变类，所谓不可变就是，实例对象一旦创建，就没有办法修改了。这是通过如下方式强制实现的：
- 所有包装类都声明为了final，不能被继承
- 内部基本类型值是私有的，且声明为了final
- 没有定义setter方法
为什么要定义为不可变类呢？不可变使得程序可以更为简单安全，因为不用操心数据被意外改写的可能了，可以安全的共享数据，尤其是在多线程的环境下。关于线程，我们后续文章介绍。
小结
本节介绍了包装类的基本用法，基本类型与包装类的相互转换、自动装箱/拆箱、重写的Object方法、Comparable接口、与String的相互转换、常用常量、Number父类，以及包装类的不可变性。从日常基本使用来说，除了Character外，其他类介绍的内容基本就够用了。
但Integer和Long中有一些关于位操作的方法，我们还没有介绍，Character中的大部分方法我们也都没介绍，它们的一些实现原理我们也没讨论，让我们在接下来的两节中继续探索。
原文地址：https://www.cnblogs.com/ivy-xu/p/12370115.html