Map相关的基础知识

HashMap

原理图

主要源码解析

基于1.6

public V put(K key, V value) {
  if (key == null)
    return putForNullKey(value);
  int hash = hash(key.hashCode());
  int i = indexFor(hash, table.length);
  for (Entry<K,V> e = table[i]; e != null; e = e.next) {
    Object k;
    if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
      V oldValue = e.value;
      e.value = value;
      e.recordAccess(this);
      return oldValue;
    }
  }

  modCount++;
  addEntry(hash, key, value, i);
  return null;
}

void addEntry(int hash, K key, V value, int bucketIndex) {
  Entry<K,V> e = table[bucketIndex];
  table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
  if (size++ >= threshold)
    resize(2 * table.length);
}

void resize(int newCapacity) {
  Entry[] oldTable = table;
  int oldCapacity = oldTable.length;
  if (oldCapacity == MAXIMUM_CAPACITY) {
    threshold = Integer.MAX_VALUE;
    return;
  }

  Entry[] newTable = new Entry[newCapacity];
  transfer(newTable);
  table = newTable;
  threshold = (int)(newCapacity * loadFactor);
}

void transfer(Entry[] newTable) {
  Entry[] src = table;
  int newCapacity = newTable.length;
  for (int j = 0; j < src.length; j++) {
    Entry<K,V> e = src[j];
    if (e != null) {
      src[j] = null;
      do {
        Entry<K,V> next = e.next;
        int i = indexFor(e.hash, newCapacity);
        e.next = newTable[i];
        newTable[i] = e;
        e = next;
      } while (e != null);
    }
  }
}

基于1.7

public V get(Object key) {
  if (key == null)
    return getForNullKey();
  Entry<K,V> entry = getEntry(key);

  return null == entry ? null : entry.getValue();
}

final Entry<K,V> getEntry(Object key) {
  if (size == 0) {
    return null;
  }

  int hash = (key == null) ? 0 : hash(key);
  for (Entry<K,V> e = table[indexFor(hash, table.length)];
       e != null;
       e = e.next) {
    Object k;
    if (e.hash == hash &&
        ((k = e.key) == key || (key != null && key.equals(k))))
      return e;
  }
  return null;
}

ConcurrentHashMap

原理图

LinkedHashMap

概念

LinkedHashMap通过维护一个运行于所有条目的双向链表，LinkedHashMap保证了元素迭代的顺序。

原理图

初始化

添加元素后

源码解析

基于1.7

// put（添加：只有重写部分）
void createEntry(int hash, K key, V value, int bucketIndex) {
  HashMap.Entry<K,V> old = table[bucketIndex];
  // e就是新创建了Entry，会加入到table[bucketIndex]的表头
  Entry<K,V> e = new Entry<>(hash, key, value, old);
  table[bucketIndex] = e;
  // 把新创建的Entry，加入到双向链表中
  e.addBefore(header);
  size++;
}

private void addBefore(Entry<K,V> existingEntry) {
  after  = existingEntry;
  before = existingEntry.before;
  before.after = this;
  after.before = this;
}

// transfer（扩容：只有重写部分）
void transfer(HashMap.Entry[] newTable, boolean rehash) {
  int newCapacity = newTable.length;
  for (Entry<K,V> e = header.after; e != header; e = e.after) {
    if (rehash)
      e.hash = (e.key == null) ? 0 : hash(e.key);
    int index = indexFor(e.hash, newCapacity);
    e.next = newTable[index];
    newTable[index] = e;
  }
}

TreeMap

概念

TreeMap 默认排序规则：按照key的字典顺序来排序（升序）
当然，也可以自定义排序规则：要实现Comparator接口。

示例代码

public class SortDemo {

  public static void main(String[] args) {
    System.out.println("---------------- 默认 排序结果-----------------");
    createDefaultSortTreeMap();
    System.out.println("---------------- 自定义 排序结果-----------------");
    createDefinitionSortTreeMap();
  }

  public static void createDefaultSortTreeMap() {
    TreeMap<String, String> map = new TreeMap<String, String>();

    init(map);
    print(map);
  }

  public static void createDefinitionSortTreeMap() {

    TreeMap<String, String> map = new TreeMap<String, String>(new Comparator<String>() {

      @Override
      public int compare(String o1, String o2) {
        return o2.compareTo(o1);
      }

    });

    init(map);
    print(map);
  }

  public static void init(Map<String, String> map) {
    map.put("c", "1");
    map.put("a", "1");
    map.put("bb", "1");
    map.put("b", "1");
  }

  public static void print(Map<String, String> map) {
    Iterator<Entry<String, String>> it = map.entrySet().iterator();
    while(it.hasNext()) {
      Entry<String, String> entry = it.next();
      System.out.println(entry.getKey() + " : " + entry.getValue());
    }
  }
}

结果：
---------------- 默认 排序结果-----------------
a : 1
b : 1
bb : 1
c : 1
---------------- 自定义 排序结果-----------------
c : 1
bb : 1
b : 1
a : 1

Map遍历方式

示例

Map<String, String> hashMap = new HashMap<String, String>();
hashMap.put("name1", "josan1");
hashMap.put("name2", "josan2");
hashMap.put("name3", "josan3");
Set<Entry<String, String>> set = hashMap.entrySet();
Iterator<Entry<String, String>> iterator = set.iterator();
while(iterator.hasNext()) {
  Entry entry = iterator.next();
  String key = (String) entry.getKey();
  String value = (String) entry.getValue();
  System.out.println("key:" + key + ",value:" + value);
}