【Java--数据结构】提升你的编程段位：泛型入门指南，一看就会！

前言

泛型是一种编程概念，它允许我们编写可以适用于多种数据类型的代码。通过使用泛型，我们可以在编译时期将具体的数据类型作为参数传递给代码，从而实现代码的复用和灵活性。

在传统的编程中，我们通常需要为不同的数据类型编写不同的代码，这样会导致代码冗余和维护困难。而泛型的出现解决了这个问题，它使得我们可以编写一次代码，然后在需要的地方使用不同的数据类型进行实例化~

欢迎关注个人主页：逸狼

---

创造不易，可以点点赞吗~

如有错误，欢迎指出~

---

---

目录

前言

包装类

装箱

法一（过时方法）

法二（手动装箱）

法三（自动装箱）

拆箱

泛型

现在有一个需求

不使用泛型

使用泛型

泛型的上界

应用

泛型方法

泛型方法举例

泛型方法静态化

---

包装类

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

除了 Integer 和 Character， 其余基本类型的包装类都是首字母大写。

装箱

法一（过时方法）

法二（手动装箱）

    public static void main(String[] args) {
        int a=10;
//        Integer ii=new Integer(a);//该方法已过时
        Integer ii=Integer.valueOf(a);//将基本类型int变为引用类型Integer  
    }

法三（自动装箱）

Integer ii=a;

拆箱

    public static void main(String[] args) {
        Integer ii=10;//自动装箱
        int a=ii;//自动拆箱
        int aa=ii.intValue();//手动拆箱
    }

泛型

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

泛型是在JDK1.5引入的新的语法。用于把类型参数化。将类型以参数的形式进行传递。

所有类的父类默认都是Object类

现在有一个需求

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

不使用泛型

class MyArray{
    public Object[] array=new Object[10];
    public void setArray(int pos,Object x){
        array[pos]=x;
    }
    public Object getVal(int pos){
        return array[pos];
    }
}
 
 
public class Test {
    public static void main(String[] args) {
        MyArray myArray=new MyArray();
        myArray.setArray(0,1);
        myArray.setArray(1,20);
        myArray.setArray(2,"hello");
        String s=(String)myArray.getVal(2);
//getVal的返回类型是Object类，而接收的类型是String类型，要强制转换为String类型，否则会报错
        System.out.println(s);
    }
}

任何类型的数据在这里都可以存放，但是当数组的元素过多时，每一个元素都要强制类型转换就显得不方便了。

虽然在这种情况下，当前数组任何数据都可以存放，但是，更多情况下，我们还是希望他只能够持有一种数据类 型。而不是同时持有这么多类型。所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译 器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。

使用泛型

class MyArray<T> {//在类的后面加上<>  ,<T>代表占位符，表示当前类是一个泛型类
    public Object[] array = new Object[10];
 
    public void setArray(int pos, T x) {
        array[pos] = x;
    }
 
    public T getVal(int pos) {
        return (T) array[pos];
    }
}
public class Test {
    public static void main(String[] args) {
        //<Integer>代表传的数据类型是整形类型，
        // 后面的MyArray<>可以不写Integer，编译器会通过前面的推导，但是要加上<>
        MyArray<Integer> myArray=new MyArray<>();
        //只能写类 类型，不能写简单类型
        //MyArray<int> myArray=new MyArray<>();//err
 
        myArray.setArray(0,1);
        myArray.setArray(1,2);
        //编译的时候，每次存储x值，会检查是否是指定的数据类型，若不一样，会报错
//        myArray.setArray(1,"hello");
// 这里不需要进行强制类型转换，因为放数据的时候就进行了严格的检查
        Integer x= myArray.getVal(1);
        MyArray<String> myArray2=new MyArray<>();
        myArray2.setArray(0,"hewsa");
 
        System.out.println(myArray2.getVal(0));
    }

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

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

泛型的编译——擦除机制

擦除机制：在编译的过程当中，将所有的T替换为Object这种机制。 Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。

泛型的上界

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

语法

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

例如下面代码表示 只接受 Number 的子类型作为 E 的类型实参

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

应用

定义一个泛型类，用于找到数组中最大值

//定义一个泛型类，找到数组中最大值
class Alg<T extends Comparable<T>>{//表示传的泛型都是要实现Comparable接口的
    public T findMax(T[]array){
        T max=array[0];
        for (int i = 0; i < array.length; i++) {
//            if(array[i]>max){//引用类型不能直接比较，会报错，要实现comparable接口比较
            if(array[i].compareTo(max)>0){
                max=array[i];
            }
        }
        return max;
    }
}
public class Test {
    public static void main(String[] args) {
        Alg<Integer> alg=new Alg<>();
        Integer [] array={1,2,3,4,5,6,7};
        Integer x =alg.findMax(array);
        System.out.println(x);
    }

结果：7

泛型方法

泛型方法举例

class Alg2{
    //泛型方法
    public<T extends Comparable <T>> T findMax(T[]array){
        T max=array[0];
        for (int i = 0; i < array.length; i++) {
            if(array[i].compareTo(max)>0){
                max=array[i];
            }
        }
        return max;
    }
}
public class Test {
    public static void main(String[] args) {
        Alg2 alg2 =new Alg2();
        Integer[] array={1,2,3,4,5,6,7};
//        Integer x =alg2.<Integer>findMax(array);
        Integer x =alg2.findMax(array);//不写<Integer>也行，编译器会通过前面来推导
        System.out.println(x);
    }

泛型方法静态化

class Alg3{
    //泛型方法静态化 相较于泛型方法，只是加了static而已
    public static <T extends Comparable <T>> T findMax(T[]array){
        T max=array[0];
        for (int i = 0; i < array.length; i++) {
            if(array[i].compareTo(max)>0){
                max=array[i];
            }
        }
        return max;
    }
}
public class Test {
    public static void main(String[] args) {
        Integer[] array={1,2,3,4,5,6,7};
        Integer x =Alg3.findMax(array);//静态方法直接通过类名调用
        System.out.println(x);
    }