Java集合框架|泛型知识点全面详解

最新推荐文章于 2024-11-09 12:43:52 发布
最新推荐文章于 2024-11-09 12:43:52 发布
阅读量515 收藏
点赞数
分类专栏： JavaSE基础 文章标签： java 泛型 集合 经验分享 javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hunny_java/article/details/121941452
版权

注：本篇属于Colletion体系插曲，主要目的是全方位梳理泛型的知识点

目录

泛型的概念

  • 泛型，即"参数化类型"，也就是说所操作的数据类型被指定为一个参数。

泛型的特性

  • 泛型只是在java的编译期会产生错误，但是在java的运行期(已经生成字节码文件后)是会被擦除的，这个期间并没泛型的存在。
//传入的类型需与泛型的类型参数相同
public class GenericTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        //list.add("HelloWorld"); 编译报错
    }
}

public class GenericTest {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        //获取ArrayList的字节码文件
        Class clazz = Class.forName("java.util.ArrayList");
        //获取add() 方法，Object.class 代表任意对象类型的数据
        Method m = clazz.getMethod("add", Object.class);
        m.invoke(list,"HelloWorld");//通过反射添加字符串类型元素数据
        System.out.println(list);
    }
}
//输出结果：[1, 2, HelloWorld]

泛型的使用

泛型类

泛型类的基本格式

class 类名称 <泛型标识>{
   ......
}

泛型类的注意事项

  • 在Java泛型中，T 是类型形参，当我们调用的时候，则传入的是类型实参。
  • T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
  • 在实例化泛型类时，必须指定T的具体类型。
  • 在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。
class Person<T>{
    private T height;
    public Person(T height) {
        this.height = height;
    }
    public T getHeight() {
        return height;
    }
    public void setHeight(T height) {
        this.height = height;
    }
}
public class GenericTest {
    public static void main(String[] args)  {
        //因为是Integer类型 所以传入的实参应该是int类型。下面同理
        Person<Integer> person1=new Person<>(180);
        Person<String> person2=new Person<>("180");
        //在使用泛型类的时候不一定要传入泛型实参
        Person person3=new Person(180.5);
        System.out.println(person3.getHeight());
        Person person4=new Person("180厘米");
        System.out.println(person4.getHeight());
    }
}

泛型接口

泛型接口的基本格式

public interface 接口名称 <T> {
    ......
}

泛型接口的注意事项

  • 在子类定义的时候继续使用泛型
interface behavior <T> {
    String cry= "正在哭";
    //T run = "正在跑"; 编译报错，因为在接口中，public static final常量需赋值，所以必须确定类型
    void shout(T key);
}
class Animal<T,V> implements behavior<T>{
    V name;
    T age;
    public Animal(V name, T age) {
      this.name = name;
      this.age = age;
    }
    @Override
    public void shout(T key) {
      System.out.println("姓名:"+name+"，年龄:"+age+"，行为:"+key);
    }
}
public static void main(String[] args)  {
    Animal<String,String> animal=new Animal<>("小狗","6岁");
    animal.shout("正在大叫");
}
//输出结果：
姓名:小狗，年龄:6岁，行为:正在大叫
  • 在子类实现接口的时候明确给出类型
interface behavior <T> {
    String cry= "正在哭";
    //T run = "正在跑"; 编译报错，因为在接口中，public static final常量需赋值，所以必须确定类型
    void shout(T key);
}
class Teacher<V> implements behavior<String>{
    V name;
    public Teacher(V name) {
        this.name = name;
    }
    @Override
    public void shout(String key) {
        System.out.println(name+"正在"+key);
    }
}
public static void main(String[] args)  {
        Teacher<String> teacher=new Teacher<>("赵老师");
        teacher.shout("上课");
    }
//输出结果：
赵老师正在上课

泛型通配符

协变、逆变和不变
  • 逆变与协变用来描述类型转换（type transformation）后的继承关系，其定义：如果A、B表示类型，f(⋅)表示类型转换，≤表示继承关系（比如，A≤B表示A是由B派生出来的子类）
    • f(⋅)是**逆变（contravariant）**的，当A≤B时有f(B)≤f(A)成立；
    • f(⋅)是**协变（covariant）**的，当A≤B时有f(A)≤f(B)成立；
    • f(⋅)是**不变（invariant）**的，当A≤B时上述两个式子均不成立，即f(A)与f(B)相互之间没有继承关系。
数组的协变
  • 可以把数组的协变看成是多态，因为B是A的子类，所以相当于B[ ]是A[ ]的子类。
class A{ }
class B extends A{ }
class C extends A{ }
class D extends B{ }

public class GenericTest2 {
    public static void main(String[] args) {
 				A[] a1=new B[10]; //和多态一样，子类对象数组可以向上转型为父类对象数组的引用
        B[] b=(B[])a1;
        //D[] d=(D[])a1; java.lang.ClassCastException 类型转换错误

        //只能向数组b赋值B类
        b[0]=new B();
        //b[1]=new D();
        //b[2]=new A();
        //b[3]=new C();
        System.out.println("----------");

        //数组a1的各个元素可以赋值以B或者B的子类
        a1[0]=new B();
        a1[1]=new D();
        //a1[2]=new A(); java.lang.ArrayStoreException 将错误类型的对象存储到一个对象数组时抛出的异常
        //a1[3]=new C(); java.lang.ArrayStoreException 将错误类型的对象存储到一个对象数组时抛出的异常
        System.out.println("----------");

        //数组a2的各个元素可以赋值以A或者A的子类
        A[] a2=new A[10];
        a2[0]=new B();
        a2[1]=new C();
        a2[2]=new D();
    }
}
泛型的不变
  • 泛型是不变的，也就是说虽然B是A的子类，但是ArrayList< A >和ArrayList< B >之间并没有内建的协变类型。
class A{ }
class B extends A{ }
class C extends A{ }
class D extends B{ }

ArrayList<A> list1=new ArrayList<A>();
//ArrayList<A> list2=new ArrayList<B>(); 编译报错
通配符的协变和逆变

协变 <? extends T>
  • extends指出了泛型的上界为T，<? extends T>称为子类通配符(上界通配符)，<? extends A>意味着某个继承自A的具体类型。
  • <? extends T>不能往里存，只能往外取，取出来的东西只能存放在T或它的基类里。 
class A{ }
class B extends A{ }
class C extends A{ }
class D extends C{ }
class E extends B{ }
class F extends B{ }
class G extends E{ }

public static void main(String[] args) {
    //<? extends T>不能往里存，只能往外取
    ArrayList aim=new ArrayList();
    aim.add(new B());
    ArrayList<? extends B> al = new ArrayList<E>(aim);
    //al.add(new A()); 编译错误
    //al.add(new B()); 编译错误
    //al.add(new C()); 编译错误
    //al.add(new D()); 编译错误
    //al.add(new E()); 编译错误
    //al.add(new F()); 编译错误
    //al.add(new G()); 编译错误

    //<? extends T>取出来的东西只能存放在T或它的基类里
    //所以<? extends B>只能放在B或它的基类里
    B newB=al.get(0);
    A newA=al.get(0);
    //C newc=al.get(0); 编译报错
    Object newObject=al.get(0);
    System.out.println("newB:"+newB);
    System.out.println("newA:"+newA);
    System.out.println("newObject:"+newObject);
}
//输出结果：
newB:javabase.javagather.B@5cad8086
newA:javabase.javagather.B@5cad8086
newObject:javabase.javagather.B@5cad8086
逆变 <? super T>
  • super指出泛型的下界为T，<？ super T>称为超类通配符，<? extends B>代表一个具体类型，而这个类型是B的超类。
  • <? super T>往里存只能存T或T的子类，往外取只能放在Object对象里。 
class A{ }
class B extends A{ }
class C extends A{ }
class D extends C{ }
class E extends B{ }
class F extends B{ }
class G extends E{ }

public static void main(String[] args) {
    //因为<? super B>说明必须是B或者B的父类
    //所以等式右边可以是new ArrayList<A>()或new ArrayList<B>()
    ArrayList<? super B> b1 = new ArrayList<A>();

    //<? super T>往里存只能存T或T的子类
    //所以<? super B>只能添加B或B的子类
    //b1.add(new A()); 编译错误
    b1.add(new B());
    //b1.add(new C()); 编译错误
    //b1.add(new D()); 编译错误
    b1.add(new E());
    b1.add(new F());
    b1.add(new G());

    //<? super T>往外取只能放在Object对象里
    //B newB=b1.get(0); 编译错误
    //A newA=b1.get(0); 编译错误
    Object newObject=b1.get(0);
    System.out.println("newObject:"+newObject);
    System.out.println("--------------");

    //因为<? super D>说明等式右边必须是D或者D的父类
    //所以等式右边可以是new ArrayList<A>()、new ArrayList<C>()或new ArrayList<D>()
    ArrayList<? super D> b2 = new ArrayList<C>();

    //<? super T>往里存只能存T或T的子类
    //所以<? super D>所以只能添加D或D的子类
    //b2.add(new A()); 编译错误
    //b2.add(new B()); 编译错误
    //b2.add(new C()); 编译错误
    b2.add(new D());
    //b2.add(new E()); 编译错误
    //b2.add(new F()); 编译错误
    //b2.add(new G()); 编译错误

    //<? super T>往外取只能放在Object对象里
    //B newB=b1.get(0); 编译错误
    //A newA=b1.get(0); 编译错误
    Object newObject2=b2.get(0);
    System.out.println("newObject2:"+newObject2);
}
//输出结果：
newObject:javabase.javagather.B@5cad8086
--------------
newObject2:javabase.javagather.D@6e0be858
通配符?的其他使用
public class GenericTest3 {
    public static void main(String[] args) {
        infor(new Worker<Number>(100));
        infor(new Worker<Integer>(200));
    }
    //通配符?解决当具体类型不确定的时候
    public static void infor(Worker<?> workers){
        System.out.println("电子厂工人总数"+workers.num+"人");
    }
}
class Worker<T>{
    T num;
    public Worker(T num) {
        this.num = num;
    }
}
//输出结果：
电子厂工人总数100人
电子厂工人总数200人

泛型方法

泛型方法的基本格式

//<T>必不可少，这表明这是一个泛型方法
public <T> T 方法名(){
		......
}
//可以这样
public <T,K> T 方法名(泛型类<K> obj){
		......
}

泛型类中的泛型方法

class Elephant<T,K>{
    T name;
    K age;
    public Elephant(T name, K age) {
        this.name = name;
        this.age = age;
    }
    //可以创建完泛型方法，但不使用<U>
    public <U> void show2(){
        System.out.println("start...");
    }
    //Elephant<T>的T和此泛型方法的T不是一个T
    public <T> void show(Elephant<T,K> elephant){
        System.out.println(elephant.name+"，年龄"+elephant.age+"岁，健康状态良好");
    }
    //泛型方法中有可变参数
    public <T> void show3(T...args){
        for (T arg : args) {
            System.out.println(arg);
        }
        System.out.println("end....");
    }
}
public static void main(String[] args) {
    Elephant<String,Integer> e=new Elephant<>("大壮",6);
    e.show2();
    e.show(e);
    e.show3(1,2);
}
//输出结果：
start...
大壮，年龄6岁，健康状态良好
1
2
end....

泛型和静态方法

  • 静态方法不能访问类中定义的泛型。
  • 如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法
class Doctor<T>{
    T name;
/*    public static void show(){ //编译报错
        System.out.println(name);
    }
*/
/*    public static void show(T age){ //编译报错
        System.out.println();
    }
*/
    public static <U> void show(U doctorName){
        System.out.println(doctorName+"医生已到岗");
    }
}
public static void main(String[] args) {
   Doctor.show("小月");
}
//输出结果：
小月医生已到岗

不能实例化一个参数化类型的数组

  • 什么叫参数化类型的数组？就是这个数组里存储的对象是参数化类型，比如说ArrayList< String >就是一个类型参数为String的参数化类型，我们在Java中也称呼它为泛型。
public static void main(String[] args) {
    //ArrayList<String>[] arrayList=new ArrayList<String>[10]; 编译报错
}
  • 由于泛型具有擦除机制，在运行时的类型参数会被擦除，对于Java的数组来说，他必须知道它持有的所有对象的具体类型，而泛型的这种运行时擦除机制违反了数组安全检查的原则。
  • 如何解决这种情况呢？我们可以通过创建一个非参数化类型的数组，然后将他强制类型转换为一个参数化类型数组。
public class GenericArray {
    public static void main(String[] args) {
        //Cat<String>[] cat = new Cat<String>[10]; 编译报错
        Cat<String>[] cat;
        Cat[] c=new Cat[10];
        cat=(Cat<String>[])c;
        cat[0]=new Cat<String>("小花");
        System.out.println(cat[0].getName());
    }
}
class Cat<T>{
    T name;
    public T getName() {
        return name;
    }
    public Cat(T name) {
        this.name = name;
    }
}

Hi, welcome to JasperのBlog！

I'm Jasper
关注
专栏目录
Java集合框架、泛型知识点
weixin_43413602的博客
05-09 313
集合 Collection 集合接口： 主要方法： 1、boolean add(Object o)添加对象到集合 2、boolean remove(Object o)删除指定的对象 3、int size()返回当前集合中元素的数量 4、boolean contains(Object o)查找集合中是否有指定的对象 5、boolean isEmpty()判断集合是否为空 6、Iterator it...
Collection泛型
tangiwang的博客
02-03 238
day02【Collection、泛型】 主要内容 Collection集合 迭代器 增强for 泛型 教学目标 能够说出集合与数组的区别 说出Collection集合的常用功能 能够使用迭代器对集合进行取元素 能够说出集合的使用细节 能够使用集合存储自定义类型 能够使用foreach循环遍历集合 能够使用泛型定义集合对象 能够理解泛型上下限 能够阐述泛型通配符的作用 第一章 Collection集合 1.1 集合概述 在前面基础班我们已经学习过并使用过集合ArrayList ,那
Java 中的泛型（两万字超全详解）
热门推荐
林二月的博客
08-02 8万+
博主将用 CSDN 记录 Java 后端开发学习之路上的经验，并将自己整理的编程经验和知识分享出来，希望能帮助到有需要的小伙伴。博主也希望和一直在坚持努力学习的小伙伴们共勉！唯有努力钻研，多思考勤动手，方能在编程道路上行至所向。由于博主技术知识有限，博文中难免会有出错的地方，还望各位大佬包涵并批评指正，博主会及时改正；如果本文对小伙伴你有帮助的话，求求给博主一个赞支持一下，可以一起交流，一起加油！！Java泛型详解，史上最全图文详解java 泛型全解 - 绝对最详细Java 泛型，你了解类型擦除吗。
Java 中的泛型详解
XuChaofafa的博客
05-29 1289
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参列表，普通方法的形参列表中，每个形参的数据类型是确定的，而变量是一个参数。在调用普通方法时需要传入对应形参数据类型的变量（实参），若传入的实参与形参定义的数据类型不匹配，则会报错。那参数化类型是什么？以方法的定义为例，在方法定义时，将方法签名中的形参的数据类型也设置为参数（也可称之为类型参数），在调用该方法时再从外部传入一个具体的数据类型和变量。
Day17 Java 集合和泛型.pdf
08-09
Java集合框架是Java编程语言中用于存储和...本知识点通过介绍Java中Map接口及其常见实现类，详细阐述了Map的核心概念、操作方法和不同实现类的特性和应用场景，对于Java集合框架的学习者来说，是不可或缺的基础知识。
Java泛型与集合框架详解
什么是Java泛型（Introduction to Java Generics） ## 1.1 泛型的概念和作用 Java泛型是Java语言中一种强大的特性，它通过参数化类型的方式在编译时提供更好的类型检查和类型安全，并且使代码更具可读性和可复用...
Java集合框架与泛型详解
Iefegend的专栏
08-25 781
一、java集合框架 1、集合类与容器 为什么出现集合类？ 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就要对对象进行存储，集合就是存储对象最常用的一种方式。 数组和集合类同是容器，有何不同？ 数组元素既可以是基本数据类型的数据，也可以是引用数据类型的数据。而集合里只能存储引用数据类型。 数组一旦定义后，长度不可变。而集合的长...
Java泛型与集合操作详解
本资源主要涵盖了Java集合框架的相关内容，包括数组、泛型、Box类的使用以及迭代器和集合容器的基本操作。以下是对这些知识点的详细解析： 1. 引用类型与实际存储类型：Java中的数组引用类型（如`Animal[]`）实际上...
Java集合框架与泛型(简单易懂)
Manofletters的博客
01-02 109
封装好的数据结构的泛型容器
Java基础：集合框架详解- TreeSet、二叉树与泛型【13节视频】
整个课程以实践为主，理论讲解与实例演示相结合，旨在帮助初学者牢固掌握Java集合框架的核心概念，为后续的高级开发打下坚实基础。视频课件提供云盘下载链接（http://pan.baidu.com/s/1dEoPNDf）和本地下载链接...
JAVA-01-变量
LJH_laura_li的博客
11-08 325
在方法、构造函数或块内部定义的变量。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 634
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
最新发布
chusheng1840的博客
11-09 822
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 324
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
在 C# 中，如何实现观察者模式？
Leo的博客
11-06 431
观察者模式是一种设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当该主题对象的状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。这个模式常用于事件处理系统、通知系统等场景。
并发编程的基础：深入理解内存屏障（Memory Barriers）
2401_86353562的博客
11-06 993
内存屏障是一种基础语言，在不同的计算机架构下有不同的实现细节。本文主要在x86_64处理器下，通过Linux及其内核代码来分析和使用内存屏障对大多数应用层开发者来说，“内存屏障”（memory Barrier）是一种陌生，甚至有些诡异的技术。实际上，他机制常被用在操作系统内核中，用于实现同步、驱动程序利用它，能够实现高效的无锁数据结构，提高多线程程序的性能表现。本文首先探讨了内存屏障的必要性，之后介绍如何利用内存屏障实现一个无锁唤醒振荡器（队列），用于在多个线程间进行高效的数据交换。
greendao使用封装
白高林的专栏
11-07 437
greenDAO
Tomcat 启动卡住，日志显示 At least one JAR was scanned for TLDs yet contained no TLDs.
jiangshanwe
11-06 338
Tomcat 启动后，控制台输出卡在了：因为应用一直没有成功，并且控制台输出上述信息后就停止了，就理所应当的以为卡住的原因就是它，然后疯狂的百度/谷歌/GPT关键字，各种方法都试过了，但是都没有效果，还是卡着不动。使用获取当前 Java 进程的堆栈信息，发现是应用本身卡在了 *** 连接上，和 Tomcat 最后卡住的日志无任何关系。日志和问题，有时候并不是因果。程序没有反应，jstack 往往是最有力的工具。
快速排序的深入优化——三路划分，内省排序（C语言）
2401_83456040的博客
11-06 372
决定快排性能的关键点是每次单趟排序后，key对数组的分割，如果每次选key基本⼆分居中，那么快 排的递归树就是颗均匀的满⼆叉树，性能最佳。但是实践中虽然不可能每次都是⼆分居中，但是性能 也还是可控的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值