数据结构与算法：泛型初学习

Monody·

已于 2023-01-06 19:39:03 修改

阅读量262

点赞数

分类专栏： 0基础学算法文章标签：学习 java jvm 算法

于 2023-01-06 16:19:11 首次发布

本文链接：https://blog.csdn.net/m0_66030479/article/details/128580179

版权

0基础学算法专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.包装类

java中的数据类型int，double等不是对象，无法通过向上转型获取到Object提供的方法，而像String却可以，只因为String是一个对象而不是一个类型。基本数据类型由于这样的特性，导致无法参与转型，泛型，反射等过程。为了弥补这个缺陷，java提供了包装类。

1.基本数据类型和对应的包装类

在这里插入图片描述
除了 Integer 和 Character，其余基本类型的包装类都是首字母大写。

下面是包装类型的继承结构图。

在这里插入图片描述

2.装箱和拆箱

装箱操作，新建一个 Integer 类型对象，将 i 的值放入对象的某个属性中。
拆箱操作，将 Integer 对象中的值取出，放到一个基本数据类型中。

public class TestDemo {
    public static void main2(String[] args) {
        Integer val1 = 10;
        int a = val1;//拆箱 ——> 引用类型拆箱为了基本数据类型
        System.out.println(a);
        int b = val1.intValue();//显示拆箱
        System.out.println(b);

        Double d = val1.doubleValue();//显示拆箱
        System.out.println(d);
    }

    public static void main1(String[] args) {
        int a = 10;
        //Integer val = a; //装包 把基本数据类型变为对应的包装类型(自动装箱)
        Integer val = Integer.valueOf(a);//显示装箱
        Integer val2 = new Integer(a);//显示装箱

        System.out.println(val);
    }
}

2.泛型的定义

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

3.泛型语法

就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。
语法结构：

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

注意：

类名后的代表占位符，表示当前类是一个泛型类。

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

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

不能new泛型类型的数组。
类型后加入指定当前类型。
不需要进行强制类型转换。
代码编译报错，指定类当前的类型，编译器会在存放元素的时候帮助我们进行类型检查。

4.泛型类的使用

泛型类<类型实参> 变量名; // 定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

MyArray<Integer> list = new MyArray<Integer>();

注意：泛型只能接受类，所有的基本数据类型必须使用包装类！

当编译器可以根据上下文推导出类型实参时，可以省略类型实参的填写：

MyArray<Integer> list = new MyArray<>(); // 可以推导出实例化需要的类型实参为 Integer

5.泛型的编译机制（擦除机制）

Java在编译后的字节码（.class）文件中是不包含泛型中的类型信息的，使用泛型的时候加上的类型参数，会在编译的时候被擦除，这个过程就叫做类型擦除机制。

泛型会被擦除，并且还将类型参数全都擦成了Object这个具体的类型。

为什么会被擦成object呢？

原来，在JDK5.0之前，容器存储的对象都只有具有Java的通用类型:Object。单根继承结构意味着所有的东西都是Object类型，所以该容器可以存储任何东西（就像我们最开始写的代码一样，可以存，但取会报错），但是由于容器只存储Object，所以当将对象引入容器时，他必须被向上转型成Object。

6.泛型的上界

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

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

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

7.泛型方法

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

8.代码小结

class MyArray<E> {
    //<T>代表当前类是一个泛型类
    public Object[] obj = new Object[3];
    //public E[] obj = (E[]) new Object[3];

    public E getPos(int pos) {
        return (E) obj[pos];
    }

    public void setObj(int pos,E val) {
        obj[pos] = val;
    }

}

public class Test {

    public static void main(String[] args) {

    }

    public static void main1(String[] args) {
        //实例化对象的同时指定当前泛型类的指定参数类型是Integer
        //指定的参数类型必须是一个引用类型不能是基本类型(int,double....)
        MyArray<Integer> myArray = new MyArray<Integer>();



        //此时存取数据的时候，什么数据都可以存储，获取数据的时候必须得强转
        myArray.setObj(0,10);
        myArray.setObj(1,23);
        myArray.setObj(2,55);

        Integer d = myArray.getPos(2);

        System.out.println("==================");

        MyArray<String> myArray2 = new MyArray<>();

        myArray2.setObj(0,"wjh");
        myArray2.setObj(1,"hello");
        myArray2.setObj(2,"world");

        myArray2.getPos(1);

        /*泛型帮我们解决了:
        1.存取数据的时候,可以帮我们进行自动的类型检查 -> 编译 -> 编译时期的一种机制，在运行的时候没有泛型的概念
        2.获取元素的时候,可以帮我们进行类型的转换*/

        //泛型当中，不能去实例化一个泛型类型的数组
    }
}
class A<E extends Number> {

}

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

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


class Agg<E extends Comparable<E>> {
    public E findMax(E[] arr) {
        E max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(max.compareTo(arr[i]) < 0) {
                max = arr[i];
            }
        }
        return max;
    }
}
public class Test2 {

    public static void main(String[] args) {
        Integer[] arr = {1,2,3,4,77,5,4};
        Integer val = Agg3.findMax(arr);
        System.out.println(val);
    }

    public static void main3(String[] args) {
        Agg2 agg2 = new Agg2();
        Integer[] arr = {1,2,3,4,77,5,4};
        Integer val = agg2.findMax(arr);
        System.out.println(val);
    }

    public static void main2(String[] args) {
        A<Number> a1 =new A<>();
        A<Integer> a2 =new A<>();
        A<Double> a3 =new A<>();
    }

    public static void main1(String[] args) {
        Agg<Integer> agg = new Agg<>();
        Integer[] arr = {1,3,2,4,5,6,7,8};
        Integer val = agg.findMax(arr);
        System.out.println(val);
    }
}