数据结构之初识泛型

1.包装类

在Java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，Java给每个基本类型都对应了一个包装类型。

1.1基本数据类型对应的包装类

（图片来源于网上，如有侵权，请联系删除）
除了Integer和Character，其余基本类型的包装类都是首字母大写。

1.2装箱和拆箱

 public static void main2(String[] args) {
        int a = 1;
        Integer i1 = Integer.valueOf(a);//手动装箱

        Integer ii2 = new Integer(1);
        int b = ii2.intValue();//手动拆箱
        double d = ii2.doubleValue();
        System.out.println(i1);
        System.out.println(b);
        System.out.println(d);
    }
    public static void main1(String[] args) {
        int a = 1;
        Integer ii = a;//自动装箱

        Integer ii1 = new Integer(1);
        int a1 = ii1;//自动拆箱
        System.out.println(ii);
        System.out.println(a1);
    }

注意：当包装类的值为100时相等，但是当改变值为200时，输出结果为false。如下代码：

public static void main3(String[] args) {
        Integer ii = 100;//200
        Integer ii1 = 100;//200
        System.out.println(ii = ii1);
//        System.out.println(ii = ii1);结果为200时，不相等。（源码）

    }

public static void main(String[] args) {
        Integer ii = 200;//200
        Integer ii1 = 200;//200
        System.out.println(ii == ii1 );
//        System.out.println(ii = ii1);结果为200时，不相等。（源码）

    }

这是为什么呢？

我们知道整个过程都是一个装箱的过程，也就是调用了valueOf（）这个方法，如图为此方法的源码一部分，我们可以知道当值大于low小于high时，返回的是缓存数组的数据，当不在这个范围时，会产生新的对象，通过源码我们发现low为-128，high为127，通过计算0下标的值为-128，255下标的值为127，所以当超过这个范围时，结果返回false

2.什么是泛型

通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。

3.引出泛型

之前我们学到过数组，里面只能存储指定类型的元素。那么如果我们将数组创建为object时会怎么样呢？

class MyArray {
  public Object[] array = new Object[10];
 
  public Object getPos(int pos) {
    return this.array[pos];
 }
  public void setVal(int pos,Object val) {
    this.array[pos] = val;
 }
}
public class TestDemo {
  public static void main(String[] args) {
    MyArray myArray = new MyArray();
    myArray.setVal(0,10);
    myArray.setVal(1,"hello");//字符串也可以存放
    String ret = myArray.getPos(1);//编译报错
    System.out.println(ret);
 }
}

通过以上代码，我们发现数组里面任何数据类型都可以存放，1号下标本身就是字符串，但是确编译报错，必须进行强制类型转换。
如果我们想指定存放某种元素需要怎么做呢？
由此我们引出了泛型，泛型的主要目的就是指定当前的容器，要持有什么类型的对象，让编译器自己去检查。

public class MyArray<T> {
    public Object[] array = new Object[10];

    public void setValue(int pos,T val){
        array[pos] = val;
    }
    public T getValue(int pos){
        return (T) array[pos];
    }
    public static void main1(String[] args) {
        MyArray<String> myArray = new MyArray<>();
        MyArray<Integer> myArray1 = new MyArray<>(); 
    }
   
    }

如上代码就是一个泛型类，注意泛型只能接收类，所有的数据类型必须使用包装类。你想要存放什么类型的元素就可以传什么类型。

4.裸类型（了解）

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

MyArray list = new MyArray();

注意： 我们不要自己去使用裸类型，裸类型是为了兼容老版本的 API 保留的机制
小结：

1. 泛型是将数据类型参数化，进行传递
2. 使用 表示当前类是一个泛型类。
3. 泛型目前为止的优点：数据类型参数化，编译时自动进行类型检查和转换

5.泛型是如何编译的

5.1擦除机制

（图片来源于网上，如有侵权，请联系删除）
在编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制。
Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息

6.泛型的上界

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

class Alg<T extends Comparable<T>>{
        public T findMaxVal(T[] array){
            T max = array[0];
            for (int i = 1; i <array.length ; i++) {
                if (array[i].compareTo(max)> 0){
                    max = array[i];
                }
            }
            return max;
        }
    }

7.泛型方法

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

```java
class Alg2 {
    public <T extends Comparable<T>> T findMaxVal(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}

你也可以将方法用static修饰，这样就可以不用实例化对象，如下代码：

class Alg3{
        public static <T extends Comparable<T>> T findMaxVal(T[] array){
            T max = array[0];
            for (int i = 1; i <array.length ; i++) {
                if (array[i].compareTo(max)> 0){
                    max = array[i];
                }
            }
            return max;
        }
    }
     public static void main3(String[] args) {
        Integer[] array = {1,2,3,4,5};
        System.out.println(Alg3.findMaxVal(array));
        System.out.println(Alg3.<Integer>findMaxVal(array));
    }