java中的Map

Java8增强的Map集合

Map接口中定义了如下常用的方法。

void clear():删除该Map对象中的所有key-value对。 
boolean containsKey(Object key):查询Map中是否包含指定的key,如果包含则返回true。 
boolean containsValue(Object value):查询Map中是否包含一个或多个value，如果包含则返回true。 
Set entrySet():返回map中包含的key-value对所组成的Set集合，每个集合元素都是map.Entry对象 
Object get(Object key):返回指定key所对应的value；如果此map中不包含该key，则返回null。 
boolean isEmpty():查询该map是否为空，如果为空，则返回true。 
Set keySet():返回该map中所有key组成的set集合 
Object put(Object key,Object value):添加一个key-value对，如果当前map中已有一个与该key相等的key-value对，则新的key-value对会覆盖原来的key-value对。 
void putAll(Map m):将指定map中的key-value对复制到本map中 
Object remove(Object key):删除指定key所对应的key-value对，返回被删除key所关联的value，如果该key不存在，则返回null。 
boolean remove(Object key,Object value):这是java8新增的方法，删除指定key，value所对应的key-value对，如果从该map中成功地删除该key-value对，该方法返回true，否则返回false。 
int size():返回该map里的key-value对的个数。 
collection values():返回该map里所有value组成的collection。 
Map中包括了一个内部类Entry，该类封装了一个key-value对。Entry包含如下三个方法。 
Object getKey():返回该Entry里包含的key值 
Object getValue():返回该Entry里包含的value值。 
Object setValue(V value):设置该Entry里包含的value值，并返回新设置的value值。

import java.util.*;
public class MapTest
{
    public static void main(String[] args)
    {
        Map map = new HashMap();
        // 成对放入多个key-value对
        map.put("疯狂Java讲义" , 109);
        map.put("疯狂iOS讲义" , 10);
        map.put("疯狂Ajax讲义" , 79);
        // 多次放入的key-value对中value可以重复
        map.put("轻量级Java EE企业应用实战" , 99);
        // 放入重复的key时，新的value会覆盖原有的value
        // 如果新的value覆盖了原有的value，该方法返回被覆盖的value
        System.out.println(map.put("疯狂iOS讲义" , 99)); // 输出10
        System.out.println(map); // 输出的Map集合包含4个key-value对
        // 判断是否包含指定key
        System.out.println("是否包含值为 疯狂iOS讲义 key："
            + map.containsKey("疯狂iOS讲义")); // 输出true
        // 判断是否包含指定value
        System.out.println("是否包含值为 99 value："
            + map.containsValue(99)); // 输出true
        // 获取Map集合的所有key组成的集合，通过遍历key来实现遍历所有key-value对
        for (Object key : map.keySet() )
        {
            // map.get(key)方法获取指定key对应的value
            System.out.println(key + "-->" + map.get(key));
        }
        map.remove("疯狂Ajax讲义"); // 根据key来删除key-value对。
        System.out.println(map); // 输出结果不再包含 疯狂Ajax讲义=79 的key-value对
    }
}

Java8 为Map新增的方法

Object compute(Object key,BiFunction remappingFunction); 
Object computeIfAbsent(Object key,Function mappingFunction); 
Object computeIfPresent(Object key,BiFunction remappingFunction); 
void forEach(BiConsumer action); 
Object getOrDefault(Object key,V defaultValue); 
Object merge(Object key,Object value,Bifunction remappingFunction); 
Object putIfAbsent(Object key,Object value); 
Object replace(Object key,Object value); 
boolean replace(K key,V oldValue,V newValue); 
replaceAll(BiFunction function);

public class MapTest2
{
    public static void main(String[] args)
    {
        Map map = new HashMap();
        // 成对放入多个key-value对
        map.put("疯狂Java讲义" , 109);
        map.put("疯狂iOS讲义" , 99);
        map.put("疯狂Ajax讲义" , 79);
        // 尝试替换key为"疯狂XML讲义"的value，由于原Map中没有对应的key，
        // 因此对Map没有改变，不会添加新的key-value对
        map.replace("疯狂XML讲义" , 66);
        System.out.println(map);
        // 使用原value与参数计算出来的结果覆盖原有的value
        map.merge("疯狂iOS讲义" , 10 ,
            (oldVal , param) -> (Integer)oldVal + (Integer)param);
        System.out.println(map); // "疯狂iOS讲义"的value增大了10
        // 当key为"Java"对应的value为null（或不存在时），使用计算的结果作为新value
        map.computeIfAbsent("Java" , (key)->((String)key).length());
        System.out.println(map); // map中添加了 Java=4 这组key-value对
        // 当key为"Java"对应的value存在时，使用计算的结果作为新value
        map.computeIfPresent("Java",
            (key , value) -> (Integer)value * (Integer)value);
        System.out.println(map); // map中 Java=4 变成 Java=16
    }
}

Java 8改进的HashMap和Hashtable实现类

HashMap和Hashtable存在两点典型区别 
  1.Hashtable是一个线程安全的Map实现，但HashMap是线程不安全的实现，所以HashMap比Hashtable的性能高一点。 
  2.Hashtable不允许使用null作为key和value，如果试图把null值放Hashtable中，将会引发NullPointerException异常；但HashMap可以使用null作为key或value。 
  为了成功地在HashMap、Hashtable中存储、获取对象，用作key的对象必须实现hashCode()方法和equals()方法。

LinkedHashMap实现类

LinkedHashMap使用双向链表来维护key-value对的次序。

public class LinkedHashMapTest
{
    public static void main(String[] args)
    {
        LinkedHashMap scores = new LinkedHashMap();
        scores.put("语文" , 80);
        scores.put("英文" , 82);
        scores.put("数学" , 76);
        // 调用forEach方法遍历scores里的所有key-value对
        scores.forEach((key, value) -> System.out.println(key + "-->" + value));
    }
}

TreeMap

  TreeMap就是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点。TreeMap也有两种排序方法。 
   自然排序：TreeMap的所有key必须实现Comparable接口，而且所有的key应该是同一个类的对象，否则将会抛出ClassCastException异常。 
   定制排序：创建TreeMap时，传入一个Comparator对象，该对象负责对TreeMap中的所有key进行排序。采用定制排序时，不要求Map的key实现Comparable接口。 
   如果使用自定义类作为TreeMap的key，则重写该类的equals()方法和comparaTo()方法时应保持一致的返回结果。

class R implements Comparable
{
    int count;
    public R(int count)
    {
        this.count = count;
    }
    public String toString()
    {
        return "R[count:" + count + "]";
    }
    // 根据count来判断两个对象是否相等。
    public boolean equals(Object obj)
    {
        if (this == obj)
            return true;
        if (obj != null && obj.getClass() == R.class)
        {
            R r = (R)obj;
            return r.count == this.count;
        }
        return false;
    }
    // 根据count属性值来判断两个对象的大小。
    public int compareTo(Object obj)
    {
        R r = (R)obj;
        return count > r.count ? 1 :
            count < r.count ? -1 : 0;
    }
}
public class TreeMapTest
{
    public static void main(String[] args)
    {
        TreeMap tm = new TreeMap();
        tm.put(new R(3) , "轻量级Java EE企业应用实战");
        tm.put(new R(-5) , "疯狂Java讲义");
        tm.put(new R(9) , "疯狂Android讲义");
        System.out.println(tm);
        // 返回该TreeMap的第一个Entry对象
        System.out.println(tm.firstEntry());
        // 返回该TreeMap的最后一个key值
        System.out.println(tm.lastKey());
        // 返回该TreeMap的比new R(2)大的最小key值。
        System.out.println(tm.higherKey(new R(2)));
        // 返回该TreeMap的比new R(2)小的最大的key-value对。
        System.out.println(tm.lowerEntry(new R(2)));
        // 返回该TreeMap的子TreeMap
        System.out.println(tm.subMap(new R(-1) , new R(4)));
    }
}

WeakHashMap和IdentityHashMap

WeakHashMap与HashMap的用法基本相似，与HashMap的区别在于，HashMap的key保留了对实际对象的强引用，这意味着只要该HashMap对象不被销毁，该HashMap的所有key所引用的对象就不会被垃圾回收，HashMap也不会自动删除这些key所对应的key-value对；但WeakHashMap的key只保留了对实际对象的弱引用，这意味着如果WeakHashMap对象的key所引用的对象没有被其他强引用变量所引用，则这些key所引用的对象可能被垃圾回收，WeakHashMap也可能自动删除这些key所对应的key-value对。 
   在IdentityHashMap中，当且仅当两个key严格相等(key1==key2)时，IdentityHashMap才认为两个key相等；对于普通的HashMap而言，只要key1和key2通过equals()方法比较返回true，且它们的hashCode值相等即可。