Map（实现类+API）

---

一、介绍

• java.util.Map，哈希表，也称散列表
• Map集合存储元素是成对出现的
• Map集合的键是唯一的，每个键最多只能映射到一个值，不同键映射的值是可重复的

二、实现类

1、HashMap

• extends AbstractMap
• 无序
• 线程不安全
• key和value都可以存null
• 底层
  • jdk7及以前：数组+链表
  • jdk8：数组+链表+红黑树

2、LinkedHashMap

• extends HashMap implements Map
• 有序，底层是哈希表+链表
• 线程不安全

3、TreeMap

• extends AbstractMap
• 有序，根据key排序
  • 基本类型、包装类、String：自然排序，从小到大
  • 自定义对象类型：指定排序规则
• 线程不安全
• 要根据key排序，所以key不能存null，value可以存null
• 基于红黑树实现

4、HashTable

• 线程安全
  • 使用synchronize对整个方法进行加锁，性能比较低，不再推荐使用
• key、value都不能存null

5、ConcurrentHashMap

• extends AbstractMap
• 线程安全
  • 它不是使用synchronize对整个方法加锁，而是利用segment段落锁来对其进行加锁，推荐使用

三、API

1、Map

1、添加

Object put(K k,V v);
//如果是新的一个key，则返回的是null
//如果已经存在一个相同的key,返回前一个key对应的value,新value覆盖旧value
//若value是包装类类型时，接收put方法返回值时要使用包装类类型而不要用基本类型，避免因为自动拆箱导致空指针出现

void putAll(Map<?,?> m);
//深拷贝，会创建一个新的Map，该Map的值改变不会影响原来的m

V putIfAbsent(K key, V value)
//该key不存在 或者 该key对应的value=null，才会put进去
//如果是新的一个key，则返回的是null
//如果已经存在一个相同的key,返回前一个key对应的value,新value不覆盖旧value

2、获取

V get(Object key);
//根据给定的key获取对应的value，若给定的key不存在，则返回值为null
//如果存入的是Integr类型，取出的时候只能强转成Integer

V getOrDefault(Object key, V defaultValue);
//若给定的key不存在，则返回给定默认值defaultValue

3、删除

V remove(Object key)
//返回删除的value，若key不存在则返回null

boolean remove(Object key, Object value)
//若key 或者 value不存在则返回false

4、是否为空

boolean isEmpty();

5、大小

int size();

6、否包含指定的key、value

boolean  map.containsKey(Object key);
boolean  map.containsValue(Object value);

7、清空

map.clear();

2、HashMap

1、初始化

//指定初始容量、加载因子
new HashMap(int initialCapacity, float loadFactor) {

//初始容量
public HashMap(int initialCapacity);

//放入1个Map
public HashMap(Map m);

//初始化
Map<K,V> Collections.singletonMap(K key, V value);

Map<String,String> map=new HashMap<String,String>(){{
        put("紧急", "紧急");
        put("高危险", "高危");
}};

3、LinkedHashMap

4、TreeMap

1、构造方法

//1、无参构造，默认比较器=null
public TreeMap();

//2、指定比较器
public TreeMap(Comparator<? super K> comparator);

//3、放入一个Map，默认比较器=null
public TreeMap(Map<? extends K, ? extends V> m);

2、自动排序

//根据key自然排序，从小到大
TreeMap<Integer,Integer> tm1=new TreeMap<>();
tm1.put(1,11);
tm1.put(3,33);
tm1.put(2,22);
System.err.println(tm1.toString());//{1=11, 2=22, 3=33}

TreeMap<String,Integer> tm2=new TreeMap<>();
tm2.put("100",1);
tm2.put("12",3);
tm2.put("110",2);
System.err.println(tm2.toString());//{100=1, 110=2, 12=3}

//指定key的比较规则
TreeMap<Integer,Integer> tm3=new TreeMap<>((o1,o2)->o2-o1);
tm3.put(1,11);
tm3.put(3,33);
tm3.put(2,22);
System.err.println(tm3.toString());//{3=33, 2=22, 1=11}

3、get

//第一个key
K firstKey();

//第一个Entry
Map.Entry<K,V> firstEntry();

//最后一个key
K lastKey();

//最后一个Entry
Map.Entry<K,V> lastEntry();

4、删除并返回

//第一个
Map.Entry<K,V> pollFirstEntry();

//最后一个
Map.Entry<K,V> pollLastEntry();

四、遍历

• 由key不重复和value可重复也可知它应当该返回什么集合

1、遍历key

Set<K> map.keySet();

2、遍历value

Collection<V> map.values();

3、遍历键值对

//1、Entry：en.getKey、en.getValue、en.setValue()
Set<Map.Entry<K, V>> map.entrySet()
//Entry每一个实例用于表示当前Map的一组键值对

//2、迭代器
Iterator<Entry<String,String>> it=map1.entrySet().iterator();
Entry<String,String> en=it.next();
//此遍历可以通过迭代器删除元素

//3、forEach
map.forEach((k,v)->{
})