java泛型

最新推荐文章于 2024-05-29 23:10:16 发布

程序三两行

最新推荐文章于 2024-05-29 23:10:16 发布

阅读量1k

点赞数

分类专栏： # java基础语法文章标签： java 算法数据结构

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/qq_34491508/article/details/127125768

版权

java基础语法专栏收录该内容

43 篇文章 3 订阅

订阅专栏

一、泛型概述

1、泛型本质

泛型就是定义一种模板，例如ArrayList<T>，只有在使用的时候才能决定T是什么类型，比如ArrayList<String>,未使用之前只是一种参数类型，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

2、泛型好处

毫不夸张的说，泛型是通用设计上必不可少的元素，所以真正理解与正确使用泛型，是一门必修课。

那使用泛型有哪些好处呢？

（1）保证了类型的安全性。

在没有泛型之前，从集合中读取到的每一个对象都必须进行类型转换，如果不小心插入了错误的类型对象，在运行时的转换处理就会出错。

（2）消除强制转换

泛型的一个附带好处是，消除源代码中的许多强制类型转换，这使得代码更加可读，并且减少了出错机会。

（3）避免了不必要的装箱、拆箱操作，提高程序的性能

在非泛型编程中，将筒单类型作为Object传递时会引起Boxing（装箱）和Unboxing（拆箱）操作，这两个过程都是具有很大开销的。引入泛型后，就不必进行Boxing和Unboxing操作了，所以运行效率相对较高，特别在对集合操作非常频繁的系统中，这个特点带来的性能提升更加明显。

泛型变量固定了类型，使用的时候就已经知道是值类型还是引用类型，避免了不必要的装箱、拆箱操作。

object a=1;//由于是object类型，会自动进行装箱操作。
 
int b=(int)a;//强制转换，拆箱操作。这样一去一来，当次数多了以后会影响程序的运行效率。

使用泛型

public static T GetValue<T>(T a)
 
{
　　return a;
}
 
public static void Main()
 
{
　　int b=GetValue<int>(1);//使用这个方法的时候已经指定了类型是int，所以不会有装箱和拆箱的操作。
}

（4）提高了代码的重用性。

二、泛型类

泛型类：把泛型定义在类上

定义格式：

public class 类名 <泛型类型1,...> {
    
}

注意事项：泛型类型必须是引用类型（非基本数据类型）

定义泛型类，在类名后添加一对尖括号，并在尖括号中填写类型参数，参数可以有多个，多个参数使用逗号分隔：

public class P<ab,a,c> {}

当然，这个后面的参数类型也是有规范的，不能像上面一样随意，通常类型参数我们都使用大写的单个字母表示：
T：任意类型 type
E：集合中元素的类型 element
K：key-value形式 key
V： key-value形式 value

public class P <T>{
    public T name;

    public T getName() {
        return name;
    }

    public void setName(T name) {
        this.name = name;
    }
}


    public static void main(String[] args) {
        P<String> p = new P<>();
        p.setName("test123");
        System.out.println(p.getName());

        P<Integer> p1 = new P<>();
        p1.setName(123);
        System.out.println(p1.getName());

    }

三、泛型接口

泛型接口与泛型类的定义及使用基本相同

定义格式：修饰符 interface接口名<代表泛型的变量> { }

/**
 * 定义一个泛型接口
 */
public interface GenericsInteface<T> {
    public abstract void add(T t); 
}

//实现类

public class GenericsImp<T> implements GenericsInteface<T> {
    @Override
    public void add(T t) {
        System.out.println("没有设置类型");
    }
}

//test

public class GenericsTest {
    public static void main(String[] args) {
        GenericsImp<Integer> gi = new GenericsImp<>();
        gi.add(66);
    }
}

例如，Arrays.sort(Object[])可以对任意数组进行排序，但待排序的元素必须实现Comparable<T>这个泛型接口：

public interface Comparable<T> {
    /**
     * 返回负数: 当前实例比参数o小
     * 返回0: 当前实例与参数o相等
     * 返回正数: 当前实例比参数o大
     */
    int compareTo(T o);
}

可以直接对String数组进行排序：

String[] ss = new String[] { "Orange", "Apple", "Pear" };
Arrays.sort(ss);
System.out.println(Arrays.toString(ss));

这是因为String本身已经实现了Comparable<String>接口。如果换成我们自定义的Person类型试试：

class Person {
    String name;
    int score;
    Person(String name, int score) {
        this.name = name;
        this.score = score;
    }
    public String toString() {
        return this.name + "," + this.score;
    }
}

运行程序，我们会得到ClassCastException，即无法将Person转型为Comparable。我们修改代码，让Person实现Comparable<T>接口：再次运行查看可以正确实现按name进行排序。

四、泛型方法

泛型方法，是在调用方法的时候指明泛型的具体类型。

定义格式：修饰符 <代表泛型的变量> 返回值类型方法名(参数){ }

/**
     *
     * @param t 传入泛型的参数
     * @param <T> 泛型的类型
     * @return T 返回值为T类型
     * 说明：
     *   1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
     *   2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
     *   3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
     *   4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E等形式的参数常用于表示泛型。
     */
    public <T> T genercMethod(T t){
        System.out.println(t.getClass());
        System.out.println(t);
        return t;
    }
 
 
public static void main(String[] args) {
    GenericsClassDemo<String> genericString  = new GenericsClassDemo("helloGeneric"); //这里的泛型跟下面调用的泛型方法可以不一样。
    String str = genericString.genercMethod("hello");//传入的是String类型,返回的也是String类型
    Integer i = genericString.genercMethod(123);//传入的是Integer类型,返回的也是Integer类型
}
 
 
class java.lang.String
hello
 
 
class java.lang.Integer
123

五、泛型通配符

Java泛型的通配符是用于解决泛型之间引用传递问题的特殊语法, 主要有以下三类:

1. 无边界的通配符(Unbounded Wildcards), 就是<?>, 比如List<?>

无边界的通配符的主要作用就是让泛型能够接受未知类型的数据.

2. 固定上边界的通配符(Upper Bounded Wildcards)，采用<? extends E>的形式

使用固定上边界的通配符的泛型, 就能够接受指定类及其子类类型的数据。

要声明使用该类通配符, 采用<? extends E>的形式, 这里的E就是该泛型的上边界。

注意: 这里虽然用的是extends关键字, 却不仅限于继承了父类E的子类, 也可以代指显现了接口E的类

3. 固定下边界的通配符(Lower Bounded Wildcards)，采用<? super E>的形式

使用固定下边界的通配符的泛型, 就能够接受指定类及其父类类型的数据.。

要声明使用该类通配符, 采用<? super E>的形式, 这里的E就是该泛型的下边界.。

注意: 你可以为一个泛型指定上边界或下边界, 但是不能同时指定上下边界。

//表示类型参数可以是任何类型
public class Apple<?>{}
 
//表示类型参数必须是A或者是A的子类
public class Apple<T extends A>{}
 
//表示类型参数必须是A或者是A的超类型
public class Apple<T supers A>{}

上面这些泛型类定义中的泛型参数E、K和V都是什么意思呢？其实这些参数名称是可以任意指定，就想方法的参数名一样可以任意指定，但是我们通常会起一个有意义的名称，让别人一看就知道是什么意思。泛型参数也一样，E一般是指元素，用来集合类中。

常见泛型参数名称有如下：

E： Element (在集合中使用，因为集合中存放的是元素)
T：Type（Java 类）
K： Key（键）
V： Value（值）
N： Number（数值类型）
？：表示不确定的java类型

参考

https://blog.csdn.net/ChenRui_yz/article/details/122935621

JAVA泛型通配符T，E，K，V区别，T以及Class<T>，Class<?>的区别 - 简书 (jianshu.com)

Java 中的 T，E，K，V, 别傻傻分不清楚！_Java技术栈的博客-CSDN博客

六、泛型原理

泛型本质是将数据类型参数化，它通过擦除的方式来实现，即编译器会在编译期间「擦除」泛型语法并相应的做出一些类型转换动作。

看一个例子就应该清楚了，例如：

public class Caculate<T> {
private T num;
}

我们定义了一个泛型类，定义了一个属性成员，该成员的类型是一个泛型类型，这个 T 具体是什么类型，我们也不知道，它只是用于限定类型的。

反编译一下这个 Caculate 类：

public class Caculate{
public Caculate(){}
private Object num;
}

发现编译器擦除 Caculate 类后面的两个尖括号，并且将 num 的类型定义为 Object 类型。

那么是不是所有的泛型类型都以 Object 进行擦除呢？大部分情况下，泛型类型都会以 Object 进行替换，而有一种情况则不是。那就是使用到了extends和super语法的有界类型，如：
public class Caculate<T extends String> { private T num; }

这种情况的泛型类型，num 会被替换为 String 而不再是 Object。

这是一个类型限定的语法，它限定 T 是 String 或者 String 的子类，也就是你构建 Caculate 实例的时候只能限定 T 为 String 或者 String 的子类，所以无论你限定 T 为什么类型，String 都是父类，不会出现类型不匹配的问题，于是可以使用 String 进行类型擦除。

实际上编译器会正常的将使用泛型的地方编译并进行类型擦除，然后返回实例。但是除此之外的是，如果构建泛型实例时使用了泛型语法，那么编译器将标记该实例并关注该实例后续所有方法的调用，每次调用前都进行安全检查，非指定类型的方法都不能调用成功。

实际上编译器不仅关注一个泛型方法的调用，它还会为某些返回值为限定的泛型类型的方法进行强制类型转换，由于类型擦除，返回值为泛型类型的方法都会擦除成 Object 类型，当这些方法被调用后，编译器会额外插入一行 checkcast 指令用于强制类型转换，这一个过程就叫做『泛型翻译』

Java泛型不能使用基本类型

int[] array = new int[]{3, 10, 4, 0, 2};
System.out.println(Arrays.asList(array).contains(3)); //false

Integer arr[] = new Integer[]{3, 10, 4, 0, 2};
System.out.println(Arrays.asList(arr).contains(3)); //true