数据结构☞泛型-EW帮帮网

一.基础定义与应用方向

1.定义：

一般的类和方法，只能使用具体的类型 : 要么是基本类型，要么是自定义的类。如果要编写可以 应用于多种类型 的代码，这种刻板的限制对代码的束缚就会很大。----- 来源《 Java 编程思想》对泛型的介绍。

2.例如：

实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？

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);
    }
}

注意：这样写虽然基本数据类型都可以传入在传出，但是对于引用类型数据就不行会出现报错。（原因在于确定传参类型为Object类，String类不能传）如果想避免这种情况，就要使用泛型。

二.泛型类的使用

1.泛型的基本格式

class 泛型类名称<类型形参列表> {
// 这里可以使用类型参数
}

class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数 */ {
// 这里可以使用类型参数
}

泛型类名<类型实参> 变量名=new 泛型类<类型实参>(); // 实例化一个泛型类对象

注意：泛型只接受类，所以所有的基本数据类型都要写成其包装类。

MyArray<Integer> list = new MyArray<>(); // 可以推导出实例化需要的类型实参为 Integer所以后面的<>内可以不写类型实参。

2.例子泛型改写

class any<T>{
    public T[] object = (T[])new Object[10];//不加<T>打印的只能是object类存不了String类
    public void set (int a,T b){
        object[a]=b;
    }
    public  T get(int a){
        return object[a];
    }
}
public class TestDemo {
    public static void main(String[] args) {
    any<Integer>an=new any<>();//<>这样可以指定接下来传入的数据类型，编译器会自己进行检查非该
//类型报错
     an.set(1,3);
        System.out.println(an.get(1));
        String b="dasd";
        any<String>an2=new any<>();
        an2.set(2,b);
        System.out.println(an2.get(2));
    }
}

3注意：

（1. ）类名后的 <T> 代表占位符，表示当前类是一个泛型类

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

E 表示 Element

K 表示 Key

V 表示 Value

N 表示 Number

T 表示 Type

S, U, V 等等 - 第二、第三、第四个类型

（2.）不能单独 new 泛型类型的数组

（3.）不需要强制类型转换，使用泛型类中的方法返回值为T类型与接收类型不同时不用强转。

三.泛型方法的使用

1.语法：

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

示例：

public class Util {
//静态的泛型方法 需要在static后用<>声明泛型类型参数
public static <E> void swap(E[] array, int i, int j) {
E t = array[i];
array[i] = array[j];
array[j] = t;
}
}

四.泛型的上界

1.使用示例

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

...

}

public class MyArray < E extends Number > {

...

}//只接受 Number 的 子类型作为 E 的类型实参

2.复杂示例

public class MyArray < E extends Comparable < E >> {

...

}E 必须是实现了 Comparable 接口的

五.泛型编译过程

1.擦除机制

通过命令： javap -c 查看字节码文件，所有的 T 都是 Object 。

由此可见所有的泛型被替换成Object。Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。

总结：类型擦除是Java泛型的一个重要特性。它的核心是：

泛型信息仅在编译时存在：在编译阶段，Java会将泛型类型参数（如T）替换为它们的上下界。如果没有指定上下界，默认替换为Object。
运行时泛型信息被擦除：运行时，泛型类型参数（如T）会被擦除，只剩下原始类型。

关键点：

类型擦除并不是简单地把T替换为Object。它会根据上下界来决定替换的类型。当上下界改变时情况会发生变化。

有关泛型擦除机制的文章截介绍： https://zhuanlan.zhihu.com/p/51452375

2.为什么不能实例化泛型类型数组

原因：

Java不允许直接创建泛型数组：在Java中，泛型类型参数（如T）在运行时会被擦除，因此编译器无法确定T的具体类型，也就无法直接创建T[]类型的数组。
类型擦除的限制：由于类型擦除，运行时无法知道T的具体类型，因此无法分配正确的数组类型。

如果你希望创建一个泛型数组，可以通过以下方式绕过这个限制：

T[] ts = (T[]) new Object[5];

这里通过强制类型转换(T[])来创建一个Object[]数组，并将其赋值给T[]类型的变量。虽然这种方式可以编译通过，但它存在类型安全问题，可能会在运行时抛出ClassCastException。

六.类型推导：（即何时可以不用写<类型参数>）

1.使用：泛型可以自己推导自身的类型所以：

泛型类： MyArray < Integer > list = new MyArray <> (); // 可以推导出实例化需要的类型实参为 Integer所以后面的<>内可以不写类型实参。
使用泛型方法时：

//使用类型推导
Integer[] a = { ... };
swap(a, 0, 9);
String[] b = { ... };
swap(b, 0, 9);
//不使用：
Integer[] a = { ... };
Util.<Integer>swap(a, 0, 9);
String[] b = { ... };
Util.<String>swap(b, 0, 9);

拓展：

裸类型 (Raw Type)

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

MyArray list = new MyArray ();

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

下面的类型擦除部分，我们也会讲到编译器是如何使用裸类型的。

小结：

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

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

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

数据结构☞泛型