HashMap底层机制及源码剖析
-
HashMap底层维护了Node类型的数组table,默认为null
-
当创建对象时，将加载因子初始化为0.75；
-
当添加key-value时，通过key的哈希值得到在table的索引，然后判断该索引处是否有元素，如果没有元素直接添加，如果该索引处有
元素，继续判断该元素的key是否和准备加入的key相等，如果相等，则直接替换val;如果不相等需要判断是树结构还是链表结构，做出相应处理，如果添加时发现容量不够，则需要扩容 resize()；
-
第一次添加，则需要扩容table容量为16，临界值threshold为12
-
以后再扩容，则需要扩容table容量为原来的2倍，临界值为原来的2倍，即24，依次类推；
-
在Java8中，如果一条链表的元素个数超过TREEIFY_THRESHOLD(默认是8)，并且table的大小>= MIN_TREEIFY_CAPACITY(默认是64)，就会进行树化（红黑树）；
HashMap源码解读
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//如果table的索引位置的key的hash和新的key的hash值相同，并
//满足(table 现有的结点的key和准备添加的key是同一个对象 || equals返回真，就认为不能加入新的k-v)
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果当前的table的已有的Node是红黑树，就按照红黑树的方式来处理
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//如果找到的结点，后面是链表，就循环比较
for (int binCount = 0; ; ++binCount) {//死循环
if ((e = p.next) == null) {//走到最后了，还没找到与之相同的
//加到链表的屁股后面
p.next = newNode(hash, key, value, null);
//判断是不是链表中加满了八个
if (binCount >= TREEIFY_THRESHOLD - 1) //>= (8-1=7)
//树化，当然这里不是立即树化哈，深挖进去，会发现还要满足table的长度>=64
//才会树化，反之不符合条件就选择扩容，不急着树化
treeifyBin(tab, hash);
//我找了一圈，发现没有找到和我一样的，就把我加到屁股后面，然后退出
break;
}
//循环比较的过程中，我发现有一个是相同的，即hash值也相同||值相同，我就退出
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;//替换找到的重复key对应的value
afterNodeAccess(e);
return oldValue;
}
}
++modCount;//每成功增加一个，就++
if (++size > threshold)//12--24--48，一旦发现到了threshold临界值，就进入分支开始扩容
resize();
afterNodeInsertion(evict);
return null;
}
//树化部分的源码
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//如果table暂时为null,或者大小还没有到 64，暂时不树化，而是进行扩容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if (
.......
}
}
HashTable
- 存放的元素是键值对： 即 k-v
- hashtable的键和值都不能为null，否则会抛出空指针异常
- hashTable使用方法基本上和HashMap一样
- hashTable是线程安全的(因为有synchronized修饰)，hashMap是线程不安全的
- 底层源码剖析
//简单说明一下HashTable的底层
/**
1.底层有数组Hashtable$Entry[] 初始化大小为11
2.临界值 threshold 为 8--> 11*0.75；
3.扩容：按照自己的扩容机制来进行
4.By 执行 addEntry(hash, key, value, index);
添加K-V ，将其封装到Entry中去
5.当if (count >= threshold) 满足时，就进行扩容
6.按照int newCapacity = (oldCapacity << 1) + 1; 的大小扩容
*/
public synchronized V put(K key, V value) {
if (value == null) {
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
for(; entry != null ; entry = entry.next) {
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
return old;
}
}
//hashtable的底层是entry数组，通过以下的add方法将key、value放进entry中，然后添加到数组中去
addEntry(hash, key, value, index);
return null;
}
}
//addEntry方法底层
private void addEntry(int hash, K key, V value, int index) {
modCount++;
Entry<?,?> tab[] = table;
//当存放的元素数量大于临界值
if (count >= threshold) {
//进入这个方法
rehash();
tab = table;
hash = key.hashCode();
index = (hash & 0x7FFFFFFF) % tab.length;
}
// Creates the new entry.
@SuppressWarnings("unchecked")
Entry<K,V> e = (Entry<K,V>) tab[index];
tab[index] = new Entry<>(hash, key, value, e);
count++;
}
//rehash()底层源码
@SuppressWarnings("unchecked")
protected void rehash() {
//oldCapacity起初为11嘛
int oldCapacity = table.length;
Entry<?,?>[] oldMap = table;
// 扩容后新的容量=oldCapacity乘以2，再+1；
//这就是起初容量为11，之后扩容后变为11*2+1=23的原因
int newCapacity = (oldCapacity << 1) + 1;
//如果新容量-数组最大值2147483639仍然大于0，则进入分支
if (newCapacity - MAX_ARRAY_SIZE > 0) {
if (oldCapacity == MAX_ARRAY_SIZE)
// Keep running with MAX_ARRAY_SIZE buckets
return;
newCapacity = MAX_ARRAY_SIZE;
}
Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
modCount++;
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
table = newMap;
for (int i = oldCapacity ; i-- > 0 ;) {
for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
Entry<K,V> e = old;
old = old.next;
int index = (e.hash & 0x7FFFFFFF) % newCapacity;
e.next = (Entry<K,V>)newMap[index];
newMap[index] = e;
}
}
}
HashMap和HashTable之间的对比
| 线程安全（同步） | 效率 | 允许null键 null值 | |
|---|---|---|---|
| HashMap | 不安全 | 高 | 可以 |
| HashTable | 安全 | 较低 | 不可以 |
Properities
- Properities类继承自HashTable类并且实现了Map接口，也是使用了一种键值对的形式来保存数据
- 它的使用特点和HashTable类似
- Properities还可以用于从xxx.properities文件中，加载数据到Properties类对象，并进行读取和修改
- 说明：工作后，xxxx.properities文件通常作为配置文件，这个知识点在IO流举例；
TreeSet
- 自动排序，TreeSet中的元素会自动按照自然顺序，例如数字从小到大，字母按照字典顺序，或者通过自定义的比较器排列；
- 不允许重复元素，TreeSet会检查插入的元素是否已经存在，如果存在相同的元素，新的元素将不会被添加
public static void main(String[] args) {
TreeSet treeSet = new TreeSet();
//1.当我们使用无参构造器，创建TreeSet时，仍然是无序的
treeSet.add("jason");
treeSet.add("R");
treeSet.add("K");
treeSet.add("AAA");
System.out.println(treeSet);
//[AAA, K, R, jason]
//2.我希望添加的元素，可以按照字符串大小来排序
//3.我们可以使用TreeSet提供的一个构造器，可以传入一个比较器(匿名内部类)
// 并指定排序规则
TreeSet treeSetNB = new TreeSet(new Comparator() {
//源码解读，当传给TreeSet一个比较器时，深挖底层，我们会发现其将传入的比较器对象 赋给了TreeSet底层的
//TreeMap的属性this.comparator,也就是将匿名对象，传给了底层TreeMap的comparator属性
/**
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}*/
//在调用treeSet.add("AAA")时，在底层会执行到
/**
//此中的cpr就是我们的匿名内部类(对象)
Comparator<? super K> cpr = comparator;
if (cpr != null) {
do {
parent = t;
//动态绑定到我们的匿名内部类（对象） compare
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
//如果相等，即返回0，那么这个key就没有加入
else
return t.setValue(value);
} while (t != null);
}
*/
@Override
public int compare(Object o1, Object o2) {
//这里的这句话调用字符串的compareTo方法，默认按照字符串来比较大小
//这里实现从大到小的比较规则
return ((String)o2).compareTo((String)o1);
}
});
treeSetNB.add("jason");
treeSetNB.add("K");
treeSetNB.add("R");
treeSetNB.add("AAA");
System.out.println("添加了比较器后的treeSet："+treeSetNB);
}
TreeMap
-
键的排序：TreeMap按照键的自然顺序，例如数字从小到大，字母按字典顺序，或者根据提供的Comparator 进行排序；
因此，插入元素时会自动排序，而不是按照插入的顺序存储；
-
不允许null键：TreeMap不允许null作为键，这与HashMap允许一个nulll键不同，但是TreeMap允许null值，可以有多个null值；
public static void main(String[] args) {
TreeMap treeMap = new TreeMap();
treeMap.put("1",null);
treeMap.put("2",null);
System.out.println(treeMap);
//{1=null, 2=null}
}
Collection工具类
- Collection是一个操作Set、List和Map等集合的工具类
- Collection中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作
- 排序操作
- reverse(List)：反转List中元素的顺序
- shuffle(List)：对List集合元素进行随机排序
- sort(List)：根据元素的自然顺序对指定List集合元素按升序排序
- sort(List，Comparator)：根据指定的Comparator 产生的顺序对List 集合元素进行排序
- swap(List，int，int)：将指定List集合中的 i 处元素和 j 处元素进行交换
public static void main(String[] args) {
//创建ArrayList 集合，用于测试。
ArrayList list = new ArrayList();
list.add("kerwin");
list.add("h活在当下hhh");
list.add("AA感受每一段旅程");
list.add("moment");
System.out.println(list);
//[kerwin, h活在当下hhh, AA感受每一段旅程, moment]
//reverse 反转
Collections.reverse(list);
System.out.println(list);
//[moment, AA感受每一段旅程, h活在当下hhh, kerwin]
//shuffle 随机排序
Collections.shuffle(list);
System.out.println(list);
//[h活在当下hhh, AA感受每一段旅程, kerwin, moment]
//sort 根据元素的自然顺序对指定的List集合元素按升序排序
Collections.sort(list);
System.out.println(list);
//[AA感受每一段旅程, h活在当下hhh, kerwin, moment]
//sort(list , Comparator) 传入比较器进行排序
Collections.sort(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
String str1 = (String)o1;
String str2 = (String)o2;
return str2.compareToIgnoreCase(str1);
}
});
System.out.println(list);
//[moment, kerwin, h活在当下hhh, AA感受每一段旅程]
//swap 将指定List集合中的i 处元素和 j 处元素进行交换；
Collections.swap(list,0,1);b ` 1N2QWA
System.out.println(list);
//[kerwin, moment, h活在当下hhh, AA感受每一段旅程]
}
- 查找、替换
- Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
- Object max(Collection ，Comparator)：根据Comparator指定的顺序返回给定集合中的最大元素
- Object min(Collection)
- Object max(Collection，Comparator)
- int frequency(Collection ，Object)：返回指定集合中指定元素的出现次数
- void copy(List dest, List src)：将src 中的内容复制到dest中
- boolean replaceAll(List list ，Object oldVal，Object newVal)：使用新值替换List对象的所有旧值
public static void main(String[] args) {
//创建ArrayList 集合，用于测试。
ArrayList list = new ArrayList();
list.add("kerwin");
list.add("hhhh");
list.add("AAjourney");
list.add("moment");
System.out.println(list);
//[kerwin, hhhh, AAjourney, moment]
//Object max(Collection); 返回给定集合中的最大元素
System.out.println("自然顺序下的最大元素");
System.out.println(Collections.max(list));
//moment
//自定义比较器，然后返回自定义规则下的最大元素
//比如，我要返回长度最大的元素
Object maxObject = Collections.max(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
String str1 = (String)o1;
String str2 = (String)o2;
return str1.length()-str2.length();
/**
* return ((String)o1).length()-((String)o2).length();
*/
}
});
System.out.println("自定义比较器下的最长元素");
System.out.println(maxObject);
//AAjourney
//min(Collection)
System.out.println("自然顺序下的最小元素：");
System.out.println(Collections.min(list));
//AAjourney
//同样，实现自定义比较器，然后返回长度最小的元素
Object minObject = Collections.min(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
/**
* 这里想补充一点容易犯错的点：你要像下面这样写的时候，务必要留意括号的位置，
* ((String)o1) 这个对应的才是String,才会有length()API可以调用
* 如果不留意这一点，就会频频报错hhh
*
*/
return ((String) o1).length() - ((String) o2).length();
}
});
System.out.println("自定义比较器下的最短元素");
System.out.println(minObject);
//hhhh
// int frequency(Collection Object) 返回指定集合中指定元素出现的次数
list.add("hhhh");
System.out.println(list);
//[kerwin, hhhh, AAjourney, moment, hhhh]
int hhhhFre = Collections.frequency(list, "hhhh");
System.out.println(hhhhFre);
//2 即"hhhh"这个对象在集合中出现了2次
//void copy(List dest,List src)
ArrayList testList = new ArrayList();
testList.add("Bingo");
testList.add("Bingo");
//将testList集合中的元素，复制到list中去
Collections.copy(list,testList);
System.out.println(testList);
//[Bingo, Bingo]
System.out.println(list);
//[Bingo, Bingo, AAjourney, moment, hhhh]
//boolean replaceAll(List list, Object oldVal, Object newVal)
Collections.replaceAll(list,"hhhh","hhhhhDamn");
System.out.println(list);
//[Bingo, Bingo, AAjourney, moment, hhhhhDamn]
}
拓展：比较器专题练习
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add("cherry");
list.add("kiwi");
//1.按照字符串的长度来 进行从短到长排序
Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length()-o2.length();
}
});
System.out.println("按照字符串长度，由短到长排序如下：");
System.out.println(list);
//[kiwi, apple, banana, cherry]
//2.按照字符串的最后一个字符从大到小排序
Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
/**
* 这样也行！！！
* char lastChar1 = o1.charAt(o1.length() - 1);
char lastChar2 = o2.charAt(o2.length() - 1);
return Character.compare(lastChar2, lastChar1); // 从大到小排序
*/
return o2.charAt(o2.length()-1)-o1.charAt(o1.length()-1);
}
});
System.out.println("按照字符串的最后一个字符从大到小排序：");
for(String obj : list){
System.out.print(obj+"\t");
}
//cherry kiwi apple banana
//3.按字符串中的元音字母数量从多到少排序
Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return countVowels(o2) - countVowels(o1); // 从多到少排序
}
private int countVowels(String str) {
int count = 0;
for (char c : str.toLowerCase().toCharArray()) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
count++;
}
}
return count;
}
});
System.out.println();
System.out.println("按字符串中的元音字母数量从多到少排序,如下:");
System.out.println(list);
//[banana, kiwi, apple, cherry]
//4.按字符串字母逆序排序
Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.toCharArray()[0]-o1.toCharArray()[0];
}
});
System.out.println("按字符串字母逆序排序");
System.out.println(list);
//[kiwi, cherry, banana, apple]
//5.按字符串是否以元音字母开头排序
Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
boolean startsWithVowel1 = startsWithVowel(o1);
boolean startsWithVowel2 = startsWithVowel(o2);
if (startsWithVowel1 && !startsWithVowel2) {
return -1;
} else if (!startsWithVowel1 && startsWithVowel2) {
return 1;
} else {
return o1.compareTo(o2); // 如果开头情况相同，则按字母顺序排序
}
}
private boolean startsWithVowel(String str) {
char firstChar = Character.toLowerCase(str.charAt(0));
return firstChar == 'a' || firstChar == 'e' || firstChar == 'i' || firstChar == 'o' || firstChar == 'u';
}
});
System.out.println("按字符串是否以元音字母开头排序");
System.out.println(list);
//[apple, banana, cherry, kiwi]
}
//输出结果如下：
按照字符串长度，由短到长排序如下：
[kiwi, apple, banana, cherry]
按照字符串的最后一个字符从大到小排序：
cherry kiwi apple banana
按字符串中的元音字母数量从多到少排序,如下:
[banana, kiwi, apple, cherry]
按字符串字母逆序排序
[kiwi, cherry, banana, apple]
按字符串是否以元音字母开头排序
[apple, banana, cherry, kiwi]
集合总结
开发中如何选择集合实现类
- 先判断存储的类型（一组对象或一组键值对）
- 一组对象(单列数据)：Collection接口
- 允许重复：List
- 增删多：LinkedList[底层维护了一个双向链表]
- 改查多：ArrayList[底层维护了Object 类型的可变数组]
- 不允许重复：Set
- 无序：HashSet [底层是HashMap,维护了一个哈希表，即数组+链表+红黑树]
- 排序：TreeSet
- 插入和取出顺序一致：LinkedHashSet 维护数组+ 双向链表
- 允许重复：List
- 一组键值对（双列）：Map
- 键无序：HashMap [ 底层是：哈希表 jdk7:数组+链表 jdk8:数组+链表+红黑树 ]
- 键排序：TreeMap
- 键插入和取出顺序一致：LinkedHashMap
- 读取文件：Properties
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
