Java集合---Map

Map接口定义的集合又称为查找表，用于存储所谓的“Key-Value”映射对。

1、基本操作

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

/**
 * java.util.Map
 * Map看起来像是一个多行两列的表格。
 * 以key-value对的形式存放元素。
 * 在Map中key不允许重复（重复是依靠key的equals判断）
 * 常用的实现类为：HashMap
 */
public class MapDemo1 {

    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<String, Integer>();

        /*
         * V put(K k, V v)
         * 将给定的key-value对存入Map
         * 由于Map要求key不允许重复，所以使用Map已有的key存入一个新的value时的操作是
         * 替换value，那么返回值为该key原来对应的value。若是一个新的key，则返回值为null
         */
        Integer value = map.put("语文", 99);
        System.out.println("old: "+value);
        map.put("数学", 98);
        map.put("英语", 97);
        map.put("物理", 96);
        map.put("化学", 99);
        System.out.println(map);

        value = map.put("语文", 98);
        System.out.println(map);
        System.out.println("old: "+value);

        /*
         * V get(K k)
         * 根据给定的key获取对应的value，若当前Map中没有给定的key，则返回值为null 
         */
        value = map.get("数学");
        System.out.println("数学: "+value);
        value = map.get("体育");
        System.out.println("体育: "+value);   

        /*
         * V remove(K k)
         * 删除给定的key所对应的key-value对。
         * 返回值为被删除的key-value对中value 
         */
        System.out.println("删除数学"); 
        value = map.remove("数学");
        System.out.println(map);
        System.out.println("old: "+value);

        /*
         * boolean containsKey(K k)
         * 判断某个key是否在Map中存在
         */
        boolean b = map.containsKey("英语");
        System.out.println("b: "+b);

    }

}

---

2、遍历

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

/**
 * 遍历Map
 * 遍历Map有三种方式：
 * 遍历所有的key
 * 遍历所有的key-value对
 * 遍历所有的value(相对不常用)
 */
public class MapDemo2 {

    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("语文", 99);
        map.put("数学", 98);
        map.put("英语", 97);
        map.put("物理", 96);
        map.put("化学", 99);
        System.out.println(map);

        /*
         * 遍历所有的key
         * Set<K> keySet()
         * 该方法会将当前Map中所有的key存入一个Set集合后返回。
         * 那么遍历该集合就等于遍历了所有的key
         */
        Set<String> keySet = map.keySet();
        for(String key : keySet){
            System.out.println("key: "+key);
        }

        /*
         * 遍历每一组键值对
         * Map中每一组键值对都是由Map的内部类：
         * java.util.Map.Entry的一个实例表示的。
         * Entry有两个方法：getKey, getValue, 可以分别获取这一组键值对中的key与value.
         * 
         * Set<Entry> entrySet
         * 该方法会将Map中每一组键值对（Entry实例）存入一个Set集合后返回。
         */
        Set<Entry<String, Integer>> entrySet = map.entrySet();
        for(Entry<String, Integer> e : entrySet){
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.println(key+":"+value);
        }

        /*
         * 遍历所有的value
         * Collection values()
         * 该方法会将当前Map中所有的value存入一个集合后返回。
         */
        Collection<Integer> values = map.values();
        for(Integer value : values){
            System.out.println("value: "+value);
        }


    }

}

---

3、相关原理

/**
 * 当一个类的实例作为HashMap的key时，它的equals方法与hashcode方法的重写
 * 直接影响着散列表（HashMap）的查询性能。
 * 在API文档中Object对这两个方法的重写做了说明：
 * 当我们重写一个类的equals方法时，就应当连同重写hashcode方法。
 * 这两个方法重写应当遵循：
 * 1:一致性，当两个对象equals比较为true时，hashcode方法返回的数字必须相等。反过来虽然不是必须的，
 *   但也应当遵循，否则在HashMap中会形成链表影响查询性能。所以两个对象hashcode值相同，equals比较
 *   也应当为true。
 * 2:稳定性： hashcode方法多次调用后返回的数字应当相同，不应是一个变化的值，除非参与equals比较的属性值发生了改变
 */
public class Key {
    private int x;
    private int y;

    public Key(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + x;
        result = prime * result + y;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Key other = (Key) obj;
        if (x != other.x)
            return false;
        if (y != other.y)
            return false;
        return true;
    }

}