简单了解泛型和包装类
作者：~小明学编程
文章专栏：Java数据结构
格言：目之所及皆为回忆，心之所想皆为过往
目录
简单了解泛型
泛型的引入
泛型类的定义的简单演示
泛型背后作用时期和背后的简单原理
泛型类的简单使用
泛型的简单总结
包装类
基本数据类型和包装类直接的对应关系
装箱和拆箱
易错提醒
简单了解泛型
泛型的引入
我们之前实现过的顺序表，只能保存 int 类型的元素，如果现在需要保存 指向 Person 类型对象的引用的顺序表，请问应该如何解决？如果又需要保存指向 Book 对象类型的引用呢？
答：1.我们在学习多态的过程中我们知道，基类的引用是可以指向子类的对象的。
2.我们知道Object是我们所有类的父类。
所以面对上面的问题我们就很容易想到一个解决的办法，那就是把我们的int类型改为我们的Object这样我们就能接受所有类型的数据了，接着我们就来做一个简单的实现。
class MyArrayList1 {
public Object[] elem;
private int userSize;
public MyArrayList1() {
this.elem = new Object[10];
}
public void add(Object x) {
this.elem[this.userSize] = x;
userSize++;
}
public Object get(int x) {
return elem[x];
}
}
public class TestDemo2 {
public static void main(String[] args) {
MyArrayList1 myArrayList = new MyArrayList1();
myArrayList.add(10);
myArrayList.add("ad");
int ret = (int) myArrayList.get(0);
System.out.println(ret);//10
}
}这样我们的顺序表就能接受来自不同类型的数据了。
接着我们看一下下面这段代码：
public static void main(String[] args) {
MyArrayList1 myArrayList = new MyArrayList1();
myArrayList.add(10);
myArrayList.add("ad");
String ret = (String) myArrayList.get(0);
System.out.println(ret);//10
}这里编译正确，但运行时会抛出异常 ClassCastException
提示：问题暴露的越早，影响越小。编译期间的问题只会让开发者感觉到，运行期间的错误会让所有的软件使用者承受错误风险。
所以我们需要一种机制，可以 1. 增加编译期间的类型检查 2. 取消类型转换的使用 泛型就此诞生。
泛型类的定义的简单演示
// 1. 尖括号 <> 是泛型的标志
// 2. E 是类型变量(Type Variable)，变量名一般要大写
// 3. E 在定义时是形参，代表的意思是 MyArrayList 最终传入的类型，但现在还不知道
public class MyArrayList<E> {
private E[] array;
private int size;
...
}泛型背后作用时期和背后的简单原理
1. 泛型是作用在编译期间的一种机制，即运行期间没有泛型的概念。
2. 泛型代码在运行期间，就是我们上面提到的，利用 Object 达到的效果（这里不是很准确，以后会做说明）。
泛型类的简单使用
class MyArrayList <E>{
public E[] elem;
private int userSize;
public MyArrayList() {
this.elem = (E[]) new Object[10];
}
public void add(E x) {
this.elem[this.userSize] = x;
userSize++;
}
public E get(int x) {
return elem[x];
}
}
这里我们，看到在编译的时候就会给我们进行检查。
通过以上代码，我们可以看到泛型类的一个使用方式：只需要在所有类型后边跟尖括号，并且尖括号内是真正的类型，即 E 可以看作的最后的类型。
注意： Book 只能想象成 E 的类型，但实际上 E 的类型还是 Object。
泛型的简单总结
1. 泛型是为了解决某些容器、算法等代码的通用性而引入，并且能在编译期间做类型检查。
2. 泛型利用的是 Object 是所有类的祖先类，并且父类的引用可以指向子类对象的特定而工作。
3. 泛型是一种编译期间的机制，即 MyArrayList<Person> 和 MyArrayList<Book> 在运行期间是一个类型。
4. 泛型是 java 中的一种合法语法，标志就是尖括号 <>。
包装类
Object 引用可以指向任意类型的对象，但有例外出现了，8 种基本数据类型不是对象，那岂不是刚才的泛型机制要失效了？
实际上也确实如此，为了解决这个问题，java 引入了一类特殊的类，即这 8 种基本数据类型的包装类，在使用过程中，会将类似 int 这样的值包装到一个对象中去。
基本数据类型和包装类直接的对应关系
除了 Integer 和 Character，剩下的就是类型的首字母大写。
装箱和拆箱
public static void main(String[] args) {
// 装箱操作，新建一个 Integer 类型对象，将 i 的值放入对象的某个属性中
Integer a2 = Integer.valueOf(123);//显示装箱
Integer a3 = new Integer(100);//显示装箱
int b2 = a2.intValue();//显示拆箱
// 拆箱操作，将 Integer 对象中的值取出，放到一个基本数据类型中
Integer a = 10;//隐式 装箱
int b = a;//隐式 拆箱
}可以看到在使用过程中，装箱和拆箱带来不少的代码量，所以为了减少开发者的负担，java 提供了自动机制。
int i = 10;
Integer ii = i; // 自动装箱
Integer ij = (Integer)i; // 自动装箱
int j = ii; // 自动拆箱
int k = (int)ii; // 自动拆箱注意：自动装箱和自动拆箱是工作在编译期间的一种机制。
易错提醒
我们看一下下面这段代码
public static void main1(String[] args) {
Integer a1 = 10;
Integer a2 = 10;
System.out.println(a1==a2);
Integer b1 = 128;
Integer b2 = 128;
System.out.println(b1==b2);
}这段代码的输出结果是什么呢？
没想到吧！为啥会是这样呢？
想要知道为何会是这样就得看看显示装箱的过程，这就需要我们查看源码了。
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
当我们的i小于等于127并且大于等于-128的时候直接返回的是cache数组里面的值，否则的话就是要重新new()一个对象，这也就是为啥我们的b1和b2不相等的原因。