Map接口

1概述

Map接口下的集合与Collection接口下的集合存储数据的形式不同。

Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。

Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找到所对应的值。

Collection中的集合称为单列集合，Map中的集合称为双列集合。

Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

 

2 Map接口常用方法

 

说明：

1）有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。

　　两个泛型变量<K,V>的数据类型可以相同，也可以不同。

2）put方法，添加。

　　若指定的键(key)在集合中没有，则没有这个键对应的值，返回null。

　　若有重复的键，那么值会被后添加的覆盖。

　　值和键不能都重复。

3）get方法，获取指定键(key)所对应的值(value)。

　　若没有指定的键，返回null（不会像set集合里那样报异常） 

例：

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

public class MapTest {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String,String>();
        //存
        map.put("a", "12");
        map.put("b", "1");
        map.put("a", "2");
        
        //取
        System.out.println(map.get("a"));
        System.out.println(map.get("b"));
        
        //删除
        String v=map.remove("b");
        System.out.println(v);
        System.out.println(map.get("b"));
    }
}

3 Map集合遍历

3.1键找值方式

通过元素中的键，获取键所对应的值

 

操作步骤：

1）获取Map集合中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键

2）遍历键的Set集合，得到每一个键

3）根据键，获取键所对应的值

例：

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

public class MyTest {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("a", "12");
        map.put("b", "1");
        map.put("c", "2");

        // 遍历--增强for
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key + ":" + map.get(key));
        }

        System.out.println();

        // 遍历--Iterator
        Set<String> keys2 = map.keySet();
        Iterator<String> it = keys2.iterator();
        while (it.hasNext()) {
            String key = it.next();
            String value = map.get(key);
            System.out.println(key + ":" + value);
        }        
    }
}

3.2 Entry键值对对象

在Map类设计时，提供了一个嵌套接口：Entry。Entry将键值对的对应关系封装成了对象。即键值对对象，这样在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

Map是接口，Entry也是接口

Map.entry是“结婚证”对象类型

获得对象：

 

Entry中的方法：

 

遍历例子：

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

public class MyTest {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("a", "12");
        map.put("b", "1");
        map.put("c", "2");

        // Entry遍历--增强for
        Set<Map.Entry<String, String>> entrys = map.entrySet();
        for (Map.Entry<String, String> entry : entrys) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + ":" + value);
        }

        System.out.println();

        // 遍Entry遍历--Iterator
        Iterator<Map.Entry<String, String>> it2 = entrys.iterator();
        while (it2.hasNext()) {
            Map.Entry<String, String> entry = it2.next();
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + ":" + value);
        }
    }
}

Tips：Map集合不能直接使用迭代器或者增强for进行遍历。但是转成Set之后就可以使用了。

 

4 Map接口中常用集合

4.1HashMap<K,V>

存储数据采用的哈希表结构，元素的存取顺序不能保证一致。

由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

（见HashSet解释）

 

4.2LinkedHashMap<K,V>

LinkedHashMap，存储数据采用的哈希表结构+链表结构。

通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

例：HashMap和LinkedHashMap存储自定义类型键值

（如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法）

public class Person {
    private String name;
    private int age;
    public Person() {
        super();
    }
    public Person(String name, int age) {
        super();
        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;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }        
}

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

public class PersonTest {
    public static void main(String[] args) {
        method01();
    }
    
    public static void method01(){
        Map<String,Person> map=new HashMap<String,Person>();
        map.put("java0601", new Person("小红",20));
        map.put("java0601", new Person("小明",21));
        map.put("java0929", new Person("小兰",17));
        map.put("java0929", new Person("小花",30));
        
        Set<String> clas=map.keySet();
        for(String s:clas){
            System.out.println(s+":"+map.get(s));
        }
    }
    
    public static void method02(){
        Map<Person,String> map=new HashMap<Person,String>();
        map.put(new Person("小红",20),"java0601");
        map.put(new Person("小明",21),"java0601");
        map.put(new Person("小兰",17),"java0929");
        map.put(new Person("小花",30),"java0929");
        map.put(new Person("小花",30),"java0929");
        
        Set<Person> clas=map.keySet();
        for(Person s:clas){
            System.out.println(s+":"+map.get(s));
        }
    }
    
    //有序
    public static void method03(){
        Map<Person,String> map=new LinkedHashMap<Person,String>();
        map.put(new Person("小红",20),"java0601");
        map.put(new Person("小明",21),"java0601");
        map.put(new Person("小兰",17),"java0929");
        map.put(new Person("小花",30),"java0929");
        map.put(new Person("小花",30),"java0929");
        
        Set<Person> clas=map.keySet();
        for(Person s:clas){
            System.out.println(s+":"+map.get(s));
        }
    }    
}

三个方法结果分别为：