黑马程序员---集合框架<泛型>

最新推荐文章于 2021-08-08 12:21:02 发布
最新推荐文章于 2021-08-08 12:21:02 发布
阅读量531 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/melinda23096/article/details/18258045
版权
---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------
 
泛型：JDK1.5版本以后出现的新特性，用于解决安全问题，是一个类型安全机制。
 
加上泛型，解决了以下这个问题：
 
好处：
    1.将运行时期出现的问题ClassCastException，转移到了编译时期。
       方便于程序员解决问题，让运行时期问题减少，安全。
    2.避免了强制转换麻烦。
  
import java.util.*;
class GenericDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		TreeSet<String> al = new TreeSet<String>(new LenCompare());
		al.add("hfjz");
		al.add("abcdef");
		al.add("hgf");
		al.add("aaa");
		al.add("a");

		Iterator<String> it = al.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}
	}
}

class LenCompare implements Comparator<String>
{
	public int compare(String s1, String s2)
	{
		int num = new Integer(s2.length()).compareTo(new Integer(s1.length()));
		if(num==0)
		{
			return s2.compareTo(s1);
		}
		return num;
	}
}

 
现在定义一个像 Student这样的自定义 类，我们就 需要实现它的所有基本功能，不管能不能用的上。
包括： hashCode() 、 equals() 、 实现Comparable:覆盖compareTo() 、 toString() 。
  
import java.util.*;
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	Student(String name, int age)
	{
		this.name = name;
		this.age = age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public String toString()
	{
		return name+"::"+age;
	}
	public int hashCode()
	{
		return name.hashCode()+age*39;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student))
		{
			throw new RuntimeException("不是学生");
		}
		Student s = (Student)obj;
		return this.name.equals(s.name)&&this.age==s.age;
	}
	public int compareTo(Student s)
	{
		int num = new Integer(this.age).compareTo(new Integer(s.age));
		if(0==num)
		{
			return this.name.compareTo(s.name);
		}
		return num;
	}
}

class GenericTest 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void method_HashSet()
	{
		HashSet<Student> hs = new HashSet<Student>();
		hs.add(new Student("lisi03",11));
		hs.add(new Student("lisi01",12));
		hs.add(new Student("lisi01",12));
		hs.add(new Student("lisi09",11));
		hs.add(new Student("lisi03",15));
		Iterator<Student> it = hs.iterator();
		while(it.hasNext())
		{
			sop(it.next().toString());
		}
	}
	public static void method_TreeSet()
	{
		TreeSet<Student> ts = new TreeSet<Student>(new MyCompare());
		ts.add(new Student("lisi03",12));
		ts.add(new Student("lisi01",13));
		ts.add(new Student("lisi01",12));
		ts.add(new Student("lisi09",11));
		ts.add(new Student("lisi03",15));
		Iterator<Student> it = ts.iterator();
		while(it.hasNext())
		{
			sop(it.next().toString());
		}
	}
	public static void main(String[] args)
	{
		//method_TreeSet();
		method_HashSet();
	}
}

class MyCompare implements Comparator<Student>
{
	public int compare(Student s1, Student s2)
	{
		int num = s1.getName().compareTo(s2.getName());
		if(0==num)
		{
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		}
		return num;
	}
}

 
泛型类：
假如：我们定义了一个Worker类，
 
class  Worker
{
}
 
就需要一个操作Worker类的工具类，
 
class  Tool
{
        private  Worker  w;
        public  void  setWorker ( Worker  w )
        {
                this.w = w;
        }
        public  Worker  getWorker ( )
        {
                return w;
        }
}
 
如果我们又定义了一个Student类，那么我们就又需要一个操作Student类的工具类。
如果我们定义许许多多的类，那么就需要定义许许多多的工具类。
这样很麻烦，所以我们就想办法定义一个特殊的工具类，它能够操作任何的自定义类，下面就产生了它，
 
class Tools
{
        private  Object  obj;
        public  void  setObject ( Object  obj )
        {
                this.obj = obj;
        }
        public  Object  getObject ( )
        {
                return obj;
        }
}
 
这样的工具类也有它的不安全性，比如说，我们误将一个Student类的引用当作参数传递给了一个Worker的引用，但是在编译时期是可以通过的，只能等到在运行时期才会报错，
 
class  GenericTest
{
        public  static  void  main ( String  args[ ] )
        {
                Tools  t  =  new  Tools () ;
                t . setObject ( new  Student () ) ;
                Worker  w  =  ( Worker )  t . getObject () ;  
        }
}
 
 
我们把这种编译时期检测不到的错误看成是不安全性，这时我们就需要通过泛型来把运行时期的问题转移到编译时期来，这样开发人员能看到错误，提高了安全性，
  
class Worker
{
}

class Student
{
}

class Tools<QQ>
{
	private QQ q;
	public void setObject(QQ q)
	{
		this.q = q;
	}
	public QQ getObject()
	{
		return q;
	}
}

class GenericTest1 
{
	public static void main(String[] args) 
	{
		Tools<Worker> t = new Tools<Worker>();
		t.setObject(new Worker());
		Worker w = t.getObject();
	}
}

 
总结：
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展。
现在定义泛型来完成扩展。
 
泛型类定义的泛型，在整个类中有效。如果被方法使用，
那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定。
那么可以将泛型定义在方法上。
  
class Demo
{
	public <T> void show(T t)
	{
		System.out.println("show :"+t);
	}
	public <T> void print(T t)
	{
		System.out.println("print :"+t);
	}
}

class GenericDemo1 
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		d.show("abcde");
		d.print(3);
	}
}

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

class GenericDemo2 
{
	public static void main(String[] args) 
	{
		Demo<String> d = new Demo<String>();
		d.show("abcde");
		d.print(3);
	}
}

 
特殊之处：
静态方法不可以访问类上定义的泛型。
因为泛型类在建立对象之后才能明确要操作的具体类型，产生静态方法的时候，类型还没确定，所以不可以使用类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
  
class Demo<T>
{
	public void show(T t)
	{
		System.out.println("show :"+t);
	}
	public static <Q> void print(Q q)
	{
		System.out.println("print :"+q);
	}
}

class GenericDemo3 
{
	public static void main(String[] args) 
	{
		Demo<String> d = new Demo<String>();
		d.show("abcde");

		Demo.print(3);
	}
}

 
泛型定义在接口上：
  
interface Inter<T>
{
	void show(T t);
}

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

class GenericDemo4 
{
	public static void main(String[] args) 
	{
		InterImpl<Integer> in = new InterImpl<Integer>();
		in.show(3);
	}
}

 
通配符 <?>  和 泛型 <T> 的区别：
 
写泛型 <T> 可以对此T类型进行操作，
  
import java.util.*;
class GenericDemo5 
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();
		al.add("aaa01");
		al.add("aaa02");
		al.add("aaa03");
		al.add("aaa04");

		ArrayList<Integer> al1 = new ArrayList<Integer>();
		al1.add(1);
		al1.add(3);
		al1.add(7);

		printColl(al);
		printColl(al1);
	}

	public static <T> void printColl(ArrayList<T> al)
	{
		Iterator<T> it = al.iterator();

		while(it.hasNext())
		{
			T t = it.next();//写泛型，可以使用此类型进行操作。
			System.out.println(t);
		}
	}
}

 
写通配符 <?> 不可以对此类型进行操作，
  
import java.util.*;

class GenericDemo6 
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();
		al.add("aaa01");
		al.add("aaa02");
		al.add("aaa03");
		al.add("aaa04");

		ArrayList<Integer> al1 = new ArrayList<Integer>();
		al1.add(1);
		al1.add(3);
		al1.add(7);

		printColl(al);
		printColl(al1);
	}

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

 
这两个符号都叫泛型。用泛型的好处是，可以扩展，提高代码复用性，坏处是不可以使用类型特有的方法如length()；但是可以使用toString()，因为所有类型都具备，不写toString()直接打印默认也是toString()。
 
 ? 通配符。也可以理解为占位符。
泛型的限定；
？ extends E: 可以接收E类型或者E的子类型。上限。
  
import java.util.*;
class GenericDemo7 
{
	public static void main(String[] args) 
	{
		ArrayList<Person> al = new ArrayList<Person>();
		al.add(new Person("abc001"));
		al.add(new Person("abc002"));
		al.add(new Person("abc003"));
		al.add(new Person("abc004"));

		ArrayList<Student> al1 = new ArrayList<Student>();
		al1.add(new Student("S-abc--001"));
		al1.add(new Student("S-abc--002"));
		al1.add(new Student("S-abc--003"));
		al1.add(new Student("S-abc--004"));

		ArrayList<Worker> al2 = new ArrayList<Worker>();
		al2.add(new Worker("W-abc--001"));
		al2.add(new Worker("W-abc--002"));
		al2.add(new Worker("W-abc--003"));
		al2.add(new Worker("W-abc--004"));

		printCollection(al);
		printCollection(al1);
		printCollection(al2);
	}
	public static void printCollection(ArrayList<? extends Person> al)
	{
		Iterator<? extends Person> it = al.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
	}
}

class Person
{
	private String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
}

class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}

class Worker extends Person
{
	Worker(String name)
	{
		super(name);
	}
}


？ super E: 可以接收E类型或者E的父类型。下限。
  
import java.util.*;
class GenericDemo8 
{
	public static void main(String[] args) 
	{
		//因为Student本身不具备比较性，所以可以传本身的比较器对象或者父类的比较器对象。
		//TreeSet(Comparator<? super E> comparator) 
		TreeSet<Student> ts = new TreeSet<Student>(new MyCompare());
		ts.add(new Student("s-abc--001"));
		ts.add(new Student("s-abc--002"));
		ts.add(new Student("s-abc--003"));
		ts.add(new Student("s-abc--004"));

		TreeSet<Worker> ts1 = new TreeSet<Worker>(new MyCompare());
		ts1.add(new Worker("w-abc--001"));
		ts1.add(new Worker("w-abc--002"));
		ts1.add(new Worker("w-abc--003"));
		ts1.add(new Worker("w-abc--004"));

		printCollection(ts);
		printCollection(ts1);
	}
	
	/*给每一个TreeSet对象定义一个迭代器比较麻烦，所以将功能抽取，封装成函数，
	此函数定义了一个<? extends E>类型参数，指定了上限，可以接收E或者E的子类*/
	public static void printCollection(TreeSet<? extends Person> ts)
	{
		Iterator<? extends Person> it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
	}
}

class MyCompare implements Comparator<Person>//父类比较器
{
	public int compare(Person p1, Person p2)
	{
		return p1.getName().compareTo(p2.getName());
	}
}

class Person
{
	private String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
}

class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}

class Worker extends Person
{
	Worker(String name)
	{
		super(name);
	}
}
 

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

详细请查看：http://edu.csdn.net

Lola的笔记
关注
专栏目录
黑马程序员-----集合框架（Map和泛型）
InsistOwn的博客
06-03 528
------- android培训、java培训、期待与您交流！ ----------
黑马程序员----泛型学习注意点
04-04
黑马程序员提供的这篇关于泛型的学习注意点，结合了源码分析和工具应用，旨在帮助开发者深入理解并有效运用泛型。下面将详细阐述泛型的主要知识点： 1. 泛型的基本概念： 泛型是Java SE 5.0引入的新特性，主要用于...
Java 泛型方法/接口、泛型限定
mingyuli的博客
08-08 1679
一、为什么要定义泛型方法 1、从泛型类到泛型方法的演变过程 我们先来看个例子 //定义一个泛型类，并定义如下两个方法 class Test<T> { public void show(T t){ System.out.println(t); } public void print(T t){ System.out.println(t); } /* 以前是这样定义，现在一个方法搞定 public vo...
黑马程序员--10--集合框架与泛型
wawl521241的专栏
07-19 340
------- android培训、java培训、期待与您交流！ ----------     ------- Windows Phone 7手机开发、.Net培训、期待与您交流！ -------
黑马程序员--泛型与集合框架
weixin_30919429的博客
08-03 99
--------- android培训、java培训、期待与您交流！ ---------- 4 泛型在集合中的使用 4.1泛型介绍 　　1，在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错...
黑马程序员-----集合 泛型
chengguang150370的博客
10-20 321
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 泛型 定义:泛型：jdk1.5版本以后出现新特性，用于解决安全问题，是一个类型安全机制 好处: 1，将运行时期出现问题classcastexception，转移到了编译时期，方便于程序员解决问题，让运行事情问题减少，安全。 2，避免了强制转换麻烦 格式: 通过 在集合框架
黑马程序员----Java集合框架学习笔记2 Map-工具类-泛型
sven556677的博客
08-23 503
------- android培训、java培训、期待与您交流！ ---------- 1.Map Map 储存键值对，必须保证键的唯一性。 与Collection 区别：Map位双列集合，Collection为单列集合。 常用方法： 增：.put(key,value) 删：.clear(); 判断:containsKey(key)，containsValue(value) is
黑马程序员------泛型
aurora_bessie
08-02 285
------- android培训、java培训、期待与您交流！ ---------- 泛型 Jdk1.5版本以后出现了这个新特性，它用来解决安全问题，是一个类型安全机制。   泛型格式中定义要操作的引用数据类型。 好处：1.将运行时期出现问题ClassCastException转移到了编译时期。方便在编译时就能解决问题，使得运行时更安全高效。            2.避免再进行
黑马程序员--泛型
xiaoygog的博客
09-29 280
----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------     关键字：TreeSet、泛型   Set：无序，不可重复元素。数据结构不一样，保证数据唯一性的方式也不一样。   |-----HashSet：数据结构是哈希表，线程非同步。               保证元素唯一性的原理，判
黑马程序员----集合框架、泛型
Feng的专栏
07-15 478
一、Collection Collection       List：元素是有序的。元素可以重复，因为有索引           ArrayList:底层使用数组结构。查询快，但是增加、删除慢。可变长度数组，默认创建是10，如果添加时超过，则会新建一个ArrayList长度为原长的150%，之后把所有元素copy进新的ArrayList。            LinkedList:链表数
黑马程序员----泛型与反射的小运用
04-04
泛型的基本语法是在类、接口或方法声明前加上尖括号`<>`，并在其中指定一个或多个类型参数。例如，一个简单的泛型列表类可以定义为`List<T>`，其中`T`就是类型参数，代表任意类型。使用泛型，我们可以创建一个能够...
黑马程序员Javase笔记
01-18
Java是世界上最流行的编程语言之一，尤其在...总结来说，"黑马程序员Javase笔记"涵盖了Java的基础语法、内存管理、面向对象编程、集合框架以及泛型和Map等内容，这些都是成为一名合格Java开发者必须掌握的核心知识。
【个人博客】 Java、技术面试必备基础知识、Leetcode、计算机操作系统、计算机网络等_CSLearning.zip
最新发布
10-31
【个人博客】 Java、技术面试必备基础知识、Leetcode、计算机操作系统、计算机网络等_CSLearning
yolo算法-车辆行人数据集-1433张图像带标签-汽车摩托车人test-c86ef.zip
10-31
yolo系列算法目标检测数据集，包含标签，可以直接训练模型和验证测试，数据集已经划分好，适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法； 包含两种标签格:yolo格式（txt文件）和voc格式（xml文件），分别保存在两个文件夹中; yolo格式：<class> <x_center> <y_center> <width> <height>， 其中： <class> 是目标的类别索引（从0开始）。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标，这些坐标是相对于图像宽度和高度的比例值，范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度，也是相对于图像宽度和高度的比例值
江苏大学京江学院在四川2020-2024各专业最低录取分数及位次表.pdf
10-31
那些年，与你同分同位次的同学都去了哪里？全国各大学在四川2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
“人力资源+大数据+薪酬报告+涨薪调薪”
10-31
人力资源+大数据+薪酬报告+涨薪调薪，在学习、工作生活中，越来越多的事务都会使用到报告，通常情况下，报告的内容含量大、篇幅较长。那么什么样的薪酬报告才是有效的呢？以下是小编精心整理的调薪申请报告，欢迎大家分享。相信老板看到这样的报告，一定会考虑涨薪的哦。
广西医科大学在四川2020-2024各专业最低录取分数及位次表.pdf
10-31
那些年，与你同分同位次的同学都去了哪里？全国各大学在四川2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
这是一个基于全卷积神经网络的语音识别系统_DFCNN-master.zip
10-31
这是一个基于全卷积神经网络的语音识别系统_DFCNN-master
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值