集合框架--Map

Map集合用于存储键值对，一对一对存，而且要保证键的唯一性

Map
|–Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。
|–HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。
|–TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

Map集合的共性方法：

1. 添加。
    V  put(K key, V value) 
    void  putAll(Map<? extends K,? extends V> m) 
    注意：添加元素时如果出现添加相同的键，那么后添加的值会覆盖原有键对应值，并且put方法会返回被覆盖的值。

2. 删除。
    void  clear() 
    V  remove(Object key) 

3. 判断。
    boolean  containsValue(Object value) 
    boolean  containsKey(Object key) 
    boolean  isEmpty() 

4. 获取。
    V  get(Object key) //可以通过get方法的返回值来判断一个键是否存在。返回null则不存在
    int  size() 
    Collection<V>  values()     //返回集合

Map的两种遍历方式：

//1. Set<K> keySet()方法
import java.util.*;
class Test1
{
    public static void main(String args[])
    {
        Map<String,String> map = new HashMap<String,String>();
        map.put("01", "zhangsan1");
        map.put("02", "zhangsan2");
        map.put("03", "zhangsan3");
        //1.先获取map集合的所有键的Set集合
        Set<String> keyset = map.keySet();
        //2.对键的set集合进行迭代取出
        Iterator<String> it = keyset.iterator();
        while(it.hasNext())
        {
            String mkey = it.next();
            //3.根据键取出对应的值
            String mvalue = map.get(mkey);
            System.out.println(mkey+":"+mvalue);
        }
    }
}

//2.Set<Map.Entry<K,V>> entrySet() 方法
import java.util.*;
class Test2
{
    public static void main(String args[])
    {
        Map<String,String> map = new HashMap<String,String>();
        map.put("01", "zhangsan1");
        map.put("02", "zhangsan2");
        map.put("03", "zhangsan3");
        //1.将Map集合中的映射关系取出,存入到Set集合中
        Set<Map.Entry<String, String>> entryset = map.entrySet();
        //2.对映射关系的set集合进行迭代取出
        Iterator<Map.Entry<String, String>> it = entryset.iterator();
        while(it.hasNext())
        {
            Map.Entry<String, String> me = it.next();
            //3.使用Map.Entry的方法取出键和值
            String mkey = me.getKey();
            String mvalue = me.getValue();
            System.out.println(mkey+":"+mvalue);
        }
    }
}

Entry其实就是Map中的一个static内部接口，之所以要定义在内部，因为只有有了Map集合，有了键值对，才会有键值的映射关系。关系属于Map集合中的一个内部事物，而且该事物在直接访问Map集合中的元素。

---

---

Map和Set的操作很像，而实际上，Set 的底层是由Map来实现的。所以关于HashMap和TreeMap的使用，也是可以参考Set的。

import java.util.*;
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 void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int hashCode()
    {
        return name.hashCode()+age*34;
    }
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Student))
            throw new ClassCastException("类型不匹配");
        Student stu = (Student)obj;
        return this.name.equals(stu.name) && this.age==stu.age;
    }
    public String toString()
    {
        return name+":"+age;
    }
}
public class TreeMapDemo {

    public static void main(String[] args) {
        TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuComparator());
        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("lisi2",22),"shanghai");
        Set<Map.Entry<Student, String>> entryset = tm.entrySet();
        Iterator<Map.Entry<Student, String>> it = entryset.iterator();
        while(it.hasNext())
        {
            Map.Entry<Student, String> me = it.next();
            Student stu = me.getKey();
            String addr = me.getValue();
            System.out.println(stu+":"+addr);
        }
    }

}

---

---

一对多的映射关系：
eg: ytu计算机学院有CS和SE两个专业，专业分别有各自的学生，学生有学号和姓名。这里面存在两个嵌套的Map集合：一个CS对应一个CS专业的Map（学号和姓名映射）

public class Map2 {

    public static void main(String[] args) {
        HashMap<String,HashMap<String,String>> YTU = new HashMap<String,HashMap<String,String>>();  //最外层的Map

        HashMap<String,String> CS = new HashMap<String,String>();
        HashMap<String,String> SE = new HashMap<String,String>();

        YTU.put("CS",CS);
        YTU.put("SE",SE);

        CS.put("01","zhangsan");
        CS.put("02","lisi");
        SE.put("01","wangwu");
        SE.put("02","zhaoliu");
        //获取所有专业名键
        Set<String> majornames = YTU.keySet();
        Iterator<String> it = YTU.keySet().iterator();
        while(it.hasNext())
        {
            String majorname = it.next();
            System.out.println(majorname);
            //获取该键对应的Map
            HashMap<String,String> classes = YTU.get(majorname);
            //遍历这个Map
            Set<String> nums = classes.keySet();
            Iterator<String> it2 = classes.keySet().iterator();
            while(it2.hasNext())
            {
                String num = it2.next();
                String name = classes.get(num);
                System.out.println(num+":"+name);
            }
        }
    }
}