集合框架
1.集合家族体系
Collection是父接口
List和Set是子接口
Map也是一个接口
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uoa4euHA-1607303007236)(.\img\集合体系.png)]
2.List接口
2.1 ArrayList
ArrayList
ArrayList 有序的 有下标 线程不安全 允许为null
- 1.初始为一个空的Object数组
- 2.当我们第一次添加元素的时候将 数组的长度赋值为10
- 3.当集合长度不够用的时候，扩容是原来的1.5倍
- 4.查询快 添加 删除 慢
package com.qfedu.test1;
import java.util.Date;
/**
* 新闻信息类
* 标题
* 作者
* 日期
* 内容
* @author WHD
*
*/
public class News {
private String title;
private String author;
private Date date;
private String content;
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public News() {
}
public News(String title, String author, Date date, String content) {
this.title = title;
this.author = author;
this.date = date;
this.content = content;
}
@Override
public String toString() {
return "News [title=" + title + ", author=" + author + ", date=" + date + ", content=" + content + "]";
}
}
package com.qfedu.test1;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
/**
* ArrayList 有序的 有下标 线程不安全 允许为null
* 1.初始为一个空的Object数组
* 2.当我们第一次添加元素的时候将 数组的长度赋值为10
* 3.当集合长度不够用的时候，扩容是原来的1.5倍
* 4.查询快 添加 删除 慢
* @author WHD
*
*/
public class TestNews {
public static void main(String[] args) {
// 使用ArrayList集合存放新闻信息
ArrayList<News> list = new ArrayList<News>();
Date date = new Date(2020,8,1);
News n1 = new News("周末竟然和女朋友做这事，全世界都震惊了", "赵四", new Date(), "在家做饭");
News n2 = new News("周末竟然和女朋友做这事，全世界都震惊了", "广坤", new Date(), "在家洗衣服");
News n3 = new News("周末竟然和女朋友做这事，全世界都震惊了", "小宝", date, "在家看电视");
list.add(n1);
list.add(n2);
list.add(n3);
System.out.println("集合原长度" + list.size());
list.remove(0);
list.remove(n2);
System.out.println("删除第二个元素之后集合长度" + list.size());
News n4 = new News("周末竟然和女朋友做这事，全世界都震惊了", "小沈阳", date, "在家跳舞");
News modifyNews = list.set(1, n4);
System.out.println("修改之前的元素内容" + modifyNews);
System.out.println("修改之后的元素内容" + list.get(1));
System.out.println("清空集合之前" + list.isEmpty());
System.out.println("===========================");
// 遍历集合
// for循环
// 第一种方式
for(int i = 0; i < list.size() ; i ++) {
System.out.println(list.get(i));
}
System.out.println("===========================");
// 第二种方式 增强for循环
// 格式 for(Type name : list){
//
// }
for(News ns : list) {
System.out.println(ns);
}
System.out.println("===========================");
// 第三种方式 迭代器的方式
// 迭代器必须使用while循环类遍历 因为 没有下标
Iterator<News> it = list.iterator();
while(it.hasNext()) {
News next = it.next();
System.out.println(next);
}
list.clear();
System.out.println("清空集合之后" + list.isEmpty());
}
}
遍历ArrayList方法
1.普通for循环遍历
2.增强for循环遍历(foreach)
3.迭代器遍历
总结：
三种遍历方式的优缺点：
- 1.for循环是基于下标查找的 所以我们可以做一些基于下标的操作
- 2.如果不需要对下标的操作 推荐使用增强for循环或者迭代器
- 3.不要在增加for循环或者迭代器中删除或者添加数据 将会报并发访问异常
- 4.增强for内部依然是迭代实现的，是JDK1.5新添加的内容，迭代器是JDK1.2有的
package com.qfedu.test1;
import java.util.ArrayList;
import java.util.Iterator;
/**
* 三种遍历方式的优缺点：
* 1.for循环是基于下标查找的 所以我们可以做一些基于下标的操作
* 2.如果不需要对下标的操作 推荐使用增强for循环或者迭代器
* 3.不要在增加for循环或者迭代器中删除或者添加数据 将会报并发访问异常
* @author WHD
*
*/
public class TestForeach {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<Integer>();
for (int i = 0; i < 200000; i++) {
list1.add(i);
}
long startTime = System.currentTimeMillis();
for (int i = 0; i < list1.size(); i++) {
if(i == 1) {
list1.remove(i);
}
System.out.println(list1.get(i));
}
long endTime = System.currentTimeMillis();
System.out.println("普通循环耗时" + (endTime - startTime)); // 1700 毫秒
startTime = System.currentTimeMillis();
// 增强for循环 是JDK1.5 才有的 内部依然使用迭代器实现
for(Integer i : list1) {
System.out.println(i);
}
endTime = System.currentTimeMillis();
System.out.println("增强循环耗时" + (endTime - startTime)); // 1439毫秒
startTime = System.currentTimeMillis();
// 迭代器 1.2
Iterator<Integer> it = list1.iterator();
while(it.hasNext()) {
list1.remove(it.next());
System.out.println(it.next());
}
endTime = System.currentTimeMillis();
System.out.println("迭代器耗时" + (endTime - startTime)); // 600毫秒
}
}
ArrayList源代码实现
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jwciJwrL-1607303007252)(.\img\ArrayList无参构造.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qi8F5CNq-1607303007262)(.\img\初始化数组长度.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4WJRDvq6-1607303007271)(.\img\确保有足够的空间，如果没有就扩容.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tU3IZuUg-1607303007286)(.\img\扩容并且赋值数组.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-01zDgOpy-1607303007292)(.\img\ArrayList删除元素.png)]
总结：ArrayList特点是查询快，添加和 +删除慢，因为涉及到移动元素，所以我们在一些查询占比高于删除和添加的场景可以使用。比如，电商系统
2.2 Vector
Vector类有和ArrayList相同的API，但是是线程安全的
面试题：
ArrayList和Vector区别？
1.Vector是JDK1.0就有的，ArrayList是JDK1.2才有的
2.Vector无参构造直接给数组长度赋值为10，而ArrayList是第一次添加内容的时候才给数组长度赋值为10
3.Vector扩容是原来的两倍，ArrayList是原来的1.5倍
4.Vector是线程安全的，ArrayList是线程不安全的
遍历方式与ArrayList一致
package com.qfedu.test1;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
public class TestVector {
public static void main(String[] args) {
// 此类与ArrayList有相同的API 先存在的 线程安全的
Vector v1 = new Vector(); // 无参构造直接初始化为10
v1.add(20);
v1.add("赵四");
v1.add(23.0);
// 热插拔
List<Object> v2 = new Vector<Object>();
v2.add(20D);
v2.add(21D);
v2.add(22D);
v2.add(23D);
v2.add(24D);
System.out.println("原集合长度" + v2.size());
System.out.println("删除的元素是" + v2.remove(0));
System.out.println("删除一个元素以后" + v2.size());
System.out.println("第一个元素" + v2.get(0));
v2.set(0, 66D);
System.out.println("第一个元素" + v2.get(0));
System.out.println("清空之前是否为空" + v2.isEmpty());
System.out.println("================================");
for (int i = 0; i < v2.size(); i++) {
System.out.println(v2.get(i));
}
System.out.println("================================");
for (Object object : v2) {
System.out.println(object);
}
System.out.println("================================");
Iterator<Object> it = v2.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
v2.clear();
System.out.println("清空之后是否为空" +v2.isEmpty());
}
}
2.3 LinkedList
特点：
无序的，可以为null，线程不安全的，双向链表
除了提供和ArrayList方法名称相同的方法之外 还提供了链表数据结构特有的一些
单独用于操作 头部 和 尾部的一些方法
添加、删除效率高
查询效率低
使用场景：
仓库管理系统，或者图书管理系统，涉及到频繁的修改数据的
package com.qfedu.test1;
import java.util.LinkedList;
/**
* LinkedList 也是List接口的实现类 也是Deque接口的实现类
* LinkedList既是一个线性表也是一个队列(双向链表)
* 除了提供和ArrayList方法名称相同的方法之外 还提供了链表数据结构特有的一些
* 单独用于操作 头部 和 尾部的一些方法
* @author WHD
*
*/
public class Test1 {
public static void main(String[] args) {
LinkedList list = new LinkedList();
// 无序的 是指空间不连续
list.add("a");
list.add(20);
list.addFirst("B");
list.addLast("C");
list.add(1, "中文");
System.out.println("集合长度" + list.size());
System.out.println("第一个元素是" + list.getFirst());
System.out.println("第二个元素" + list.get(1));
list.getLast();
list.removeFirst();
list.removeLast();
list.remove();
for (Object object : list) {
System.out.print(object + "\t");
}
System.out.println();
System.out.println("删除第一个元素以后，集合长度" + list.size());
list.set(1, "A");
for (Object object : list) {
System.out.print(object + "\t");
}
System.out.println();
System.out.println("集合是否为空" + list.isEmpty());
list.clear();
System.out.println("集合是否为空" + list.isEmpty());
}
}
遍历LinkedList
三种 方式
1.普通for循环
2.增强for循环
3.迭代器
注意：不要使用普通for循环遍历LinkedList
package com.qfedu.test1;
import java.util.Iterator;
import java.util.LinkedList;
public class Test3 {
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<Integer>();
for (int i = 0; i < 20; i++) {
list.addFirst(i);
}
System.out.println("=================");
// 1 普通for循环
for(int i = 0; i < list.size(); i ++) {
System.out.println(list.get(i));
}
// 2 增强for循环
for(Integer i : list) {
System.out.println(i);
}
// 3 迭代器
Iterator<Integer> it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
LinkedList源码解读
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NzshxLFh-1607303007299)(.\img\add方法.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cdhOwHsA-1607303007306)(.\img\addFirst方法.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a3nOLUJv-1607303007313)(.\img\addLast方法.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W4560Pmk-1607303007318)(.\img\addLast方法内部实现.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0XtPjZpU-1607303007328)(.\img\getFirst方法.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EQ425jDp-1607303007333)(.\img\getLast方法.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Bvllmc0M-1607303007341)(.\img\LinkedList查找元素方法.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AcLlc5MN-1607303007346)(.\img\removeFirst内部实现.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KhIIftJG-1607303007351)(.\img\remove方法内部实现.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r5p4Kn55-1607303007357)(.\img\每一个元素都是一个Node.png)]
3.Map接口
3.1HashMap
特点：
无序
线程不安全
允许键和值为null 键不能重复
ArrayList是基于数组 有下标 所以查询快 同样也是因为有下标 涉及到移动元素 所以增删慢
LinkedList 基于双向链表 没有下标 所以查询慢 同样也是因为没有下标 增删快
能不能将以上两个集合 结合到一起呢？
可以的 HashMap就是 几乎实现了将两者结合到一起
JDK 1.7 数组 + 单向链表
JDK 1.8 数组 + 单向链表 + 红黑树 当单向的链表的长度大于8时候 转换为红黑树 提高查询效率
扩容 2倍
效率：
增删改查都快只是理想状态，实际中会受到影响，只是会相对提高增删改查的效率，但是缺点是占用空间大
package com.qfedu.test2;
import java.util.ArrayList;
import java.util.HashMap;
public class Test1 {
public static void main(String[] args) {
// 定义一个集合 存储成对的信息
ArrayList<String> list = new ArrayList<String>();
list.add("US美国");
list.add("JP日本");
list.add("CN中国");
HashMap<String,String> map =new HashMap<String,String>();
map.put("US", "美国");
map.put("RU", "俄罗斯");
map.put("CN", "中国");
map.put("JP", "小日本");
System.out.println(map.size());
// map集合 键和值 都允许为 null 键不能重复 如果重复 那么将覆盖值
map.put("JP", "日本");
System.out.println(map.size());
System.out.println(map.get("JP"));
System.out.println("删除的元素value是" + map.remove("JP"));
System.out.println(map.isEmpty());
map.clear();
System.out.println(map.isEmpty());
}
}
遍历方式
1.获取所有key，根据key获取值
2.获取所有的值
3.获取Set<Entry<?,?>> 获取所有的整条数据的集合
4.获取整条数据的集合迭代器map.entrySet().iterator();
package com.qfedu.test2;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
/**
* HashMap 集合特点
* 无序
* 线程不安全
* 允许键和值为null 键不能重复
* 效率
* 增删改查
* ArrayList是基于数组 有下标 所以查询快 同样也是因为有下标 涉及到移动元素 所以增删慢
* LinkedList 基于双向链表 没有下标 所以查询慢 同样也是因为没有下标 增删快
* 能不能将以上两个集合 结合到一起呢？
* 可以的 HashMap就是 几乎实现了将两者结合到一起
* JDK 1.7 数组 + 单向链表
* JDK 1.8 数组 + 单向链表 + 红黑树 当单向的链表的长度大于8时候 转换为红黑树 提高查询效率
* 扩容 2倍
* @author WHD
*
*/
public class Test2 {
public static void main(String[] args) {
// keySet() 返回所有的key集合 set集合
HashMap<String,String> map =new HashMap<String,String>();
map.put("US", "美国");
map.put("RU", "俄罗斯");
map.put("CN", "中国");
map.put("JP", "小日本");
Set<String> set = map.keySet();
for (String key : set) {
System.out.print(key + "\t" + map.get(key));
System.out.println();
}
System.out.println("=================");
// 获取所有的value values()
Collection<String> values = map.values();
for (String value : values) {
System.out.println(value);
}
System.out.println("==================");
Set<Entry<String, String>> entrySet = map.entrySet();
for(Entry en : entrySet) {
System.out.println(en.toString());
}
System.out.println("==================");
// 使用迭代器
Iterator<Entry<String, String>> iterator = map.entrySet().iterator();
while(iterator.hasNext()) {
Entry<String, String> next = iterator.next();
System.out.println(next.getKey() + "===" + next.getValue());
}
}
}
HashMap数据结构
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oKExPN3x-1607303007364)(.\img\HashMap.png)]
3.2Hashtable
面试题：
HashMap和Hashtable的区别？
此类提供与Hashtable相同的实现，但是是线程安全的，默认容量是11，扩容是两倍 + 1,键和值都不允许为null，无序的
package com.qfedu.test2;
import java.util.Hashtable;
/**
* Hashtable
* 无序
* 线程安全的
* 键和值都不允许null
* @author WHD
*
*/
public class Test3 {
public static void main(String[] args) {
Hashtable<Integer,String> table = new Hashtable<Integer,String>();
table.put(1, "A");
table.put(2, "B");
table.put(3, "C");
}
}
3.3Properties
Properties:属性
Hashtable子类，也是线程安全的，不要使用put或者putAll方法添加内容，因为此类只用于存放键和值都是String类型
package com.qfedu.test1;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;
/**
* Properties 类
* Hashtable子类
* 线程安全
* 键和值都为String
* 不要使用put或者putAll方法添加内容
*
* @author WHD
*
*/
public class TestProperties {
public static void main(String[] args) {
// Properties properties1 = System.getProperties();
// properties1.list(System.out);
// properties.put(20, 20.0); // 不要使用put方法来添加内容
//
// properties.get(20);
Properties properties2 = new Properties();
properties2.setProperty("CN", "中国");
properties2.setProperty("US", "美国");
properties2.setProperty("JP", "日本");
properties2.setProperty("KR", "韩国");
properties2.setProperty("RU", "俄罗斯");
properties2.list(System.out);
System.out.println(properties2.size());
System.out.println(properties2.get("CN"));
Set<Entry<Object, Object>> set = properties2.entrySet();
System.out.println("-- listing properties --");
for(Entry<Object, Object> entry : set) {
System.out.println(entry);
}
System.out.println("===============================");
Set<Object> keys = properties2.keySet();
for(Object key : keys) {
System.out.println(properties2.get(key));
}
System.out.println("===============================");
}
}
3.4TreeMap
TreeMap是可以保证顺序的Map集合，要求键必须可以排序，也就是必须实现Comparable接口，重写CompareTo方法
package com.qfedu.test2;
import java.util.Map.Entry;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.TreeSet;
/**
* Tree 树
* TreeMap是有顺序的Map集合 所存放的数据Key值必须可以比较 而且是升序的顺序
* 我们自定义的对象必须实现Comparable接口 重写CompareTo方法
* @author WHD
*
*/
public class TestTreeMapAndTreeSet {
public static void main(String[] args) {
TreeMap<String,String> map =new TreeMap<String,String>();
map.put("A","赵四");
map.put("a","广坤");
map.put("h","大拿");
map.put("B","小宝");
map.remove("A");
for(Entry<String,String> entry : map.entrySet()) {
System.out.println(entry);
}
map.clear();
map.size();
map.isEmpty();
System.out.println("=================================");
SortedMap<Person,String> map1 = new TreeMap<Person,String>();
map1.put(new Person("赵四",20), "A");
map1.put(new Person("广坤",21), "F");
map1.put(new Person("小宝",22), "c");
map1.put(new Person("大拿",23), "B");
System.out.println(map1.size());
for(Entry<Person,String> entry : map1.entrySet()) {
System.out.println(entry);
}
System.out.println("=================================");
}
}
package com.qfedu.test2;
/**
* 实现Comparable 自定义比较规则
*/
public class Person implements Comparable<Person>{
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int compareTo(Person o) {
if(this.getAge() == o.getAge()) {
return 0;
}else if(this.getAge() > o.getAge()) {
return 1;
}else {
return -1;
}
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
4.Set接口
4.1 HashSet
HashSet底层是一个HashMap，因为HashMap键不能重复的特点，所以可以使用HashMap维护一个我们创建HashSet
特点：
- 无序
- 不能重复 不允许添加两个对象 A和B A.equals(B) 并且 A和BhashCode相等
- 线程不安全
- 可以为null
- HashSet去重复是根据对象的hashCode和equals方法比较 都为true 则认为是同一个对象
package com.qfedu.test1;
import java.util.HashSet;
import java.util.Iterator;
/**
* HashSet
* 无序
* 不能重复 不允许添加两个对象 A和B A.equals(B)
* 线程不安全
* 可以为null
* HashSet去重复是根据对象的hashCode和equals方法比较 都为true 则认为是同一个对象
* @author WHD
*
*/
public class TestHashSet {
public static void main(String[] args) {
HashSet<String> set = new HashSet<String>();
set.add("A");
set.add("hello");
set.add("20");
set.add("中国");
System.out.println("第二次添加A" + set.add("A"));
System.out.println(set.size());
for(String str : set) {
System.out.println(str);
}
System.out.println("=======================");
Iterator<String> it = set.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
System.out.println("=======================");
System.out.println(set.remove("A"));
System.out.println(set.size());
set.clear(); // 清空集合
System.out.println(set.isEmpty());
}
}
4.2LinkedHashSet
HashSet的子类，基于链表的HashSet，可以保证数据的顺序，顺序就是插入的顺序
package com.qfedu.test1;
import java.util.Iterator;
import java.util.LinkedHashSet;
/**
* HashSet是无序的 不能保证顺序
* 如果需要保证顺序 并且元素不能重复 可以使用LinkedHashSet
* LinkedHashSet是基于链表的 HashSet 可以保证元素的顺序 插入顺序
*
* @author WHD
*
*/
public class TestLinkedHashSet {
public static void main(String[] args) {
LinkedHashSet<String> set = new LinkedHashSet<String>();
set.add("A");
set.add("hello");
set.add("中国");
set.add("千锋");
set.add("666");
System.out.println("=======================");
for(String str : set) {
System.out.println(str);
}
System.out.println("=======================");
Iterator<String> it = set.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
System.out.println("=======================");
set.remove("A");
System.out.println(set.size());
set.clear();
System.out.println("清空集合以后" + set.isEmpty());
}
}
4.3 TreeSet
TreeSet是可以保证顺序的Set集合，与LinkeHashSet不同，TreeSet是按照比较规则定义的顺序，LinkedHashSet是按照插入的顺序，TreeSet底层是维护的一个TreeMap，TreeSet要求保存的内容必须可以排序，也就是必须实现Comparable接口，重写CompareTo方法
package com.qfedu.test2;
import java.util.Map.Entry;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.TreeSet;
/**
* Tree 树
* TreeMap是有顺序的Map集合 所存放的数据Key值必须可以比较 而且是升序的顺序
* 我们自定义的对象必须实现Comparable接口 重写CompareTo方法
* @author WHD
*
*/
public class TestTreeMapAndTreeSet {
public static void main(String[] args) {
TreeSet<String> set = new TreeSet<String>();
set.add("你好");
set.add("A");
set.add("B");
set.add("hello");
for(String str : set) {
System.out.println(str);
}
TreeSet<Worker> set1 = new TreeSet<Worker>();
set1.add(new Worker());
set1.add(new Worker());
set1.add(new Worker());
set1.add(new Worker());
System.out.println(set1.size());
}
}
package com.qfedu.test2;
public class Worker implements Comparable<Worker>{
@Override
public int compareTo(Worker o) {
return 0; // 此处没有定义比较规则 同一返回0 那么将只能添加一个Worker对象 因为所有的Worker对象相比都相等
}
}
5.泛型
泛型
作用：相当于一个 占位 符 可以规范数据类型 有点类似于Object的作用 但是注意不能类型转换
适用场景：
接口，类，抽象类，形参，返回值
泛型可以是任何的字母，一般常用的：
T:Type
E:Element
K:Key
V:Value
package com.qfedu.test2;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* 泛型 <T>
* 作用：相当于一个 占位 符 可以规范数据类型 有点类似于Object的作用 但是注意不能类型转换
* 使用场景：
* 接口 类
* 方法形参 返回值
* 占位符 T Type E Element K key V value
* @author WHD
*
*/
public class TestGeneric {
public static void main(String[] args) {
AImpl1 ai = new AImpl1();
ai.m1("hello wolrd");
AImpl2 ai2 = new AImpl2();
ai2.m1(20);
B<String> b = new B<String>();
b.m1();
B<Integer> b1 = new B<Integer>();
b1.m2(1);
E.m1("String");
}
}
class C<K,V>{
public V m1(K k) {
return null;
}
}
class E{
public static <T> void m1(T t) {
System.out.println(t);
}
}
class B<T>{
public T m1() {
return null;
}
public void m2(T t) {
System.out.println(t);
}
}
interface A<T>{
void m1(T sb);
void m2(Object obj);
T m3();
}
class AImpl1 implements A<String>{
@Override
public void m1(String sb) {
}
@Override
public void m2(Object obj) {
}
@Override
public String m3() {
return null;
}
}
class AImpl2 implements A<Integer>{
@Override
public void m1(Integer i) {
System.out.println(i);
}
@Override
public void m2(Object obj) {
}
@Override
public Integer m3() {
return null;
}
}
class Animal{
}
class Dog extends Animal{
}
class Cat extends Animal{
}
class Test{
/**
* ? extends Animal 表示泛型可以是Animal或者Animal的子类
* @param set
*/
public void m1(Set<? extends Animal> set) {
}
public void m2(List<? super Dog> list) {
}
// public void m3(List<Dog extends ?> list) {
//
// }
public static void main(String[] args) {
Test test = new Test();
test.m1(new HashSet<Dog>());
test.m1(new HashSet<Cat>());
test.m1(new HashSet<Animal>());
// test.m1(new HashSet<String>());
test.m2(new ArrayList<Dog>());
test.m2(new ArrayList<Animal>());
// test.m2(new ArrayList<Cat>());
test.m2(new ArrayList<Object>());
}
}
716
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
