黑马程序员 java基础 集合框架之泛型

最新推荐文章于 2024-06-19 11:00:59 发布
最新推荐文章于 2024-06-19 11:00:59 发布
阅读量430 收藏
点赞数
分类专栏： java基础学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013372012/article/details/41673807
版权

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

泛型的产生

在jdk1.5版本以后，集合中可以存储基本的数据类型，因为java可以自动的对基本数据进行装箱，这样不适当的操作就会造成程序的一些安全隐患。

请看下面的代码：

import java.util.*;
class JavaCollection1_15 
{
	public static void main(String[] args) 
	{
		ArrayList al=new ArrayList();
		al.add("abc");
		al.add("bcd");
		al.add("xt");
		al.add(4);//注意java会对基本数据类型进行自动装箱，相当于al.add(new Integer(4));
		for(Iterator it=al.iterator();it.hasNext();)
		{
			String s=(String)it.next();
			System.out.println(s.length());
		}
	}
}
注意这段代码在编译时，能够通过，但是在运行时就会报异常， 运行结果如下：


通过提示我们可以发现，程序在运行时会报出类型转换错误，原因就是我们一开始对集合没有定义数据类型而造成。为了解决这种安全隐患，因此出现了泛型。

泛型的概述：

对集合(容器)一开始就定义了数据类型，是Jdk1.5版本后的一个新特性，用于解决安全隐患。

优点：

1 将运行时期的问题和安全隐患暴露在编译时期，减少了安全问题。

2避免了强制转换的麻烦，

上面的代码进行修改：

import java.util.*;
class JavaCollection1_15 
{
	public static void main(String[] args) 
	{
		ArrayList<String> al=new ArrayList<String>();
		al.add("abc");
		al.add("bcd");
		al.add("xt");
		al.add(4);//注意java会对基本数据类型进行自动装箱，相当于al.add(new Integer(4));
		for(Iterator<String> it=al.iterator();it.hasNext();)
		{
			//String s=(String)it.next();
			String s=it.next();
			System.out.println(s.length());
		}
	}
}

运行结果如下：


这时编译就不能通过，这样就可以提醒程序员能够修改程序。

泛型的使用
其实通过上面的程序我们可以发现<>就是用来接收数据的类型的。同时<E>中E的类型必须是引用类型的。

泛型实例三：

import java.util.*;
class JavaCollection1_16 
{
	public static void main(String[] args) 
	{
		TreeSet<String> ts=new TreeSet<String>(new MyComparator());
		ts.add("c");
		ts.add("aaa");
		ts.add("b");
		ts.add("bca");
		for(Iterator<String> it=ts.iterator();it.hasNext();)
		{
			String s=it.next();//这里避免了类型强制转换
			System.out.println(s);
		}
	}
}
class MyComparator implements Comparator<String>//泛型避免了强制转换，这里我们也可以定义泛型类型的比较器
{
	public int compare(String str1,String str2)
	{
       int num=str1.length()-str2.length();
	   if(num==0)
		   return str1.compareTo(str2);
	   return num;
	}
}
程序运行结果如下：


从上面的实例我们发现Comparator和Comparable都可以定义成泛型的，从而避免了类型强制转换。

泛型类

什么时候定义泛型类呢？

当类中要操作的引用数据类型不确定时，需要定义泛型类。

早期使用Object类型进行扩展，现在使用泛型更方便。

泛型实例四：

需求，定义一个工具类，用来操作不同的实例对象。

import java.util.*;
class JavaCollection1_17 
{
	public static void main(String[] args) 
	{
		Tools<Student> t=new Tools<Student>();
		t.setInstance(new Student());
		Student s=t.getInstance();
		Tools<Worker>tt=new Tools<Worker>();
		tt.setInstance(new Worker());
		Worker w=tt.getInstance();
	}
}
/*泛型类的定义用来操作不同的对象*/
class Tools<T>
{
	private T t;
	public void  setInstance(T t)
	{
		this.t=t;
	}
	public T getInstance()
	{
		return t;
	}
}
class Student
{
	
}
class  Worker
{
}

编译通过，说明上面的Tools类具有操作不同的引用类型对象的功能。

注意：泛型类定义的泛型在整个类中都有效，如果在方法中使用，那么在泛型类在创建对象时，明确了对象的操作类型，那么方法的操作类型也被局限性了

泛型方法

为了解决泛型类的局限性，定义一个方法，能够操作不同引用类型的数据，从而引进了泛型方法来解决类似的问题，泛型方法的定义是将泛型定义在方法体上，同时泛型方法也可以存在泛型类中。

实例五：

import java.util.*;
class JavaCollection1_18 
{
	public static void main(String[] args) 
	{
		TextDemo<Integer> t=new TextDemo<Integer>();
		t.show(new Integer("111"));
		t.show("123213");
		t.display(new Character('c'));
		t.print(new Integer("123"));
	}
}
//定义了泛型类，并在泛型类中定义了泛型方法，但是泛型类在实例化后，泛型的操作类型只能够限定print方法，而不能够限定show()和display()等类似的泛型方法。
class TextDemo<Q>
{
	public <T> void show(T t)
	{
		System.out.println(t);
	}
	public <G> void display(G g)
	{
		System.out.println(g);
	}
	public void print(Q q)
	{
		System.out.println(q);
	}
}

运行结果：


注意：特殊之处，静态方法不可以访问定义在类上的定义的泛型，如果静态方法操作的数据类型不确定，那么可以将泛型定义在泛型方法上。

其他发型知识点：

泛型接口

泛型接口在项目中的使用频率都很小，一般都使用内置的接口，但我们还是要了解其基本用法。

泛型实例六：

class  JavaCollection1_19
{
	public static void main(String[] args) 
	{
		MyGenericClass<String> mgc=new MyGenericClass<String>();
		mgc.show("aaaa");
	}
}
interface IText<T>
{
	void show(T t);
}
class MyGenericClass<T> implements IText<T>
{
	public void show(T t)
	{
		System.out.println(t);
	}
}
运行结果：



泛型限定


提到泛型限定，不得不提java中?通配符，我们可以理解为占位符，我们可以理解为一个占位符，在泛型中可能出现这种情况，我们只知道操作的集合时泛型的，但是具体是什么样的泛型我们不知道，这时我们在写方法时就可以使用？来作为占位符：

泛型实例七：

import java.util.*;
class JavaCollection1_20 
{
	public static void main(String[] args) 
	{
		ArrayList<String> al1=new ArrayList<String>();
		al1.add("aaa");
		al1.add("bbb");
		al1.add("ccc");
		ArrayList<Integer> al2=new ArrayList<Integer>();
		al2.add(1);
		al2.add(2);
		al2.add(3);
		show(al1);
		show(al2);
	}
	public static void show(ArrayList<?> al)
	{
		for(Iterator<?> it=al.iterator();it.hasNext();)
		{
			System.out.println(it.next());
		}
	}
}
运行结果是：

从上面的例子中我们可以看出，？可以起到占位的作用，只有等到使用时才知道？具体代表什么泛型类型。

接下来我们再看下一种情况，有时候我们需要一个方法只能够操作子类对象及其父类对象，其它的如果作为参数传进来就会报错，也就是限定了泛型的类型

实例八：

import java.util.*;
class JavaCollection1_21 
{
	public static void main(String[] args) 
	{
		ArrayList<Person> alp=new ArrayList<Person>();
		alp.add(new Person("xt_1",12));
		alp.add(new Person("xt_2",12));
		alp.add(new Person("xt_3",12));
		alp.add(new Person("xt_4",12));

		ArrayList<Student> als=new ArrayList<Student>();
		als.add(new Student("x",20));
		als.add(new Student("t",21));
		als.add(new Student("x",20));
		als.add(new Student("m",24));
		show(alp);
		show(als);

	}
	//定义了一个方法，这个方法采用了泛型限定，只允许传入的泛型操作对象是Person类型或者是Person类的子类对象。
	public static void show(ArrayList<? extends Person> al)
	{
		for(Iterator<? extends Person> it=al.iterator();it.hasNext();)
		{
			Person p=it.next();
			System.out.println(p.getName()+":"+p.getAge());
		}
	}
}
class Person
{
	private int age;
	private String name;
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public int getAge()
	{
		return age;
	}
	public String getName()
	{
		return name;
	}
}
class Student extends Person
{
	Student(String name,int age)
	{
		super(name,age);
	}
}
通过我们查询javaAPI帮助文档我们可以发现TreeSet的构造函数中有 TreeSet(Comparator<? super E> comparator)这样的方法，而这个方法翻译过来就是，我们可以创建一个比较器，同时我们可以限定这个比较器的操作类型，

实例九：

需求：定义一个比较器，这个比较器不仅能让存储在TreeSet中的学生进行排序，并且这个比较器能够让存储在TreeSet中的工人进行排序，代码如下：

import java.util.*;
class JavaCollection1_22 
{
	public static void main(String[] args) 
	{
		//想要存储在TreeSet中的对象具备比较性，那么我们可以让TreeSet具备比较性，但是由于TreeSet中存储的对象不同，所以我们每次在初始TreeSet时，必须重新定义一个比较器，这样不利于代码的复用性，因此我们可以对比较器进行向上限定，
		
		TreeSet<Person> alp=new TreeSet<Person>(new MyCom());
		alp.add(new Person("xt_1",12));
		alp.add(new Person("xt_2",12));
		alp.add(new Person("xt_3",12));
		alp.add(new Person("xt_4",12));
		for(Iterator<Person> it=alp.iterator();it.hasNext();)
		{
			Person p=it.next();
			System.out.println(p.getName()+":"+p.getAge());
		}

		TreeSet<Worker> als=new TreeSet<Worker>(new MyCom());
		als.add(new Worker("wx",20));
		als.add(new Worker("wt",21));
		als.add(new Worker("ww",20));
		als.add(new Worker("wm",24));
		for(Iterator<Worker> it=als.iterator();it.hasNext();)
		{
			Worker p=it.next();
			System.out.println(p.getName()+":"+p.getAge());
		}


	}
}

class MyCom implements Comparator<Person>
{
	public int compare(Person p1,Person p2)
	{
		return p1.getName().compareTo(p2.getName());
	}
}
class Person
{
	private int age;
	private String name;
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public int getAge()
	{
		return age;
	}
	public String getName()
	{
		return name;
	}
}
class Student extends Person
{
	Student(String name,int age)
	{
		super(name,age);
	}
}
class Worker extends Person
{
	Worker(String name,int age)
	{
		super(name,age);
	}
}
运行的结果如下：



通过上面的结果，我们发现只定义了一个比较器，由于限定了类型，Person类既是Worker类的基类，也是Student类的基类满足向上限定的条件，所以扩展了代码的复用性。



foreverxiongtao
关注
专栏目录
Java笔记4 JavaAPI<2>TreeSet、Comparator、泛型
l_215851356的专栏
05-22 863
------- android培训、java培训、期待与您交流！ ---------- 15天-01-集合框架(TreeSet) Set：无序，元素不可以重复。        |--HashSet：        |--TreeSet：可以对set集合中的数据排序。                        底层数据是二叉树。                        保证
黑马程序员Javase笔记
01-18
Java是世界上最流行的编程语言之一，尤其在...总结来说，"黑马程序员Javase笔记"涵盖了Java的基础语法、内存管理、面向对象编程、集合框架以及泛型和Map等内容，这些都是成为一名合格Java开发者必须掌握的核心知识。
加入泛型后的TreeSet容器 （注意比较器）
dingjingchao的博客
11-15 434
比较其中确认泛型后可以将Campara的参数写成泛型类型，省略强转， 但是如果重写元素中的equals方法   equals方法的参数还是Object，因为重写的是Objecj类方法，没有泛型 import java.util.*; class FanXing { public static void main(String[] args) { TreeSet al=new Tre
黑马程序员_JAVA学习日记_JAVA中的泛型
Java程序员命运之改变
08-18 761
黑马程序员-学习日记   黑马程序员_JAVA学习日记_JAVA中的泛型   ------- android培训、java培训、期待与您交流！ ----------   一：泛型概述：    泛型是JDK1.5版本以后出现的一个安全机制；泛型其实给编译器使用的。    泛型的表现形式就是    集合中存储了不同类型的对象，取出时，容易在运行时时期发生ClassCastExcept
黑马程序员Java基础学习，涉及精细知识点复习【持续更新】
最新发布
qq_49288362的博客
06-19 1545
文章目录01java基础java基础面向对象1.类：2.成员变量：类中方法外的变量，不能赋值3.成员方法：4.java内存分配：5.成员变量有初始值，局部变量没有初始值。6.this关键字：7.封装：8.构造方法：9.标准的JavaBean组成10.JDK帮助文档使用流程：GUI1.java.awt包：2.javax.swing包：3.GUI组件：4.事件监听机制5.“”创建的字符串对象，在字符串常量池存储，如果内容一样的字符串，本质上是同一个对象。6.基本类型包装类7.比较字符串相等02java_进阶一、
黑马程序员——JAVA基础拾遗之泛型和集合框架（二）
bbdeyouxang的专栏
10-05 581
泛型 JDK1.5以后出现的新特性，用于解决安全问题，是个类型安全机制， 先看以下的代码         ArrayList l = new ArrayList();         l.add("a");         l.add("ab");         l.add("abc");         l.add(4);         Iterator it = l
黑马程序员——java基础之泛型
back
01-04 534
——- android培训、java培训、期待与您交流！ ———- 泛型一 初识泛型泛型:JDK1.5版本以后出现的新特性,用于解决安全问题 是一个类型安全机制 - JDK1.5的集合类希望在定义集合时，明确表明你要向集合中装入那种类型的数据，无法加入指定类型以外的数据。 - 泛型是提供给javac编译器使用的可以限定集合中的输入类型说明的集合时，会去掉“类
黑马程序员Java笔记
m0_68735537的博客
03-14 2074
输出打印、参与运算、修改记录的值。
黑马程序员 Java集合框架 Map和泛型
wangning101的专栏
12-13 367
------- android培训、java培训、期待与您交流！ ---------- Map集合 1.特点：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。 2.常用方法：    1.添加：v  put(k key , v value); 将数据以键值对的方式存进集合中。           void putAll(Map m) ;从指定
黑马程序员——Java基础知识——泛型、枚举
ai272519的专栏
03-30 625
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ 泛型、枚举  -------------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
黑马程序员入学Java精华总结
11-07
### 黑马程序员入学Java精华总结 #### 一、Java概述与基础知识 1. **何为编程？** - 编程是指通过编写计算机能够理解的指令来解决问题或完成特定任务的过程。这些指令通常被组织成算法，并使用某种编程语言实现。...
黑马程序员----泛型学习注意点
04-04
泛型是Java SE 5.0引入的新特性，主要用于集合框架，它可以限制容器中存储的数据类型，确保在编译时就能检测出错误，而不是等到运行时。泛型使用尖括号`<>`表示，如`List<String>`。 2. 类型参数： 泛型中的`T`、...
黑马程序员入学Java知识——精华总结.doc
05-09
Java集合框架包括List、Set、Queue和Map等接口，以及ArrayList、HashSet、LinkedList等实现类，用于存储和操作对象。 15. **IO流**： Java的IO流系统支持数据的输入和输出，包括字符流和字节流，以及缓冲区、转换...
黑马程序员JAVA面试宝典2018年5月最新版
11-23
Java集合框架，包括List、Set、Map接口的实现类以及它们的特点和使用场景，例如ArrayList、LinkedList、HashSet、HashMap、ConcurrentHashMap等。此外，集合框架的高级话题，如泛型、迭代器、比较器、并发容器也会有...
黑马程序员---Java包的创建以及包与包之间的访问
u013372012的专栏
11-30 597
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 一包的概述 当一个大型项目由多个人开发时，往往会出现相同的类的命名，而为了避免出现这种状况，java中引入了包的概念。 java中的包主要是对java文件进行管理，用package来表示，相当于windows下的文件夹。使用不同的文件夹，可以避免出现在一个项目中两个相同的名字类。 而包的
黑马程序员 JAVA jar包的创建和操作
u013372012的专栏
12-01 581
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------在window中，当出现多个文件时，我们为了方便文件的管理和浏览就可以使用winrar等软件对文件夹进行压缩打包，同理在java中，当如果项目中出现多个package时，为了将多个包压缩成一个压缩文件，我们就可以使用jdk为我们提供的工具jar.exe对文件进行压缩，最后生成一个后缀名为.jar的
黑马程序员 Java基础IO流之File类
u013372012的专栏
12-12 499
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- File的概述 流操作的是数据，但是不能操作文件夹，或者文件的属性，这时Java就为我们提供了一个File类，来为方便我们对文件或者文件夹的属性进行操作。 演示实例： import java.io.*; class JavaCollection1_80 { public static
黑马程序员 java基础集合框架之集合工具类Collections
u013372012的专栏
12-03 498
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- Collections概述 有时候List集合中存入了一堆元素，而我们又想对List集合进行排序，我们知道只有TreeSet，或者TreeMap才有排序的功能。而List集合本身没有排序的功能，这时我们就需要使用Collections这个工具类来完成排序这个功能。 Collections常
Java集合框架与泛型基础教程
应用程序开发基础-集合框架与泛型" Java集合框架是Java语言中用于存储和操作数据的重要工具，它为开发者提供了统一的接口和类，使得处理对象集合变得更加高效和便捷。在Java中，集合框架的核心接口包括Collection、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值