Java-集合框架-泛型

最新推荐文章于 2024-05-20 11:32:04 发布
最新推荐文章于 2024-05-20 11:32:04 发布
阅读量110 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lwycc2333/article/details/88812215
版权

1. 泛型概述

泛型：JDK1.5版本以后出现的新特性，用于解决安全问题，是一个安全机制

  1. 方便程序员解决问题，让运行事情问题减少，安全。
  2. 避免了强制转换的麻烦
package collectionDemo;

import java.util.ArrayList;
import java.util.Iterator;

public class GenericDemo {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        // 定义了一个ArrayList容器，容器里面装的都是String类型的元素
        al.add("ab01");
        al.add("ab021");
        al.add("adc014");

        Iterator<String> it = al.iterator();
        while (it.hasNext()){
            //String s = (String)it.next();
            System.out.println(it.next().length());
        }
    }
}

输出结果：

4
5
6

2. 泛型使用

泛型格式：通过< >来定义要操作的引用数据类型

在使用java提供的对象时，什么时候写泛型呢？

  • 通常在集合框架中很常见，只要见到< >就要定义泛型。
  • 其实< >就是用来接收类型的
  • 当使用集合时，将集合中要存储的数据类型作为参数传递到< >中即可。
package collectionDemo;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class GenericDemo {
    public static void main(String[] args) {
        TreeSet<String> treeSet = new TreeSet<String>(new LenComparator());

        treeSet.add("abcd");
        treeSet.add("cc");
        treeSet.add("cba");

        Iterator<String> it = treeSet.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

class LenComparator implements Comparator<String>{
    public int compare(String s1, String s2){
        int len1 = s1.length(), len2 = s2.length();
        int num = len1-len2;
        if(num == 0)
            return s1.compareTo(s2);
        return num;
    }
}

输出：

cc
cba
abcd

3. 泛型类

什么时候定义泛型类？
当类中要操作的对象的引用数据类型不确定的时候，早期通过定义Object来完成扩展，
现在定义泛型来完成扩展。

泛型出现之前的做法：

package collectionDemo;

class Worker{

}

class Master{

}


// 泛型出现之前的做法，需要强转
class Tool{
    private Object obj;

    public void setWorker(Object obj) {
        this.obj = obj;
    }

    public Object getWorker() {
        return obj;
    }
}
public class GenericDemo1 {
    public static void main(String[] args) {

        Tool t = new Tool();
        t.setWorker(new Master());
        Worker w = (Worker)t.getWorker();
    }
}

结果：（编译成功，运行失败）

Exception in thread "main" java.lang.ClassCastException: collectionDemo.Master cannot be cast to collectionDemo.Worker
	at collectionDemo.GenericDemo1.main(GenericDemo1.java:29)

改进——泛型类

package collectionDemo;

class Worker{

}

class Master{

}

class Utils<T>{
    private T t;

    public void setMaster(T t) {
        this.t = t;
    }

    public T getMaster() {
        return t;
    }
}

public class GenericDemo1 {
    public static void main(String[] args) {

        Utils<Master> utilsMaster = new Utils<Master>();
        utilsMaster.setMaster(new Master());
        //utilsMaster.setMaster(new Worker()); // 编译失败
        
        Utils<Worker> utilsWorker = new Utils<Worker>();
        utilsWorker.setMaster(new Worker());
        //utilsWorker.setMaster(new Worker()); // 编译失败
        
    }
}

4.泛型方法

（1） 泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

package collectionDemo;

class Demo<T>{
    public void show(T t){
        System.out.println("show:"+t);
    }
}

public class GenericDemo2 {
    public static void main(String[] args) {
        Demo<String> demoStr = new Demo<>();
        demoStr.show("xixixi");

        Demo<Integer> demoInt = new Demo<>();
        demoInt.show(123);
    }
}

输出：

xixixi
show:123

（2） 为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

package collectionDemo;

class Demo{
    public <T> void show(T t){
        System.out.println("show:"+t);
    }
}

public class GenericDemo2 {
    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.show("xixixi");
        demo.show(123);
    }
}

输出：

show:xixixi
show:123

5. 静态方法泛型

静态方法不可以访问类上定义的泛型

如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

package collectionDemo;

class Demo<T>{
    public  void show(T t){
        System.out.println("show:"+t);
    }
    public <Q> void print(Q q){
        System.out.println("print:"+q);
    }

    /*
    会产生 Error:(13, 31) java: 无法从静态上下文中引用非静态 类型变量 T
    public static void Method(T t){
        System.out.println("method:"+t);
    }
     */

    public static <H> void Method(H h){
        System.out.println("method:"+h);
    }

}

public class GenericDemo2 {
    public static void main(String[] args) {
        Demo.Method("shh");
        Demo.Method(123);

        Demo<String> demo = new Demo<>();
        demo.show("xixiix");
        //demo.show(123); 编译失败

        demo.print("ssss");
        demo.print(123);

    }
}

输出结果：

method:shh
method:123
show:xixiix
print:ssss
print:123

6. 泛型接口

package collectionDemo;

interface Inter<T>{
    void show(T t);
}

class InterImp1 implements Inter<String>{
    public void show(String t){
        System.out.println("show:"+t);
    }
}

class InterImp2<T> implements Inter<T>{
    public void show(T t){
        System.out.println("show:"+t);
    }
}

public class GenericDemo3 {
    public static void main(String[] args) {
        InterImp1 inter = new InterImp1();
        inter.show("shh");

        InterImp2<Integer> integerInterImp2 = new InterImp2<>();
        integerInterImp2.show(123);
     }
}

输出：

show:shh
show:123

7. 泛型限定

（1） 麻烦

package collectionDemo;

import java.util.ArrayList;

public class GenericDemo4 {
    public static void main(String[] args) {
        ArrayList<String> al1 = new ArrayList<>();
        al1.add("shh1");
        al1.add("shh2");
        al1.add("shh3");

        ArrayList<Integer> al2 = new ArrayList<>();
        al2.add(1);
        al2.add(2);
        al2.add(3);
    }
}

（2） ?是通配符

package collectionDemo;

import java.util.ArrayList;
import java.util.Iterator;

public class GenericDemo4 {
    public static void main(String[] args) {
        ArrayList<String> al1 = new ArrayList<>();
        al1.add("shh1");
        al1.add("shh2");
        al1.add("shh3");

        ArrayList<Integer> al2 = new ArrayList<>();
        al2.add(1);
        al2.add(2);
        al2.add(3);

        printColl(al1);
        printColl(al2);
    }

    public static void printColl(ArrayList<?> al1){
        Iterator<?> it = al1.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

（3） error：ArrayList<Student1> al = new ArrayList<Person1>();

package collectionDemo;

import java.util.ArrayList;
import java.util.Iterator;

class Person1{
    private String name;
    private int age;

    public Person1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

    public void setAge(int age) {
        this.age = age;
    }

}

class Student1 extends Person1{
    Student1(String name, int age){
        super(name,age);
    }
}

public class GenericDemo4 {
    public static void main(String[] args) {
        ArrayList<Person1> al1 = new ArrayList<>();

        al1.add(new Person1("shh1",1));
        al1.add(new Person1("shh2",2));
        al1.add(new Person1("shh3",3));
        al1.add(new Person1("shh4",4));

        ArrayList<Student1> al2 = new ArrayList<>();
        al2.add(new Student1("gy",1));

        //printColl(al2);
        //Error 不兼容的类型: java.util.ArrayList<collectionDemo.Student1>无法转换为java.util.ArrayList<collectionDemo.Person1>

    }

    public static void printColl(ArrayList<Person1> al1){
        Iterator<Person1> it = al1.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

（4） 泛型限定

?是通配符，也叫占位符

  1. ? extends E ：可以接受E类型或者E的子类型，上限
  2. ? super E ：可以接受E类型或者E的父类型，下限
package collectionDemo;

import java.util.ArrayList;
import java.util.Iterator;

class Person1{
    private String name;
    private int age;

    public Person1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

    public void setAge(int age) {
        this.age = age;
    }

}

class Student1 extends Person1{
    Student1(String name, int age){
        super(name,age);
    }
}

public class GenericDemo4 {
    public static void main(String[] args) {
        ArrayList<Person1> al1 = new ArrayList<>();

        al1.add(new Person1("shh1",1));
        al1.add(new Person1("shh2",2));
        al1.add(new Person1("shh3",3));
        al1.add(new Person1("shh4",4));
        printColl(al1);

        ArrayList<Student1> al2 = new ArrayList<>();
        al2.add(new Student1("gy",1));
        printColl(al2);

    }

    public static void printColl(ArrayList<? extends Person1> al1){
        Iterator<? extends Person1> it = al1.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

运行结果：

collectionDemo.Person1@13b6d03
collectionDemo.Person1@f5f2bb7
collectionDemo.Person1@73035e27
collectionDemo.Person1@64c64813
collectionDemo.Student1@483bf400

8. 泛型限定2

应用实例：

TreeSet(Comparator<? extends E> comparator)
TreeSet(Comparator<? super E> comparator)

package collectionDemo;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class GenericDemo5 {
    public static void main(String[] args) {

        TreeSet<Student2> tree = new TreeSet<>(new Comp());
        tree.add(new Student2("shh1"));
        tree.add(new Student2("shh5"));
        tree.add(new Student2("shh3"));

        Iterator<Student2> it = tree.iterator();
        while (it.hasNext()){
            System.out.println(it.next().getName());
        }

        TreeSet<Worker2> tree1 = new TreeSet<Worker2>(new Comp());
        tree1.add(new Worker2("...gy1"));
        tree1.add(new Worker2("...gy5"));
        tree1.add(new Worker2("...gy3"));

        Iterator<Worker2> it1 = tree1.iterator();
        while (it1.hasNext()){
            System.out.println(it1.next().getName());
        }
    }
}

class Person2{
    private String name;
    public Person2(String name){
        this.name = name;
    }

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

    public String getName() {
        return name;
    }
}

class Student2 extends Person2{
    public Student2(String name){
        super(name);
    }
}

class Worker2 extends Person2{
    public Worker2(String name){
        super(name);
    }
}

class Comp implements Comparator<Person2>{
    public int compare(Person2 s1, Person2 s2){
        return s1.getName().compareTo(s2.getName());
    }
}

输出结果：

shh1
shh3
shh5
...gy1
...gy3
...gy5
lwycc233
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java集合框架及泛型
10-11
在实际开发中，理解和熟练运用Java集合框架和泛型能够大大提高代码的可维护性和安全性，减少类型转换的麻烦，并使得代码更易于理解和复用。通过以上讲解，相信你已经对这两个主题有了更深入的理解。通过练习和应用，...
Java集合框架 Map和泛型
12-22
Map集合 　1.特点：该集合存储键值对。一对一对往里存。而且要保证键的性。 　2.常用方法： 　1.添加：v put(k key ， v value); 将数据以键值对的方式存进集合中。 　void putAll(Map<? extends k，? ...
Java-集合框架和泛型
m0_64005381的博客
10-03 430
泛型，即参数化类型。就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也就定义成参数类型（也可以称之为参数类型），然后在使用/调用时传入具体的类型(类型参数)。该篇介绍了的泛型的应用、泛型类、类型通配符、泛型方法以及泛型接口等....
Java-集合与泛型-泛型
程序猿小样的博客
10-19 64
在Java编程中，泛型（Generics）是一项强大的特性，它允许在编写类、接口和方法时使用一个或多个类型作为参数。本文将深入研究Java中的泛型，介绍其基本概念、用法，以及在实际开发中的应用场景。泛型是一种参数化类型的概念，它允许在类、接口和方法的声明中使用类型参数，这些类型参数在使用时才被确定。泛型是Java编程中非常重要的特性，它提供了类型安全和代码重用的机制。：通过泛型，可以编写通用的代码，适用于多种数据类型，提高了代码的重用性。：泛型可以用于编写通用的算法，适用于不同类型的数据。
集合框架---泛型
Abner_G的博客
05-07 239
集合框架—泛型 泛型 1.集合中存储的元素类型叫做泛型；一种未知的数据类型 * E：Element元素 * 创建集合的时候就会确定集合的数据类型 例：ArrayList L=new ArrayList(); 会把数据类型作为参数进行传递，赋值给泛型E * 不使用泛型 * 优点：默认Object类型，可以存储任意类型的数据 * 缺点：不安全会引发异常，想使用特定类型的方法向下转型的时候有可能报错...
java--集合框架和泛型.基础
weixin_53416906的博客
03-24 530
集合 集合：对象的容器 相比数组：长度不固定         数组可以存放基本类型和引用类型，集合只能存放引用类型 collection体系
Java高级特性 - 集合框架（1）
最新发布
xu_tingfang的博客
05-20 1632
什么是泛型呢？类型参数，那什么又是类型参数呢？我们知道一个方法如果指定了一个字符串类型的参数，那方法的调用者就只能传递String类型的参数才能正确的使用这个方法了，否则就报错，其实泛型也是一样，只不过在这里泛型用在集合上，即指定集合中只能放某一种类型的元素你要往ATM机中存钱，就只能放毛爷爷，而不能放冥币，这就是泛型，指定只能用一种类型。
Java自学-集合框架 泛型Generic
我的博客
05-22 138
ArrayList上使用泛型 步骤 1 : 泛型 Generic 不指定泛型的容器，可以存放任何类型的元素 指定了泛型的容器，只能存放指定类型的元素以及其子类 package property; public class Item { String name; int price; public Item(){ } ...
Java-EE-泛型
qq_43156057的博客
04-25 1050
Java引入泛型主要是为了提高类型安全性和代码的可读性。
Java--泛型
weixin_42075274的博客
11-19 395
学习泛型的使用和自定义
java----集合框架和泛型
fighting
07-21 214
泛型 作用：类型参数化，将类型进行参数传递达到动态确定类型的目的 实现方法： 泛型接口：public interface 接口名 { } 泛型方法：public 返回值类型 方法名（E e）{ } 集合框架 集合定义：一个解决数组固定长度缺陷的动态容器。集合中只能存放对象。 集合框架图 Collection：单值保存根接口 分类：按照重复有序，或者不重复无序分成两个接口：Li...
泛型-Java集合框架基础
m0_46965984的博客
04-16 625
1.泛型 泛型主要目的是建立具有类型安全的集合框架，如链表，散列映射等数据结构。 详细内容查看Oracle Java Technologies | Oracle 泛型类 使用"class 名称<泛型列表>"声明一个类 这种类叫泛型类 class People<E> E指其中的泛型，并没有指定E是何种类型的数据，它可以是任意类或接口，但不能是基本数据类型 “泛型列表”给出的泛型可以作为类的成员变量的类型，方法的类型以及局部变量的类型 泛型类的类体和普通类的类体完全类似
29-API-集合框架-泛型-使用_java_
09-29
在Java集合框架中，泛型的应用尤其广泛。集合框架是Java中用于存储和操作对象的核心组件，包括List、Set和Map等接口以及它们的实现类。在未引入泛型之前，集合中的元素都是Object类型，这导致了频繁的强制类型转换，...
Java-collection-frame.rar_Java集合框架
09-20
Java集合框架是Java编程语言中一个至关重要的组成部分，它为数据存储、管理和操作提供了丰富的类库。这个框架包括了各种接口、类以及实现，使得开发者能够高效地处理对象的集合，无论是小型还是大型数据集。在Java...
Java-Java集合教程
11-13
Java集合框架是Java编程语言中一个非常重要的组成部分，它提供了数据结构和算法的实现，使得在处理对象集合时更加高效和灵活。Java集合教程通常会涵盖以下关键知识点： 1. **集合接口**： - `Collection`：这是...
本地连接服务器上rocketmq 出现closeChannel: close the connection to remote address[] result: true
热门推荐
lwycc2333的博客
06-08 3万+
本地连接服务器上rocketmq 一直弹出出现closeChannel: close the connection to remote address[] result: true 解决： 首先查看阿里云服务器的安全组，是否打开了10911端口 然后查看conf/broker.conf 是否设置了brokerIP1=xxx.xxx.xxx.xxx（服务器公网地址） 然后kill掉开启的进程，重新启动： （1）启动namesrv: nohup sh bin/mqnamesrv & 日志：tail
Java-集合框架-List练习题
lwycc2333的博客
03-21 2049
1. LinkedList练习题 使用LinkedList模拟一个堆栈或者队列数据结构。 堆栈：先进后出
PriorityQueue实现大根堆和小根堆
lwycc2333的博客
02-06 1326
小根堆 import java.util.PriorityQueue; PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();//小根堆 从源码上看PriorityQueue的入列操作并没对所有加入的元素进行优先级排序。仅仅保证数组第一个元素是最小的即可。下面一个例子，入队顺序是4 6 3 9，然后遍历整...
jav项目——商品交易系统
lwycc2333的博客
08-06 497
表设计 商品表，包含的字段：id、名字、库存、类别 买家表，包含的字段：id、姓名 商品交易表：包含的字段：商品id，买家id，交易数量
Java集合框架与泛型基础
"Java基础技术文档涵盖了Java开发的核心概念，包括集合框架、线程以及相关的工具包。...这个Java基础技术文档涵盖了从集合框架到泛型，再到实用工具类的重要知识，对于理解和掌握Java编程的基础非常有帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值