概述
01-常用对象API(集合框架-泛型-概述)
泛型：
jdk1.5出现的安全机制。
好处：
1，将运行时期的问题ClassCastException转到了编译时期。
2，避免了强制转换的麻烦。
<>:什么时候用？当操作的引用数据类型不确定的时候。就使用<>。将要操作的引用数据类型传入即可.
其实<>就是一个用于接收具体引用数据类型的参数范围。
在程序中，只要用到了带有<>的类或者接口，就要明确传入的具体引用数据类型 。
02-常用对象API(集合框架-泛型-擦除&补偿)
泛型技术是给编译器使用的技术,用于编译时期。确保了类型的安全。
运行时，会将泛型去掉，生成的class文件中是不带泛型的,这个称为泛型的擦除。
为什么擦除呢？因为为了兼容运行的类加载器。
泛型的补偿：在运行时，通过获取元素的类型进行转换动作。不用使用者在强制转换了。
03-常用对象API(集合框架-泛型-在集合中的应用)
示例代码:GenericDemo2.java演示treeset,泛型里面全都是引用数据类型，而且也只能是引用数据类型
04-常用对象API(集合框架-泛型-泛型类)
我们在搞完了基本原理过后，还有其他的用处，它还能为我们提供设计上的便捷
/*
public class Tool {
private Object object;
public Object getObject() {
return object;
}
public void setObject(Object object) {
this.object = object;
}
}
*/
//在jdk1.5后，使用泛型来接收类中要操作的引用数据类型。
//泛型类。什么时候用？当类中的操作的引用数据类型不确定的时候，就使用泛型来表示。
public class Tool<QQ>{
private QQ q;
public QQ getObject() {
return q;
}
public void setObject(QQ object) {
this.q = object;
}
使用
Tool<Student> tool = new Tool<Student>();
// tool.setObject(newWorker());
// Student stu =tool.getObject();
// Tool tool = new Tool();
// tool.setObject(newWorker());
// Student stu = (Student)tool.getObject();
05-常用对象API(集合框架-泛型-泛型方法)
/**
* 将泛型定义在方法上。
* @param str
*/
public <W> void show(W str){
System.out.println("show : "+str.toString());
}
public void print(QQ str){
System.out.println("print : "+str);
}
/**
* 当方法静态时，不能访问类上定义的泛型。如果静态方法使用泛型，
* 只能将泛型定义在方法上。
* @param obj
*/
public static <Y> void method(Y obj){
System.out.println("method:"+obj);
}
使用
Tool<String> tool = new Tool<String>();
tool.show(new Integer(4));
tool.show("abc");
tool.print("hahah");
// tool.print(newInteger(8));
Tool.method("haha");
Tool.method(new Integer(9));
06-常用对象API(集合框架-泛型-泛型接口)
//泛型接口，将泛型定义在接口上。
interface Inter<T>{
public void show(T t);
}
class InterImpl2<Q> implements Inter<Q>{
public void show(Q q){
System.out.println("show :"+q);
}
}
class InterImpl implements Inter<String>{
public void show(String str){
System.out.println("show :"+str);
}
使用
InterImpl in = new InterImpl();
in.show("abc");
InterImpl2<Integer>in2 = newInterImpl2<Integer>();
in2.show(5);
07-常用对象API(集合框架-泛型-泛型限定(上限))
现在我们的泛型类，泛型接口，泛型方法都已经说完了,现在来说一些高级应用
public static void main(String[] args) {
ArrayList<String>al = new ArrayList<String>();
al.add("abc");
al.add("hehe");
ArrayList<Integer>al2 = newArrayList<Integer>();
al2.add(5);
al2.add(67);
printCollection(al);
printCollection(al2);
}
/**
* 迭代并打印集合中元素。
* @param al
*/
public static voidprintCollection(Collection<?> al) {
Iterator<?> it =al.iterator();
while(it.hasNext()){
// T str = it.next();
// System.out.println(str);
System.out.println(it.next().toString());
}
}
泛型的通配符：? 未知类型。
当我们的工具类中如果返回有这样的t的话也，这个T是不是可以进行操作，是，对于我们的?号来讲，仅在不明确类型，不对这个类型进行操作时用来表示,一般我们用?号的情况比较多一些
时间:0----13分钟
下面讲解另外一个知识点
ArrayList<Person> al= new ArrayList<Person>();
al.add(new Person("abc",30));
al.add(new Person("abc4",34));
ArrayList<Student>al2 = newArrayList<Student>();
al2.add(new Student("stu1",11));
al2.add(new Student("stu2",22));
ArrayList<String>al3 = new ArrayList<String>();
al3.add("stu3331");
al3.add("stu33332");
printCollection(al2);
printCollection(al);
08-常用对象API(集合框架-泛型-泛型限定(下限))
接着上面的代码，从方法前面的代码都一样的
/**
* 迭代并打印集合中元素。
*
* 可以对类型进行限定：
* ? extends E:接收E类型或者E的子类型对象。上限！
*
* ? super E ：接收E类型或者E的父类型。下限！
* @param al
*/
public static voidprintCollection(Collection<? super Student> al){
Iterator<? super Student> it = al.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
接下来我们说说什么时候用
09-常用对象API(集合框架-泛型-泛型限定(上限的体现))
public static void main(String[] args) {
ArrayList<Person>al1 = new ArrayList<Person>();
al1.add(new Person("abc",30));
al1.add(new Person("abc4",34));
ArrayList<Student>al2 = new ArrayList<Student>();
al2.add(new Student("stu1",11));
al2.add(new Student("stu2",22));
ArrayList<Worker>al3 = new ArrayList<Worker>();
al3.add(new Worker("stu1",11));
al3.add(new Worker("stu2",22));
ArrayList<String>al4 = new ArrayList<String>();
al4.add("abcdeef");
// al1.addAll(al4);//错误，类型不匹配。
al1.addAll(al2);
al1.addAll(al3);
System.out.println(al1.size());
// printCollection(al2);
// printCollection(al);
}
}
/*
* 一般在存储元素的时候都是用上限，因为这样取出都是按照上限类型来运算的。不会出现类型安全隐患。
*
*/
class MyCollection<E>{
public void add(E e){
}
public void addAll(MyCollection<? extends E> e){
}
10-常用对象API(集合框架-泛型-泛型限定(下限的体现))
public static void main(String[] args) {
TreeSet<Person>al1 = new TreeSet<Person>(new CompByName());
al1.add(new Person("abc4",34));
al1.add(new Person("abc1",30));
al1.add(new Person("abc2",38));
TreeSet<Student>al2 = new TreeSet<Student>(new CompByName());
al2.add(new Student("stu1",11));
al2.add(new Student("stu7",20));
al2.add(new Student("stu2",22));
TreeSet<Worker>al3 = new TreeSet<Worker>();
al3.add(new Worker("stu1",11));
al3.add(new Worker("stu2",22));
TreeSet<String>al4 = new TreeSet<String>();
al4.add("abcdeef");
// al1.addAll(al4);//错误，类型不匹配。
// al1.addAll(al2);
// al1.addAll(al3);
// System.out.println(al1.size());
Iterator<Student>it = al2.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
/*
* class TreeSet<Worker>
* {
* Tree(Comparator<? super Worker> comp);
* }
*
* 什么时候用下限呢？通常对集合中的元素进行取出操作时，可以是用下限。
*
*/
class CompByName implements Comparator<Person>{
@Override
public int compare(Person o1, Person o2) {
int temp = o1.getName().compareTo(o2.getName());
return temp==0? o1.getAge()-o2.getAge():temp;
}
}
class CompByStuName implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
int temp = o1.getName().compareTo(o2.getName());
return temp==0? o1.getAge()-o2.getAge():temp;
}
}
class CompByWorkerName implements Comparator<Worker>{
@Override
public int compare(Worker o1, Worker o2) {
int temp = o1.getName().compareTo(o2.getName());
return temp==0? o1.getAge()-o2.getAge():temp;
}
11-常用对象API(集合框架-泛型-泛型限定(通配符的体现))
12-常用对象API(集合框架-集合查阅的技巧)
===========================================================
集合的一些技巧：
需要唯一吗？
需要：Set
需要制定顺序：
需要： TreeSet
不需要：HashSet
但是想要一个和存储一致的顺序(有序):LinkedHashSet
不需要：List
需要频繁增删吗？
需要：LinkedList
不需要：ArrayList
如何记录每一个容器的结构和所属体系呢？
看名字！
List
|--ArrayList
|--LinkedList
Set
|--HashSet
|--TreeSet
后缀名就是该集合所属的体系。
前缀名就是该集合的数据结构。
看到array：就要想到数组，就要想到查询快，有角标.
看到link：就要想到链表，就要想到增删快，就要想要 add get remove+frist last的方法
看到hash:就要想到哈希表，就要想到唯一性，就要想到元素需要覆盖hashcode方法和equals方法。
看到tree：就要想到二叉树，就要想要排序，就要想到两个接口Comparable，Comparator 。
而且通常这些常用的集合容器都是不同步的。
============================================
01-常用对象API(集合框架-Map集合特点&常用方法)
Map：一次添加一对元素。Collection 一次添加一个元素。
Map也称为双列集合，Collection集合称为单列集合。
其实map集合中存储的就是键值对。
map集合中必须保证键的唯一性。
常用方法：
1，添加。
valueput(key,value):返回前一个和key关联的值，如果没有返回null.
2，删除。
void clear():清空map集合。
valueremove(key):根据指定的key翻出这个键值对。
3，判断。
booleancontainsKey(key):
booleancontainsValue(value):
booleanisEmpty();
4，获取。
valueget(key):通过键获取值，如果没有该键返回null。
当然可以通过返回null，来判断是否包含指定键。
intsize(): 获取键值对的个数。
02-常用对象API(集合框架-常用方法演示)
public static voidmethod(Map<Integer,String> map){//学号和姓名
// 添加元素。
System.out.println(map.put(8,"wangcai"));//null
System.out.println(map.put(8,"xiaoqiang"));//wangcai 存相同键，值会覆盖。
map.put(2,"zhangsan");
map.put(7,"zhaoliu");
//删除。
// System.out.println("remove:"+map.remove(2));
//判断。
// System.out.println("containskey:"+map.containsKey(7));
//获取。
System.out.println("get:"+map.get(6));
System.out.println(map);
}
03-常用对象API(集合框架-重点方法keySet演示图解)
//取出map中的所有元素。
//原理，通过keySet方法获取map中所有的键所在的Set集合，在通过Set的迭代器获取到每一个键，
//在对每一个键通过map集合的get方法获取其对应的值即可。
/*
Set<Integer>keySet = map.keySet();
Iterator<Integer>it = keySet.iterator();
while(it.hasNext()){
Integer key = it.next();
String value = map.get(key);
System.out.println(key+":"+value);
}
*/
原理图:
04-常用对象API(集合框架-重点方法entrySet演示图解).
/*
* 通过Map转成set就可以迭代。
* 找到了另一个方法。entrySet。
* 该方法将键和值的映射关系作为对象存储到了Set集合中，而这个映射关系的类型就是Map.Entry类型(结婚证)
*
*
*/
Set<Map.Entry<Integer,String>> entrySet = map.entrySet();
Iterator<Map.Entry<Integer,String>> it = entrySet.iterator();
while(it.hasNext()){
Map.Entry<Integer, String> me = it.next();
Integer key = me.getKey();
String value = me.getValue();
System.out.println(key+"::::"+value);
}
05-常用对象API(集合框架-方法values演示).
map.put(8,"zhaoliu");
map.put(2,"zhaoliu");
map.put(7,"xiaoqiang");
map.put(6,"wangcai");
Collection<String>values = map.values();
Iterator<String>it2 = values.iterator();
while(it2.hasNext()){
System.out.println(it2.next());
}
06-常用对象API(集合框架-Map集合-常见子类对象)
Map常用的子类：
|--Hashtable :内部结构是哈希表，是同步的。不允许null作为键，null作为值。
|--Properties：用来存储键值对型的配置文件的信息，可以和IO技术相结合。
|--HashMap: 内部结构是哈希表，不是同步的。允许null作为键，null作为值。
|--TreeMap : 内部结构是二叉树，不是同步的。可以对Map集合中的键进行排序。
07-常用对象API(集合框架-Map集合-HashMap存储自定义对象)
/*
* 将学生对象和学生的归属地通过键与值存储到map集合中。
*
*/
HashMap<Student,String>hm = new HashMap<Student,String>();
hm.put(new Student("lisi",38),"北京");
hm.put(new Student("zhaoliu",24),"上海");
hm.put(new Student("xiaoqiang",31),"沈阳");
hm.put(new Student("wangcai",28),"大连");
hm.put(new Student("zhaoliu",24),"铁岭");
// Set<Student> keySet= hm.keySet();
// Iterator<Student> it= keySet.iterator();
Iterator<Student>it = hm.keySet().iterator();
while(it.hasNext()){
Student key = it.next();
String value = hm.get(key);
System.out.println(key.getName()+":"+key.getAge()+"---"+value);
}
08-常用对象API(集合框架-Map集合-TreeMap存储自定义对象)
TreeMap<Student,String>tm = newTreeMap<Student,String>(new ComparatorByName());
tm.put(new Student("lisi",38),"北京");
tm.put(new Student("zhaoliu",24),"上海");
tm.put(new Student("xiaoqiang",31),"沈阳");
tm.put(new Student("wangcai",28),"大连");
tm.put(new Student("zhaoliu",24),"铁岭");
Iterator<Map.Entry<Student,String>> it = tm.entrySet().iterator();
while(it.hasNext()){
Map.Entry<Student,String> me = it.next();
Student key = me.getKey();
String value = me.getValue();
System.out.println(key.getName()+":"+key.getAge()+"---"+value);
}
day18 学习结果：
1，泛型类，泛型方法，泛型接口什么时候用？并举例！
2，泛型的通配符，以及泛型的限定的表现形式，和用法，以及什么时候用？
? extends E: 存储元素对象的时候用，你定义的是E类型，我们可以存储E类型或者E的子类型的对象。
? super E:从容器中取出元素时使用，容器中有E类型对象，取出时可使用E类型接收，或者E的父类型接收。比如比较器。
3，泛型的细节作为了解？
4，要求api中涉及泛型限定的方法一定要看的懂并会用，比如TreeSet集合的构造函数。
5，Map集合的特点以及常见子类的特点？
6，Map集合中，取出所有元素原理，以及keySet,entrySet方法的使用，必须会？
7，Map集合和Collection集合的区别？
1，
Map中一次存储是键值对。
Collection中一次存储是单个元素。
2，
Map的存储使用的put方法。
Collection存储使用的是add方法。
3，
Map的取出，是讲Map转成Set，在使用迭代器取出。
Collection取出，使用就是迭代器。
4，
如果对象很多，必须使用容器存储。
如果元素存在着映射关系，可以优先考虑使用Map存储或者用数组，
如果没有映射关系，可以使用Collection存储。
8，Map集合的使用场景。要求，将常见的体现之一：查表法回顾一下，并用map集合完成一次查表法。
练习:
"fdgavcbsacdfs" 获取该字符串中，每一个字母出现的次数。
要求打印结果是：a(2)b(1)...;
最后
以上就是坦率白云为你收集整理的day18_Map集合+泛型的全部内容，希望文章能够帮你解决day18_Map集合+泛型所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复