数据结构之初识泛型

目录：

注意：在看泛型之前可以，回顾一下，包装类，包装类就是服务泛型的 ：初识JAVA中的包装类，时间复杂度及空间复杂度-CSDN博客

一.什么是泛型:  

二.引出泛型：

class My_array {
    public Object[] array = new Object[10];

    public Object getArray(int pos) {
        return array[pos];
    }

    public void setArray(int pos, Object val) {
        this.array[pos] = val;
    }
}

public class Test {
    public static void main0(String[] args) {
        My_array my_array = new My_array();
        //放置元素太乱，
        my_array.setArray(0, "haha");
        my_array.setArray(1, 2);

        //如果数据太多，每次返回，向下转型太麻烦
        String str = (String) my_array.getArray(0);
    }
}

三.泛型语法及，泛型类的使用和裸类型(Raw Type) 的了解

1.语法 ：下面给出一些泛型类的语法：

class 泛型类名称<类型形参列表> {
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> {
}




class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数 */ {
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> {
// 可以只使用部分类型参数
}

2.泛型类的使用：对引出泛型存在缺陷的，代码进行改写：

  
public static void main(String[] args) {

                //指定你要的类型
        My_array<Integer/*只能写类类型*/> my_array = new My_array</*Integer*/>();

//        my_array.setArray(0, "haha");//自动类型检查
        my_array.setArray(0, 2);

        Integer a =  my_array.getArray(0);//自动类型转换
        System.out.println(a);


        /**
         * 想给数组放你想要的类型
         */
        My_array<String> my_array1 = new My_array<>();
        my_array1.setArray(0, "haha");

        String str = my_a rray1.getArray(0);
        System.out.println(str);
    }

}

/**
 * 用泛型
 */
              //这个E相当于占位符
class My_array<E> {
    public Object[] array = new Object[10];

    public E getArray(int pos) {
        return (E) array[pos];
    }

    public void setArray(int pos, E val) {
        this.array[pos] = val;
    }
}

 注意：类名后的 <T> 代表占位符，表示当前类是一个泛型类，泛型只能接受类，所有的基本数据类型必须使用包装类！ 

总结：

1. 泛型是将数据类型参数化，进行传递

2. 使用 <T> 表示当前类是一个泛型类。

3. 泛型目前为止的优点：数据类型参数化，编译时自动进行类型检查和转换

   四.泛型的编译：

1. 擦除机制： 在Java虚拟机运行时，是不允许泛型 ，存在的，所以 在编译成字节码文件过程 中 会将所有的<E>替换为Object这种机制，我们称为：擦除机制。（可以到out目录，通过反汇编来查看） （命令：javap）

例子：下面这个代码中的，set方法的参数被擦除，为Object类：

class My_array<E> {
    public Object[] array = new Object[10];

    public E getArray(int pos) {
        return (E) array[pos];
    }

    public void setArray(int pos, E val) {
        this.array[pos] = val;
    }
}

   五.泛型的上界：

1.语法：这里用到extends关键字

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

2.来个例子：这里E继承了，Comparable接口，下面就可以使用，compareTo方法来，比较，

如果不规定这个边界，那么通过擦除机制，就不能直接比较。规定了边界，就有了方法来比较

class Alg<E extends Comparable<E>> {

   public E Find_Max(E[] array) {
       E max = array[0];
       for (int i = 0; i < array.length; i++) {
           if (max.compareTo(array[i]) < 0) {
               max = array[i];
           }
       }
       return max;
   }
}

public class Test {

    public static void main1(String[] args) {

        Integer[] array = new Integer[]{1,2,3,4,5,6};
        Alg<Integer> alg = new Alg<>();
        int ret = alg.Find_Max(array);//自动类型转换
        System.out.println(ret);

    }
}

这里还有一点值得注意：这里E继承了，Comparable接口，后没有重写，compareTo方法，因为你传的泛型参数（Integer）已经实现了Comparable接口，可以直接使用。

   六.泛型方法：

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

class Alg2 {
    public<E extends Comparable<E>>  E Find_Max(E[] array) {
        E max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }
}

  public static void main2(String[] args) {
        Alg2 alg2 = new Alg2();
        Integer[] array = new Integer[]{1,2,3,4,5,6};
        int ret = alg2./*<Integer>*/Find_Max(array);
        System.out.println(ret);
    }

2.静态泛型方法：可以不用每次，实例化对象去调用方法，因为静态行为，不依赖对象，可以直接用类名调用

代码如下：

class Alg3 {
    public static  <E extends Comparable<E>>  E Find_Max(E[] array) {
        E max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }
}

 /**
     * 泛型静态方法2:加static
     * 静态行为，不依赖对象，可以直接用类名调用（不用每次,new对象）
     */
    public static void main(String[] args) {

        Integer[] array = new Integer[]{1,2,3,4,5,6};
        int ret = Alg3./*<Integer>*/Find_Max(array);
        System.out.println(ret);
    }
}