JavaSE笔记10.8-集合-Map_map.putall 传入null

一. Map概述

1. 定义

Map是一种键-值对（key-value）集合，Map集合中的每一个元素都包含一个键（key）对象和一个值（value）对象，用于保存具有映射关系的数据。

Collection是单列集合，Map是双列集合

2. Map的特点

• key和value都可以是任意引用类型的数据
• key不允许重复，value可以重复
• 每个key可以映射到最多一个value

二. Map的常见实现类

常见实现类：HashTable、HashMap、TreeMap

1. HashTable

• 底层是哈希表数据结构
• 按哈希算法来存取键对象，用作键的对象必须实现hashCode方法和equals方法
• HashTable中元素的排列顺序是不固定的
• 不可以存入null键null值
• 该集合是线程同步的，效率低

2. HashMap

• 底层是哈希表数据结构
• 按哈希算法来存取键对象，用作键的对象必须实现hashCode方法和equals方法
• HashMap中元素的排列顺序是不固定的
• 可以存入null键null值
• 该集合是线程不同步的，效率高

3. TreeMap

• 底层是二叉树结构
• 可以用于给Map集合中的键进行排序，具体是自然排序还是比较器排序取决于所使用的构造方法
• 该集合是线程不同步的，效率高

构造方法：

（1）TreeMap()

• 构造一个新的空的树图，根据键的自然排序进行排序
• 插入到地图中的所有键必须实现Comparable接口
• 只能添加相同数据类型的键对象，否则会抛出ClassCastException

（2）TreeMap(Comparator<? super K> comparator)

• 构造一个新的空的树图，键对象根据指定的比较器进行排序（comparator为用于对该集合进行排序的比较器）
• 只能添加相同数据类型的键对象，否则会抛出ClassCastException

（3）TreeMap(Map<? extends K,? extends V> m)

• 构造一个包含指定树图中的元素的新树图，根据键的自然排序进行排序
• 插入到地图中的所有键必须实现Comparable接口
• 只能添加相同数据类型的键对象，否则会抛出ClassCastException

三. Map接口的共性方法

1. 添加

V put(K key,V value);//向Map集合中添加键-值对
void putAll(Map<?entends K,?entends V> m);//将指定Map中的key-value复制到本Map中
1
2

注意：对于put方法，如果添加时已有相同的键，那么后添加的值会覆盖原有的键对应的值，而且put方法会返回被覆盖的值

2. 删除

void clear();//删除该Map对象中所有的key-value对
V remove(Object key);//从Map集合中删除key对应的键-值对，并返回对应的value；如果该key不存在，则返回null
1
2

3. 判断

boolean containKey(Object key);//查询Map中是否包含指定的key，如果包含则返回true
boolean containValue(Object value);//查询Map中是否包含一个或多个value，如果包含则返回true
boolean isEmpty();//查询Map中是否为空（不包含任何key-value对），如果为空则返回true
1
2
3

4. 获取

V get(Object key);//返回Map集合中指定键对象所对应的值
int size();//返回Map集合中key-value对的个数
Collection<V> values();//返回Map里所有value组成的Collection
Set<K> keySet();//返回Map集合中所有键对象的Set集合
Set<Map.Entry<k,V>> entrySet();//返回Map集合中所有键-值对的Set集合，此Set集合中元素的数据类型为Map.Entry
1
2
3
4
5

注意：对于get方法，如果返回null，说明该键可能并不存在（虽然可能存在值为null但键不为null的情况）

5. 例子

import java.util.*;
class MapDemo{
    public static void main(String[] args) {
        //使用泛型，创建1个Map的子类对象
        Map<String,String> map=new HashMap<String, String>();
        //添加元素,如果添加时已有相同的键，那么后添加的值会覆盖原有的键对应的值，而且put方法会返回被覆盖的值
        System.out.println(map.put("01","zhangsan"));
        System.out.println(map.put("01","lisi"));
        System.out.println(map);
        //HashMap允许使用null键null值
        map.put(null,"aha");
        map.put("03","zhangsan3");
        map.put("02","zhangsan2");
        //判断
        System.out.println("containsKey: "+map.containsKey("02"));
        //获取
        System.out.println("get: "+map.get("02"));
        System.out.println("get: "+map.get(null));
        Collection<String> coll=map.values();
        System.out.println(coll);
        //删除
        System.out.println("remove: "+map.remove("02"));
        System.out.println(map);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

运行结果是：

四. Map集合的2种取出方法

Map集合没有迭代器，要先将Map集合转成Set集合，再通过迭代器取出

1. Set keySet()

（1）使用步骤

• 将map中所有的键存入Set集合中
• 因为Set集合具备迭代器，所以可以用迭代方式取出所有的键
• 再根据get(Key)方法，获取每一个键对应的值

（2）keySet方法图例

（3）例子

import java.util.*;
class MapDemo{
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String, String>();
        map.put("02","zhangsan2");
        map.put("03","zhangsan3");
        map.put("01","zhangsan1");
        map.put("04","zhangsan4");

        //先获取Map集合中的所有键的Set集合，用keySet()
        Set<String> keyset=map.keySet();
        //有了Set集合，就可以获取其迭代器
        Iterator<String> it=keyset.iterator();
        while(it.hasNext()){
            String key=it.next();
            //有了键，就通过Map集合的get方法获取其对应的值
            String value=map.get(key);
            System.out.println("key: "+key+", value: "+value);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行结果是：

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

（1）使用步骤

• 将Map集合中的映射关系存入Set集合中，此集合的类型为Map.Entry
• 关系对象Map.Entry获取到后，就可以通过Map.Entry中的getKey和getValue方法获取到关系中的键和值

Map.Entry：
Entry接口是Map接口的一个内部接口，此接口为泛型，定义为Entry<K,V>，
它表示Map中的一个实体（一个key-value对），
接口中有getKey()、getValue()方法

（2）entrySet方法图例

（3）例子

import java.util.*;
class MapDemo{
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String, String>();
        map.put("02","zhangsan2");
        map.put("03","zhangsan3");
        map.put("01","zhangsan1");
        map.put("04","zhangsan4");

        //将Map中的映射关系取出,存入到set集合中
        Set<Map.Entry<String,String>> entrySet=map.entrySet();
        Iterator<Map.Entry<String,String>> it=entrySet.iterator();
        while (it.hasNext()){
            Map.Entry<String,String> me=it.next();
            String key=me.getKey();
            String value=me.getValue();
            System.out.println(key+":"+value);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行结果是：

五. HashMap存储自定义对象

需求：
存储学生对象及其对应的归属地，学生对象Student有属性姓名name和年龄age，归属地为String类型；
姓名和年龄相同的视为同一个学生，要保证学生的唯一性

思路：

• 描述学生
• 定义HashMap容器，将学生作为键（键不可重复）、归属地作为值存入容器
• 获取HashMap集合中的元素

代码：
HashMap容器中：用作键的对象必须实现hashCode方法和equals方法

import java.util.*;

//描述学生
class 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;
    }
    //HashMap容器中，用作键的对象必须实现hashCode方法和equals方法
    //复写hashCode方法
    public int hashCode(){
        return name.hashCode()+age*34;
    }
    //复写equals方法
    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;
    }
}
class MapTest{
    public static void main(String[] args) {
        //定义HashMap容器，将学生作为键、归属地作为值存入容器
        HashMap<Student,String> hm=new HashMap<Student,String>();
        hm.put(new Student("lisi1",21),"Beijing");
        hm.put(new Student("lisi1",21),"Tianjin");
        hm.put(new Student("lisi2",22),"Shanghai");
        hm.put(new Student("lisi3",23),"Nanjing");
        hm.put(new Student("lisi4",24),"Wuhan");

        //第一种取出方式 keySet
        Set<Student> keySet=hm.keySet();
        Iterator<Student> it=keySet.iterator();
        while (it.hasNext()){
            Student stu=it.next();
            String addr=hm.get(stu);
            System.out.println(stu+"..."+addr);
        }

        //第二种取出方式 entrySet
        Set<Map.Entry<Student,String>> entrySet=hm.entrySet();
        Iterator<Map.Entry<Student,String>> it1=entrySet.iterator();
        while (it1.hasNext()){
            Map.Entry<Student,String> me=it1.next();
            Student stu=me.getKey();
            String addr=me.getValue();
            System.out.println(stu+"......"+addr);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

运行结果是：

六. TreeMap存储自定义对象

1. 按学生对象的年龄进行排序

需求：
存储学生对象及其对应的归属地，学生对象Student有属性姓名name和年龄age，归属地为String类型；
姓名和年龄相同的视为同一个学生，要保证学生的唯一性；
对学生对象的年龄进行升序排序

思路：

• 描述学生
• 定义TreeMap容器，使用自然排序，将学生作为键、归属地作为值存入容器
• 获取TreeMap集合中的元素

代码：
自然排序，使用构造方法TreeMap()：所有键必须实现Comparable接口

import java.util.*;

//描述学生，实现Comparable接口
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;
    }
    //复写compareTo方法,按Student的年龄排序
    public int compareTo(Student s){
        int num=new Integer(this.age).compareTo(new Integer(s.age));
        if(num==0){
            return this.name.compareTo(s.name);
        }
        return num;
    }
}
class MapTest{
    public static void main(String[] args) {
        //定义TreeMap容器，将学生作为键、归属地作为值存入容器
        TreeMap<Student,String> tm=new TreeMap<Student,String>();
        tm.put(new Student("lisi3",23),"Nanjing");
        tm.put(new Student("lisi1",21),"Beijing");
        tm.put(new Student("lisi4",24),"Wuhan");
        tm.put(new Student("lisi1",21),"Tianjin");
        tm.put(new Student("lisi2",22),"Shanghai");

        //第一种取出方式 keySet
        Set<Student> keySet=tm.keySet();
        Iterator<Student> it=keySet.iterator();
        while (it.hasNext()){
            Student stu=it.next();
            String addr=tm.get(stu);
            System.out.println(stu+"..."+addr);
        }

        //第二种取出方式 entrySet
        Set<Map.Entry<Student,String>> entrySet=tm.entrySet();
        Iterator<Map.Entry<Student,String>> it1=entrySet.iterator();
        while (it1.hasNext()){
            Map.Entry<Student,String> me=it1.next();
            Student stu=me.getKey();
            String addr=me.getValue();
            System.out.println(stu+"......"+addr);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

2. 按学生对象的姓名进行排序

需求：
按学生对象的姓名进行排序

思路：
定义TreeMap容易，使用按Student的姓名排序的比较器

代码：
比较器排序，使用构造方法TreeMap(Comparator<? super K> comparator)：键对象根据指定的比较器进行排序

import java.util.*;

//定义按Student的姓名排序的比较器
class StuNameComparator implements Comparator<Student>{
    public int compare(Student o1, Student o2) {
        int num=o1.getName().compareTo(o2.getName());
        if(num==0){
            return new Integer(o1.getAge()).compareTo(new Integer(o2.getAge()));
        }
        return num;
    }
}

//描述学生，实现Comparable接口
class 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;
    }
}

class MapTest{
    public static void main(String[] args) {
        //定义TreeMap容器，将学生作为键、归属地作为值存入容器
        TreeMap<Student,String> tm=new TreeMap<Student,String>(new StuNameComparator());
        tm.put(new Student("blisi3",23),"Nanjing");
        tm.put(new Student("lisi1",21),"Beijing");
        tm.put(new Student("alisi4",24),"Wuhan");
        tm.put(new Student("lisi1",21),"Tianjin");
        tm.put(new Student("lisi2",22),"Shanghai");

        //第一种取出方式 keySet
        Set<Student> keySet=tm.keySet();
        Iterator<Student> it=keySet.iterator();
        while (it.hasNext()){
            Student stu=it.next();
            String addr=tm.get(stu);
            System.out.println(stu+"..."+addr);
        }

        //第二种取出方式 entrySet
        Set<Map.Entry<Student,String>> entrySet=tm.entrySet();
        Iterator<Map.Entry<Student,String>> it1=entrySet.iterator();
        while (it1.hasNext()){
            Map.Entry<Student,String> me=it1.next();
            Student stu=me.getKey();
            String addr=me.getValue();
            System.out.println(stu+"......"+addr);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

运行结果是：