Java中关于泛型、包装类及ArrayList介绍

---

一、泛型

1.1 泛型类的定义

泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。
泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译
器去做检查。

// 1. 尖括号 <> 是泛型的标志
// 2. E 是类型变量(Type Variable)，变量名一般要大写
// 3. E 在定义时是形参，代表的意思是 MyArrayList 最终传入的类型，但现在还不知道
	public class MyArrayList<E> {
	private E[] array;
	private int size;
} 

【规范】类型形参一般使用一个大写字母表示，常用的名称有：

• E 表示 Element；
• K 表示 Key；
• V 表示 Value；
• N 表示 Number；
• T 表示 Type；
• S, U, V 等等 - 第二、第三、第四个类型。

泛型类可以一次有多个类型变量，用逗号分割。

1. 泛型是作用在编译期间的一种机制，即运行期间没有泛型的概念。
2. 泛型代码在运行期间，利用 Object 达到的效果（这里不是很准确）。
3. 泛型的意义：自动对类型进行检查。
4. 不能new泛型类型的数组。

1.2 泛型类的使用

示例：

class MyArrayList<E>{//  代表当前类是一个泛型类，此时的E就是一个占位符而已
    private E[] elem;
    private int usedSize;

    public MyArrayList() {
//        this.elem = elem;
        this.elem = (E[])new Object[10];//这样的写法不是十分正确
    }
    public void add(E val){
        this.elem[usedSize] = val;
        usedSize++;
    }
    public E get(int pos){
        return this.elem[pos];
    }
}
public class test02 {
    public static void main(String[] args) {
        //泛型中尖括号里面的内容不参与类型的组成
        //泛型只能接受类，所有的基本数据类型必须使用包装类！
        MyArrayList<String>  myArrayList = new MyArrayList<>();
        System.out.println(myArrayList);
        MyArrayList<Integer>  myArrayList1 = new MyArrayList<>();
        System.out.println(myArrayList1);
        MyArrayList<Boolean>  myArrayList2 = new MyArrayList<>();
        System.out.println(myArrayList2);
    }
    public static void main2(String[] args) {
        MyArrayList<String>  myArrayList = new MyArrayList<>();
        myArrayList.add("ni");//自动对类型进行检查，不是字符串类型就会报错
        myArrayList.add("n");
        String ret = myArrayList.get(1);//自动对类型进行强制类型转换
        System.out.println(ret);
   }
}

裸类型：
裸类型是一个泛型类但没有带着类型实参，例如 MyArrayList 就是一个裸类型：

MyArray list = new MyArray();

裸类型是为了兼容老版本的 API 保留的机制。

1.3 泛型总结

1. 泛型是为了解决某些容器、算法等代码的通用性而引入，并且能在编译期间自动做类型检查和转换。
2. 泛型利用的是 Object 是所有类的祖先类，并且父类的引用可以指向子类对象的特定而工作。
3. 泛型是一种编译期间的机制，在编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制。即 MyArrayList 和 MyArrayList 在运行期间是一个类型。即泛型中尖括号里面的内容不参与类型的组成。Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。
4. 泛型是 java 中的一种合法语法，标志就是尖括号 <>，使用 表示当前类是一个泛型类。
5. 泛型是将数据类型参数化，进行传递。

1.4 泛型的上界

在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。

语法：

class 泛型类名称<类型形参 extends 类型边界> {
...
}

示例：

public class MyArray<E extends Number> {
...
}

只接受 Number 的子类型作为 E 的类型实参。（E可以是 Number或者是 Number的子类）

MyArray<Integer> l1; // 正常，因为 Integer 是 Number 的子类型
MyArray<String> l2; // 编译错误，因为 String 不是 Number 的子类型

如果没有指定类型边界 E，可以视为 E extends Object。
泛型只有上界，没有下界。

1.5 复杂示例

//代表此时传入的E一定要实现compareTo接口，这里也是一种特殊的泛型上界
public class MyArray<E extends Comparable<E>> {
...
}

示例：

public class test01 {
    public static void main(String[] args) {
        Alg<Integer> alg1 = new Alg<>();
        Integer[] arr = {1,34,5,67,9};
        System.out.println(alg1.findMax(arr));

        Alg<String> alg2 = new Alg<>();
        String[] str = {"abd","zge","cde"};
        System.out.println(alg2.findMax(str));
    }
}
class Alg<T extends Comparable <T>>{
    public T findMax(T[] arr){
        T max = arr[0];
        for (int i = 1; i <arr.length ; i++) {
            if(max.compareTo(arr[i]) < 0){
                max = arr[i];
            }
        }
        return max;
    }
}

输出结果：

1.6 泛型方法

语法格式：

方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) { ... }

示例：

class Alg2{
    public static<T extends Comparable <T>> T findMax(T[] arr){
        T max = arr[0];
        for (int i = 1; i <arr.length ; i++) {
            if(max.compareTo(arr[i]) < 0){
                max = arr[i];
            }
        }
        return max;
    }
}
public class test01 {
    public static void main(String[] args) {
        Integer[] arr = {1,34,5,67,9};
        //System.out.println(Alg2.findMax(arr));
        //可以不类型推导
        System.out.println(Alg2.findMax(arr));
    }

1.7 泛型中的父子类关系

public class MyArrayList<E> { ... }
// MyArrayList