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

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量500 收藏
点赞数
分类专栏： 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
关注
专栏目录
Day17 Java 集合和泛型.pdf
08-09
Java集合框架是Java编程语言中用于存储和...本知识点通过介绍Java中Map接口及其常见实现类，详细阐述了Map的核心概念、操作方法和不同实现类的特性和应用场景，对于Java集合框架的学习者来说，是不可或缺的基础知识。
Java集合详解代码.zip
02-16
Java集合框架是Java编程语言中的一个...以上就是Java集合框架的基本概念和主要知识点，通过代码实现可以更直观地理解这些概念并应用于实际项目中。深入学习和熟练掌握这些内容对于成为一名专业的Java开发者至关重要。
Java集合框架、泛型知识点
weixin_43413602的博客
05-09 298
集合 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 213
day02【Collection、泛型】 主要内容 Collection集合 迭代器 增强for 泛型 教学目标 能够说出集合与数组的区别 说出Collection集合的常用功能 能够使用迭代器对集合进行取元素 能够说出集合的使用细节 能够使用集合存储自定义类型 能够使用foreach循环遍历集合 能够使用泛型定义集合对象 能够理解泛型上下限 能够阐述泛型通配符的作用 第一章 Collection集合 1.1 集合概述 在前面基础班我们已经学习过并使用过集合ArrayList ,那
Java 中的泛型（两万字超全详解）
热门推荐
林二月的博客
08-02 7万+
博主将用 CSDN 记录 Java 后端开发学习之路上的经验，并将自己整理的编程经验和知识分享出来，希望能帮助到有需要的小伙伴。博主也希望和一直在坚持努力学习的小伙伴们共勉！唯有努力钻研，多思考勤动手，方能在编程道路上行至所向。由于博主技术知识有限，博文中难免会有出错的地方，还望各位大佬包涵并批评指正，博主会及时改正；如果本文对小伙伴你有帮助的话，求求给博主一个赞支持一下，可以一起交流，一起加油！！Java泛型详解，史上最全图文详解java 泛型全解 - 绝对最详细Java 泛型，你了解类型擦除吗。
Java 中的泛型详解
XuChaofafa的博客
05-29 1210
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参列表，普通方法的形参列表中，每个形参的数据类型是确定的，而变量是一个参数。在调用普通方法时需要传入对应形参数据类型的变量（实参），若传入的实参与形参定义的数据类型不匹配，则会报错。那参数化类型是什么？以方法的定义为例，在方法定义时，将方法签名中的形参的数据类型也设置为参数（也可称之为类型参数），在调用该方法时再从外部传入一个具体的数据类型和变量。
java 1.8 泛型_Java 泛型详解
weixin_32211739的博客
02-16 1288
原标题：Java 泛型详解引言泛型是Java中一个非常重要的知识点，在Java集合类框架中泛型被广泛应用。本文我们将从零开始来看一下Java泛型的设计，将会涉及到通配符处理，以及让人苦恼的类型擦除。泛型基础 泛型类我们首先定义一个简单的Box类： 这是最常见的做法，这样做的一个坏处是Box里面现在只能装入String类型的元素，今后如果我们需要装入Integer等其他类型的元素，还必须要另外重写一...
JAVA集合框架知识点整理
weixin_46096297的博客
07-07 1004
集合整理
Java学习（七）泛型与集合
weixin_51760209的博客
04-12 1192
泛型与集合一、泛型1.泛型定义2.泛型的限制二、集合概述1.集合框架2.迭代器接口三、集合类1.Collection接口2.List 接口及其实现类3.Set 接口及其实现类4.Queue 接口及其实现类5.Map 接口及其实现类四、集合转换（了解）五、集合工具类（了解）后期扩展总结 一、泛型 1.泛型定义 泛型是将数据类型参数化，即在编写代码时将数据类型定义成参数，这些类型参数在使用之前再进行指明。 泛型提高了代码的重用性，使得程序更加灵活、安全和简洁。 JDK 5.0之前，为了实现参数类型的任意
Java集合知识详解
ggggggzzzzz的博客
07-19 445
Java集合详解
【Java基础系列教程】第十九章 Java集合框架详解
波哩个波的博客
03-15 1999
一、Java集合框架概述 二、集合框架层次结构 三、Collection接口方法 四、Iterator迭代器接口 五、Collection子接口之一：List接口 六、Collection子接口之二： Set接口 七、Map接口 八、集合总结 九、线程安全集合类 十、Comparable 和 Comparator 十一、Collections工具类 十二、面试题
Java泛型与集合框架详解
什么是Java泛型（Introduction to Java Generics） ## 1.1 泛型的概念和作用 Java泛型是Java语言中一种强大的特性，它通过参数化类型的方式在编译时提供更好的类型检查和类型安全，并且使代码更具可读性和可复用...
spring事务详细讲解-深入浅出
小电玩
09-08 497
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1481
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 548
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
基于SpringBoot的旅游管理系统
heye0910032的博客
09-08 475
随着科技的发展，旅游管理系统的信息化成为提升旅游服务效率的关键。本系统采用JSP技术和SpringBoot框架，结合MySQL数据库，旨在实现一个功能全面、操作简便、安全可靠的旅游管理平台。系统通过需求分析、系统设计、功能实现和测试，确保了良好的用户体验和数据处理能力，为旅游业务的现代化管理提供了强有力的技术支持。本研究成功开发了一个基于SpringBoot的旅游管理系统，该系统通过集成多种旅游管理功能，显著提高了旅游服务的效率和质量。系统的用户友好界面和强大的后端功能，使得管理员和用户都能从中受益。
自定义Stater
m0_63624484的博客
09-07 734
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值