Java入门（三十五）

Map集合概述和特点

• map由两部分组成，k是map集合里面存储键的类型，v是map里面存储值的类型。
• map集合是一个接口，将键映射到值的对象，他不能包含重复的键，每个键可以映射到一个值。
• 举例，比如下面的学号对应姓名。学号是不能重复的，并且一定对应一个姓名

itheima001	林青霞
itheima002	张曼玉
itheima003	王祖贤

• map是一个接口不能创建对象，HashMap实现了map接口。
• 创建map集合采用多态的方式，使用具体的实现类HashMap。

import java.util.HashMap;
import java.util.Map;

public class MapDemo01 {
    public static void main(String[] args) {
        //创建map集合对象
        Map<String,String> map = new HashMap<String,String>();
    }
}

• put方法，map集合添加的方法用的是put。
  
• 添加三个元素，看有没有成功

        map.put("itheima001","林青霞");
        map.put("itheima002","张曼玉");
        map.put("itheima003","王祖贤");
        System.out.println(map);

• 存储了三个元素，他的键和值通过等于号连接起来。是HashMap重写了toString方法，他的键和值用=号拼接了起来，最终输出数据。
• 他的键是唯一的，不能包含重复的。如果添加一个重复键，再等于不同的值。可以看见他的值被修改了。原来的值被替代掉。
• 当键第一次出现的时候是添加元素，当键第二次出现的时候是修改元素，用后面的值把前面的值替代掉。
• 保证键的唯一性是HaspMap实现的，底层数据结构是哈希表，哈希表主要是用来保证Map集合的键的唯一性。

Map集合的基本功能

方法名	说明
V put(K key, V value)	添加元素
V remove(Object key)	根据键删除键值对元素
void clear()	移除所有的键值对元素
boolean containsKey(Object key)	判断集合是否包含指定的键
boolean containsValue(Object value)	判断集合是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中键值对的个数

• 试下使用方法

import java.util.Map;
import java.util.HashMap;

public class MapDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();
        //添加元素
        map.put("张无忌","赵敏");
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");
        //输出集合对象
        System.out.println(map);
    }
}

- 测试remove方法，删除郭靖这个键，黄蓉这个元素就不存在集合了。

        //remove方法
        System.out.println(map.remove("郭靖"));
        //输出集合对象
        System.out.println(map);

• 删除不存在的值，返回null
  
• 测试clear方法

        //clear方法
        map.clear();
        //输出集合对象
        System.out.println(map);

• containsKey方法

        System.out.println(map.containsKey("郭靖"));

• containsValue判断里面是否包含值
  
• 判断集合是否为空

        System.out.println(map.isEmpty());

• 测试长度的方法 size

        System.out.println(map.size());

Map集合的获取功能

方法名	说明
V get(Object key)	根据键获取值
Set< K> keySet()	获取所有键的集合
Collection< V> values()	获取所有值的集合
Set<Map.Entry<K,V>>entrySet()	获取所有键值对对象的集合

• Collection这里是因为返回的值不能保证是唯一的，所以用Collection。

import java.util.HashMap;
import java.util.Map;

public class MapDemo03 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String >map = new HashMap<String,String>();
        //添加元素
        map.put("张无忌","赵敏");
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");
        //get方法，根据键获取值
        System.out.println(map.get("张无忌"));
    }
}

• 如果键对应的值不存在，则返回null
  
• keySet方法

        Set<String> keySet = map.keySet();
        for(String key : keySet){
            System.out.println(key);
        }

• keySet就是获取集合中的键
  
• Collection < V > values() 获取所有值的集合

        Collection<String> values = map.values();
        for(String value : values){
            System.out.println(value);
        }

• 输出map中所有的值
  

Map集合的遍历（方式1）

• 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合，假如现在有很多夫妻在一起，我要找到丈夫对应的妻子怎么办呢？
• 首先把所有的丈夫集中起来，然后遍历所有丈夫的集合获取到每一个丈夫，最后让丈夫赵对应的妻子。这样就可以找到每一个丈夫对应的妻子。
• 转换为Map集合的操作：

1. 获取所有键的集合，用keySet()方法实现
2. 遍历键的集合，获取到每一个键，用增强for可以实现。
3. 根据键找值，用get(Object Key) 方法实现

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo04 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();
        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");
        //获取所有键的集合，用keySet()方法实现
        Set<String> keySet = map.keySet();
        //遍历键的集合，获取到每一个键，用增强for实现
        for (String key : keySet) {
            //根据键去找值，用get(Object key)方法实现
            String value = map.get(key);
            System.out.println(key + "," + value);
        }
    }
}

Map集合的遍历（方式2）

• 获取所有结婚证的集合

• 遍历结婚证的集合，得到每一个结婚证

• 根据结婚证后去丈夫和妻子

• 思路

1. 获取所偶有键值对对象的集合，使用entrySet方法，Map.Entry可以看做是一个键值对对象，他包含了K和V。
   
2. 用增强for实现，得到每一个Map.Entry，用方法去获取键值
   

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo05 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();
        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");
        //获取所有键值对对象的集合
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        //遍历键值对对象的集合，得到每一个键值对对象
        for(Map.Entry<String, String> me : entrySet){
            //根据键值对对象获取键和值
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "," + value);
        }
    }
}

HashMap集合存储学生对象并遍历

• 需求：创建一个HashMap集合，键是学号（String），值是学生对象（Student），存储三个键值对元素，并遍历。
• 思路：

1. 定义学生类
2. 创建HashMap集合对象
3. 创建学生对象
4. 把学生添加到集合
5. 遍历集合 ：①根据键找值 ②键值对对象找键和值

• 定义Student类

package generic.itheima06;

public class Student {
    private String name;
    private int 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;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }
}

• 方式1

import java.util.HashMap;
import java.util.Set;

public class HashMapDemo {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<String, Student> hm = new HashMap<String, Student>();
        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("张曼玉", 35);
        Student s3 = new Student("王祖贤", 33);
        //把学生添加到集合
        hm.put("itheima001", s1);
        hm.put("itheima002", s2);
        hm.put("itheima003", s3);
        //方式1：键找值
        Set<String> keySet = hm.keySet();
        for (String key : keySet) {
            Student value = hm.get(key);
            System.out.println(key + "," + value.getName() + "," + value.getAge());
        }
    }
}

• 方式2

        //方式2：键值对对象找键和值
        Set<Map.Entry<String,Student>> entrySet = hm.entrySet();
        for (Map.Entry<String,Student> me : entrySet){
            String key = me.getKey();
            Student value = me.getValue();
            System.out.println(key + "," + value.getName() + "," + value.getAge());
        }

案例

• 需求：创建一个HashMap集合，键是学生对象（Student），值是居住地（String）。存储多个键值对元素，并遍历。要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象。
• 自定义的类型保证唯一性，这里是HashMap类型，HashMap集合底层数据结构是哈希表，主要是用来保证键的唯一性，所以学生对象里面要重写两个方法。
• 思路：

1. 定义学生类
2. 创建HashMap集合对象
3. 创建学生对象
4. 把学生添加到集合
5. 遍历集合
6. 在学生类中重写两个方法保证键的唯一性：hashCode(),equals()。自动生成即可

package generic.itheima07;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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;
    }
}

• 创建HashMap集合对象

import java.util.HashMap;
import java.util.Set;

public class HashMapDemo {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<Student,String> hm = new HashMap<Student,String>();
        //创建学生对象
        Student s1 = new Student("林青霞",30);
        Student s2 = new Student("张曼玉",35);
        Student s3 = new Student("王祖贤",33);
        //把学生添加到集合
        hm.put(s1,"西安");
        hm.put(s2,"武汉");
        hm.put(s3,"郑州");
        //遍历集合
        Set<Student> keySet = hm.keySet();
        for(Student key : keySet){
            String value = hm.get(key);
            System.out.println(key.getName()+","+key.getAge()+","+value);
        }

    }
}

• 创建一个和s3重复的s4，结果发现两个结果都出来了
  
• 所以我们要在学生类里面重写两个方法
  

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

• 再执行一遍，王祖贤就住到北京去了。

ArrayList集合存储HashMap元素并遍历

• HashMap本身是一个集合，所以这里是集合嵌套。
• 需求：创建一个ArrayList集合，存储三个元素，每一个元素都是HashMap，每一个HashMap的键和值都是String，并遍历。
• 思路：

1. 创建ArrayList集合
2. 创建HashMap集合，并添加键值对元素
3. 把HashMap作为元素添加到ArrayList集合
4. 遍历ArrayList集合

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class ArrayListIncludeHashMapDemo {
    public static void main(String[] args) {
        //创建ArrayList集合
        ArrayList<HashMap<String, String>> array = new ArrayList<HashMap<String, String>>();
        //创建HashMap集合并添加键值对元素
        HashMap<String, String> hm1 = new HashMap<String, String>();
        hm1.put("孙策", "大乔");
        hm1.put("周瑜", "小乔");
        //把HashMap作为元素添加到ArrayList集合
        array.add(hm1);

        HashMap<String, String> hm2 = new HashMap<String, String>();
        hm2.put("郭靖", "黄蓉");
        hm2.put("杨过", "小龙女");
        //把HashMap作为元素添加到ArrayList集合
        array.add(hm2);

        HashMap<String, String> hm3 = new HashMap<String, String>();
        hm3.put("令狐冲", "任盈盈");
        hm3.put("林平之", "岳灵珊");
        //把HashMap作为元素添加到ArrayList集合
        array.add(hm3);

        //遍历ArrayList集合
        for (HashMap<String, String> hm : array) {
            Set<String> keySet = hm.keySet();
            for (String key : keySet) {
                String value = hm.get(key);
                System.out.println(key + "," + value);
            }
        }
    }
}

HashMap集合存储ArrayList元素并遍历

• 需求：创建一个HashMap集合，存储三个键值对元素，每一一个键值对的键是String，值是ArrayList。每一个ArrayList的元素是String，并遍历。
• 思路：

1. 创建HashMap集合
2. 创建ArrayList集合，并添加元素
3. 把ArrayList作为元素添加到HashMap集合
4. 遍历HashMap集合

package generic.itheima08;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class HashMapIncluseArrayListDemo {
    public static void main(String[] args) {
        //创建HashMap集合
        HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>();
        //创建ArrayList集合并添加元素
        ArrayList<String> sgyy = new ArrayList<String>();
        sgyy.add("诸葛亮");
        sgyy.add("赵云");
        //把ArrayList作为元素添加到HashMap集合
        hm.put("三国演义",sgyy);

        //创建ArrayList集合并添加元素
        ArrayList<String> xyj = new ArrayList<String>();
        xyj.add("唐僧");
        xyj.add("孙悟空");
        //把ArrayList作为元素添加到HashMap集合
        hm.put("西游记",xyj);

        //创建ArrayList集合并添加元素
        ArrayList<String> shz = new ArrayList<String>();
        shz.add("武松");
        shz.add("鲁智深");
        //把ArrayList作为元素添加到HashMap集合
        hm.put("水浒传",shz);

        //遍历HashMap集合
        Set<String> keySet = hm.keySet();
        for ( String key : keySet){
            ArrayList<String> value = hm.get(key);
            for(String s : value){
                System.out.println(s);
            }
        }

    }
}

• 但是这个输出我们看不出哪个是三国演义，哪个是西游记，哪个是水浒传的。所以修改一下输出语句