Java基础视频教程第16天_Map集合

一、集合—— Map 概述

Map<K,V>  —— key value

Map 集合: 该集合存储键值对，一对一对往里存，而且要保证键的唯一性。值可以不唯一。

注意：
一个键只能对应一个值，但是一个值可以对应多个键。

1、添加
V put(K key, V value);
void putAll(Map<? extends K,? extends V> m);

2、删除
void clear();
V remove(Object key);

3、判断
boolean containsKey(Object key);
boolean containsValue(Object value);
boolean isEmpty();

4、获取
V get(Object key);
int size();
Collection<V> values();

Set<Map.Entry<K,V>> entrySet();
Set<K> keySet();

二、集合 —— Map 子类对象特点 
Map
--Hashtable: 底层是哈希表数据结构，不可以存入null键null值。该集合线程同步。效率低。

--HashMap: 底层是哈希表数据结构，可以使用null键null值，该集合是不同步的。出现于JDK1.2 。效率高。

--TreeMap: 底层是二叉树数据结构，线程不同步，可以用于给 Map 集合中的键进行排序。

Map 和 Set 很像。
其实, Set 底层使用的是 Map 集合。

三、集合 —— Map 共性方法 
注意：
添加时，如果添加相同的键，那么后添加的值会覆盖原有键对应的值，同时put方法会返回被覆盖的值。

常见方法演示：
	import java.util.*;
class MapDemo
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();

//添加元素
sop("put: "+map.put("01","zhangsan1"));//返回 null
sop("put: "+map.put("01","wangwu"));//返回zhangsan1,同时被wangwu覆盖。
map.put("02","zhangsan2");
map.put("03","zhangsan3");
map.put(null,"zhangsan4");//打印结果 null=zhangsan4
map.put("05",null);//打印结果 05=null

sop(map);//{null=zhangsan4, 05=null, 01=wangwu, 02=zhangsan2, 03=zhangsan3}

sop("containsKey: "+map.containsKey("02"));//判断该键是否存在 true
sop("containsValue: "+map.containsValue("zhangsan1"));//判断该值是否存在 false

//map.clear();//清空集合

sop("get: "+map.get("02"));//根据键获取值，也可用于判断该键是否存在。get: zhangsan2

sop("remove: "+map.remove("02"));//删除该键所在的元素,remove: zhangsan2

Collection<String> coll = map.values();
sop(coll);//[zhangsan4, null, wangwu, zhangsan3]
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

四、集合 —— Map--keySet 
Map 集合的两种取出方式：
1, Set keySet(); 将 Map 中所有的键存入到 Set 集合。因为 Set 集合具备迭代器，可以用迭代的方式取出所有的键，再根据get方法获取每一个键对应的值。
2, Set<Map.Entry<K,V>> entrySet();

keySet()方法演示：
[code]	import java.util.*;
class MapDemo2
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();

map.put("02","zhangsan2");
map.put("01","zhangsan1");
map.put("03","zhangsan3");
map.put("04","zhangsan4");

//先获取Map集合中所有键的集合，keySet();
Set<String> ks = map.keySet();

Iterator<String> it = ks.iterator();//此时ks是一个Set集合
while (it.hasNext())
{
String key = it.next();//获取Set集合中的元素，获取key
String value = map.get(key);//通过key获取value
System.out.println(key+" : "+value);
}
}
}

原理：
从双列集合 Map 的中取出包含键的单列集合 Set ，再通过Set集合的迭代器取出Set集合中的键，然后通过map的get(key)方法获取键对应的值。

五、集合 —— Map--entrySet

java.util.Map.Entry<K,V>
public static interface Map.Entry<K,V> 它是 Map 的内部接口。

Map 集合的取出方式二：
Set<Map.Entry<K,V>> entrySet();

原理：
将 Map 集合中的映射关系存入到了 Set 集合中，这个关系的数据类型是 Map.Entry<K,V> 。
然后通过Set集合迭代器的方式取出 Map.Entry<K,V>对象, 再通过这个对象 Map.Entry 中的方法getKey()和getValue()获取关系中的键和值。

理解：
可以将一对一对的夫妻当做键值对存入Map集合；丈夫代表key，妻子代表value，结婚证书就代表Map.Entry

Map.Entry<K,V>的方法：
boolean equals(Object obj);
K getKey();
V getValue();
int hashCode();
V set(V value); 用指定的值替换与此项对应的值。

Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。示例代码：

interface Map
{
public static interface Entry //接口中可以定义内部接口
{
public abstract Object getKey();
public abstract Object getValue();
}
}
class HashMap implements Map
{
class Haha implements Map.Entry
{
public Object getKey(){}
public Object getValue(){}
}
}

entrySet()方法演示：

import java.util.*;
class MapDemo3
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();

map.put("02","zhangsan2");
map.put("01","zhangsan1");
map.put("03","zhangsan3");
map.put("04","zhangsan4");

//将Map集合中的映射关系取出，存入到Set集合中
Set<Map.Entry<String,String>> ent = map.entrySet();

Iterator<Map.Entry<String,String>> it = ent.iterator();//迭代Set集合

while(it.hasNext())
{
Map.Entry<String,String> me = it.next();//获取Set集合中的元素
String key = me.getKey();//调用该元素的方法获取键
String value = me.getValue();//调用该元素的方法获取值

System.out.println(key+"...."+value);
}
}
}

六、集合 —— Map 练习

需求：
每一个学生都有对应的归属地，学生属性：姓名，年龄；
学生Student视为键key, 地址String视为值value，将两者存入Map集合中。

注意：姓名和年龄相同视为同一个学生，保证学生的唯一性。

思路：
1、定义一个学生类，定义对应属性和方法；
2、学生类中，复写hashCode(),equals()方法，这样就可以存入到HashSet集合中；
3、学生类实现Comparable接口，复写compareTo()方法；
4、创建一个Map集合，将学生对象作为键，地址作为值传入集合中；
5、遍历取出集合中的元素。

代码：

import java.util.*;

class MapTest
{
public static void main(String[] args)
{
HashMap<Student,String> hm = new HashMap<Student,String>();
hm.put(new Student("lisi1",21),"beijing");
hm.put(new Student("lisi1",21),"tianjing");
hm.put(new Student("lisi2",22),"shanghai");
hm.put(new Student("lisi3",23),"nanjing");
hm.put(new Student("lisi4",24),"wuhan");

Set<Student> keyset = hm.keySet();
Iterator<Student> it = keyset.iterator();
while (it.hasNext())
{
Student s = it.next();
String addr = hm.get(s);
System.out.println(s+"..."+addr);
}

Set<Map.Entry<Student,String>> ent = hm.entrySet();
Iterator<Map.Entry<Student,String>> iter = ent.iterator();
while (iter.hasNext())
{
Map.Entry<Student,String> me = iter.next();
Student s = me.getKey();
String addr = me.getValue();
System.out.println(s+"......."+addr);
}
}
}

class Student implements Comparable<Student>
{
private String name;
private int age;
Student(String name, int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Student s)
{
int num = this.age-s.age;
if (num==0)
{
return this.name.compareTo(s.name);
}
return num;
}
public int hashCode()
{
return name.hashCode()+age*37;
}
public boolean equals(Object obj)
{
if (!(obj instanceof Student))
throw new ClassCastException("不是学生");
Student s = (Student)obj;
return this.name.equals(s.name) && this.age==s.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public String toString()
{
return name+": "+age;
}
}

七、集合 —— TreeSet 练习

通过查阅API发现，TreeMap集合可以通过构造函数给定比较器：
TreeMap(Comparator<? super K> comparator)，可以传入泛型定义为K类或者K的父类类型的比较器

需求：对学生对象的年龄进行升序排序

因为数据是以键值对的形式存在的。
所以要使用可以排序的Map集合。

思路：
定义一个比较器，将学生年龄作为主要条件，姓名作为次要条件即可。

代码：

import java.util.*;
class MapTest2
{
public static void main(String[] args)
{
TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuAgeCom());
tm.put(new Student("lisi7",21),"beijing");
tm.put(new Student("lisi3",23),"nanjing");
tm.put(new Student("lisi1",24),"wuhan");
tm.put(new Student("lisi2",22),"shanghai");

Set<Map.Entry<Student,String>> ent = tm.entrySet();//获取Set集合

Iterator<Map.Entry<Student,String>> it = ent.iterator();//迭代
while(it.hasNext())
{
Map.Entry<Student,String> me = it.next();//获取集合中的元素
Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu+"...."+addr);
}
}
}

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

八、集合 —— TreeMap 练习——字母出现的次数

练习：
"aaabbccccddddd"获取该字符串中字母出现的次数

希望打印结果：a(1) c(2) ......

分析：
通过结果发现，每一个字母都有对应的次数。
说明字母和次数之间都有映射关系。
因此可以使用Map集合。

什么时候使用 Map集合呢？
当数据之间存在映射关系时，就要先想Map集合。

思路：
1，将字符串转换成字符数组。因为要对每一个字母进行操作。
2，定义一个map集合，因为打印结果的字母有顺序，所以使用TreeMap集合。
3，遍历字符数组。
将每一个字母作为键去查map集合；
如果返回null，将该字母和1存入到map集合中；
如果返回不是null，说明该字母在map集合已经存在并有对应次数；
那么就获取该次数并进行自增，然后将该字母和自增后的次数存入到map集合中，覆盖原来键所对应的值。
4，将map集合中的数据变成指定的字符串形式返回。

代码：

import java.util.*;
class MapTest3
{
public static void main(String[] args)
{
System.out.println('a'-'c');
String str = "aapklabbccc++--..cdddd";
String s = charCount(str);
System.out.println(s);
}
public static String charCount(String str)
{
char[] chs = str.toCharArray();//字符串变数组

TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();//创建集合

int count = 0;
for (int x=0 ;x<chs.length ;x++ )//遍历数组
{
if(!(chs[x]>='a' && chs[x]<='z' || chs[x]>='A' && chs[x]<='Z'))
continue;
Integer value = tm.get(chs[x]);
if(value!=null)
count = value;
count = count+1;
tm.put(chs[x],count);
count = 0;
}
//System.out.println(tm);

StringBuilder sb = new StringBuilder();

Set<Map.Entry<Character,Integer>> entryset = tm.entrySet();
Iterator<Map.Entry<Character,Integer>> it = entryset.iterator();
while(it.hasNext())
{
Map.Entry<Character,Integer> me = it.next();
Character ch = me.getKey();
Integer value = me.getValue();
sb.append(ch+"("+value+")  ");
}

return sb.toString();
}
}

九、集合 —— Map 扩展

Map集合被使用是因为具备映射关系，而集合中存放的是具体对象，集合也是对象；
那么，就可以往集合中存入集合对象。也就是集合中嵌套集合。
例如：
将一个学校视为一个集合，该学校有很多班级；
每一个班级又视为一个集合，每一个班级中有很多具体的学生。
以传智播客为例：
传智播客有预热班和就业班；
每个班级都有自己的学生。
学生只有id和name两个属性。
方式一：
用Map集合表示一个学校，用List集合表示一个班级，班级中存放的是具体的学生对象
HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();
List<Student> yure = new ArrayList<Student>();
List<Student> jiuye = new ArrayList<Student>();
方式二：
用Map集合表示一个学校，用Map集合表示一个班级，班级中存放的是以学生的id和名字的键值对形式存放
HashMap<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();//创建一个学校集合
HashMap<String,String> yure = new HashMap<String,String>();//创建一个班级yure
HashMap<String,String> jiuye = new HashMap<String,String>();//创建一个班级jiuye

代码：

import java.util.*;
class Student
{
private String id;
private String name;
Student(String id, String name)
{
this.id = id;
this.name = name;
}
public String toString()
{
return id+"::"+name ;
}
}
class MapDemo4
{
//主函数
public static void main(String[] args)
{
demo();
//demo_2();
}
//方式一：
public static void demo()
{
//创建一个学校集合
HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();

//创建两个班级
List<Student> yure = new ArrayList<Student>();
List<Student> jiuye = new ArrayList<Student>();

//将班级加入学校
czbk.put("yureban",yure);
czbk.put("jiuyeban",jiuye);

//每个班级中添加学生对象
yure.add(new Student("01","zhangsan"));
yure.add(new Student("02","lisi"));
jiuye.add(new Student("01","wangwu"));
jiuye.add(new Student("02","zhaoliu"));

//迭代这个学校集合，取出每一个班级集合
Iterator<String> it = czbk.keySet().iterator();
while(it.hasNext())
{
String roomName = it.next();
List<Student> room = czbk.get(roomName);
System.out.println(roomName);

//调用迭代班级中学生的方法
getInfos(room);
}
}
//定义一个方法，用于迭代取出班级中的每一个学生对象
public static void getInfos(List<Student> list)
{
Iterator<Student> it = list.iterator();
while(it.hasNext())
{
Student s = it.next();
System.out.println(s);
}
}

//方式二：
public static void demo_2()
{
HashMap<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();//创建一个学校集合

HashMap<String,String> yure = new HashMap<String,String>();//创建一个班级yure

HashMap<String,String> jiuye = new HashMap<String,String>();//创建一个班级jiuye

//将班级加入学校
czbk.put("yureban",yure);
czbk.put("jiuyeban",jiuye);

//将学生的id和name作为键值对传入班级集合中
yure.put("01","zhangsan");
yure.put("02","lisi");
jiuye.put("01","wangwu");
jiuye.put("02","zhaoliu");

//迭代这个学校集合，取出每一个班级
Iterator<String> it = czbk.keySet().iterator();
while(it.hasNext())
{
String roomName = it.next();
HashMap<String,String> room = czbk.get(roomName);
System.out.println(roomName);

//调用取出学生的方法。
getStudentInfo(room);
}
}
//定义一个方法，用于取出班级中的学生id和name
public static void getStudentInfo(HashMap<String,String> roomMap)
{
Iterator<String> it = roomMap.keySet().iterator();
while(it.hasNext())
{
String id = it.next();
String name = roomMap.get(id);
System.out.println(id+"..."+name);
}
}
}