1. List集合
1.1 ArrayList
-
ArrayListr中维护了一个Object类型的数组elementData.
transient Object[]elementData; -
当创建ArrayListy对象时，如果使用的是无参构造器，则初始elementData容量为0，第1次添加，则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5倍。
-
如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData为1.5倍。
1.2 Vector
-
Vector)底层也是一个对象数组，protected Object[]elementData;
-
Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized
public synchronized E get(int index) { if (index >= elementCount) throw new ArrayIndexOutOfBoundsException(index); return elementData(index); } -
在开发中，需要线程同步安全时，考虑使用Vector
| 底层结构 | 版本 | 线程安全、效率 | 扩容倍数 | |
|---|---|---|---|---|
| ArrayList | 可变数组 | jdk1.2 | 不安全、效率高 | 有参构造 1.5倍 无参构造 1.第一次大小为10 2.从第二次开始1.5 倍 |
| Vector | 可变数组 | jdk1.0 | 安全、效率不高 | 无参构造 默认10,满后，就按2倍扩容 有参构造 满后，2倍扩容 |
1.3 LinkedList
- LinkedList底层实现了双向链表和双端队列特点
- 可以添加任意元素（元素可以重复），包括null
- 线程不安全，没有实现同步
2. Set集合
- 无序（添加和取出的顺序不一致），没有索引
- 不允许重复元素，所以最多包含一个null
2. 1 HashSet
2.1.1 HashSet底层机制说明
-
HashSet底层是HashMap
-
添加一个元素时，先得到hash值会转成->索引值
-
找到存储数据表table,看这个索引位置是否已经存放的有元素
-
如果没有，直接加入
-
如果有，调用equals比较，如果相同，就放弃添加，如果不相同，则添加到链表最后
-
在Java8中，如果一条链表的元素个数>=TREEIFY_THRESHOLD(默认是8)，并且table的大小>=
MIN_TREEIFY_CAPACITY(默认64)，就会进行树化（红黑树）
- 测试代码
public static void main(String[] args) {
HashSet hashSet = new HashSet();
hashSet.add("java");
hashSet.add("php");
hashSet.add("java");
System.out.println(hashSet);
}
- 源码分析：
- 执行HashSet()
public HashSet() {
map = new HashMap<>();
}
- 执行add(“java”)方法
public boolean add(E e) { // e = "java"
return map.put(e, PRESENT)==null; // PRESENT is private static final Object PRESENT = new Object(); key是变的，但是value是不会变的
}
- 执行put()方法
public V put(K key, V value) { // key = "java" value = PRESENT
return putVal(hash(key), key, value, false, true);
}
- 执行hash()方法,确定表中的位置，得到key对应的hash值，不等同于hashcode()
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); // null值返回值为0，所以null值会在第一个索引
}
- 执行putVal()方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i; // 辅助变量
// table 就是HashMap的一个属性，类型是 Node<K,V>[]
// if 语句表示如果当前table是null，或者大小 =0
// 就是第一次扩容，到16个空间
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length; // resize() 下面解读，初始化了table
// (1)根据key得到的hash 去计算该key应该存放到table表的哪个索引位置
// 并把这个位置的对象，赋值给p
// (2)判断p是否为null
// (2.1) 如果p为null。表示还没有存放元素，就创建一个Node(key="java",value=PRESENT)
// (2.2) 就放在该位置
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
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) // -1 for 1st
treeifyBin(tab, hash);
break;
}
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;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold) // 内存预警
resize();
afterNodeInsertion(evict);
return null; // 返回空，代表成功
}
resize()
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY; // 默认大小16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 临界值，到了这个值就进行扩容，使操作量较大时会有一个缓冲
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; // 初始化了新数组，并返回
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
- 执行add(“php”)方法
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) // false
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null) // 计算索引为9，i=9,直接添加 其实索引的计算就是 h = hashcode % (table.length-1)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
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) // -1 for 1st
treeifyBin(tab, hash);
break;
}
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;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
- 继续执行add(“java”)方法
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) // false
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null) // i=3 p≠null
tab[i] = newNode(hash, key, value, null);
else { // 进入
Node<K,V> e; K k; // 辅助变量
if (p.hash == hash && // p 就是索引处的第一个结点
// 如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样
// 并且满足
// 1.准备加入的key和p指向的Node结点的key是同一个对象
// 2.不是同一个对象但是内容相同
// 就不能加入
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 再判断p是不是一颗红黑树
// 如果是一颗红黑树，就调用putTreeVal，来进行添加
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 如果table对应索引位置，已经是一个链表，就使用for循环比较
// (1)依次和该链表的每一个元素比较后，都不相同，则加入至链表末尾
// 添加末尾后，判断该链表是否已经达到8个结点，达到则使用treeifyBin，对当前链表转为红黑树
// 进入红黑树方法后，如果数组长度小于64，那么对table表进行扩容
// if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
// resize();
// 只有上述条件不成立，才会进行树化
// (1)依次和该链表的每一个元素比较后，有相同，就直接break，放弃添加
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
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;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
- 分析HashSet的扩容和转成红黑树机制
- HashSet底层是HashMap,第一次添加时，table数组扩容到16，临界值(threshold)是16加载因子
(loadFactor)是0.75 =12 - 如果table数组使用到了临界值12，就会扩容到16 * 2=32，新的临界值就是32*0.75=24,依次类推
- 在Java8中，如果一条链表的元素个数到达TREEIFY THRESHOLD(默认是8)，并且table的大小>=
MIN_TREEIFY_CAPACITY(默认64)，就会进行树化（红黑树），否则仍然采用数组扩容机制
2.2 LinkedHashSet
- LinkedHashSet是HashSet的子类
- LinkedHashSet底层是一个LinkedHashMap,底层维护了一个数组+双向链表
- LinkedHashSet根据元素的hash值来决定元素的存储位置，同时使用链表维护元素的次序（图），这使得元素看起来是以插入顺序保存的。
- LinkedHashSet不允许添重复元素
说明
-
在LinkedHastSet中维护了一个hash表和双向链表
(LinkedHashSet有head和tail) -
每一个节点有before和after属性，这样可以形成双向链表
-
在添加一个元素时，先求hash值，在求索引，确定该元素tablel的位置，然后将添加的元素加入到双向链表（如果已经存在，不添加[原则和hashset一样])
tail.next=newElement //示意代码
newElement.pre = tail
tail = newEelment;
-
这样的话，我们遍历LinkedHashSet也能确保插入顺序和遍历顺序一致
public class LinkedHashSetSource { public static void main(String[] args) { LinkedHashSet set = new LinkedHashSet(); set.add(new String("AA")); set.add(456); set.add(456); set.add(new Customer("刘", 1001)); set.add(123); set.add("lsp"); System.out.println(set); } } class Customer { private String name; private Integer no; public Customer(String name, Integer no) { this.name = name; this.no = no; } @Override public String toString() { return "Customer{" + "name='" + name + '\'' + ", no=" + no + '}'; } }输出：
[AA, 456, Customer{name=‘刘’, no=1001}, 123, lsp]
结论
- LinkedHashSet加入顺序和取出元素/数据的顺序一致
- LinkedHashSet底层维护的是一个LinkedHashMap（是HashMap的子类）
- LinkedHashSet底层结构 （数组+双向链表）
- 添加第一次时，直接将数组扩容到16，加载因子为0.75，存放的结点类型是LinkedHashMap$Entry
- 数组是HashMap N o d e [ ] 存 放 的 元 素 / 数 据 是 L i n k e d H a s h M a p Node[]存放的元素/数据是LinkedHashMap Node[]存放的元素/数据是LinkedHashMapEntry类型
static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after;
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
2.2 TreeSet
- 当我们使用无参构造器时，创建TreeSet时，仍然是无序的
TreeSet treeSet = new TreeSet();
treeSet.add("jack");
treeSet.add("tom");
treeSet.add("sp");
treeSet.add("a");
System.out.println(treeSet);
输出：[a, jack, sp, tom]
- 如果希望添加的元素，按照首字母的大小来排序
TreeSet treeSet = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
// 首字母从大到小排序
return ((String)o2).compareTo(((String)o1));
}
});
treeSet.add("jack");
treeSet.add("tom");
treeSet.add("sp");
treeSet.add("a");
System.out.println(treeSet);
输出：[tom, sp, jack, a]
- 构造器把传入的比较器对象，赋给了TreeSet的底层的TreeMap的属性this.comparator
3. Map集合
-
Map接口实现类的特点[很实用]
注意：这里讲的是JDK8的Map接口特点Map .java
- Map与Collection:并列存在。用于保存具有映射关系的数据：Key-Value
- Map中的key和value可以是任何l引用类型的数据，会封装到HashMap:$Node对象中
- Map中的key不允许重复，原因和HashSet一样，前面分析过源码，当出现一样的key，那么直接覆盖
- Map中的value可以重复
- Map的key可以为null,value也可以为null,注意key为null,只能有1个，value为null,可以多个.
- 常用String类作为Map的key
- key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value
- Map存放数据的key-value示意图，一对k-v是放在一个Node中的，又因为Node实现了Entry接口，有些书上也说一对k-v就是一个Entry(如图)[代码演示]
解读：
-
K-V 最后是
HashMap$Node node = newNode(hash, key, value, null); -
K-V为了方便程序员的遍历，还会创建EntrySet集合，该集合存放的元素的类型Entry，而一个Entry对象就有k,v EntrySet<Entry<K,V>>
-
entrySet中，定义的类型是Map.Entry,但是实际上存放的还是HashMap$Node，是HashMap中的值得引用
这是因为static class Node<K,V>implements Map,Entry<K,V>
public class MapSource_ {
public static void main(String[] args) {
HashMap map = new HashMap();
map.put("no1","lsp");
map.put("no2","zs");
System.out.println(map);
Set set = map.entrySet();
for (Object o : set) {
System.out.println(o.getClass());
}
}
}
输出：
{no2=zs, no1=lsp}
class java.util.HashMap$Node
class java.util.HashMap$Node
- 当把HashMap$Node对象存放到entrySet就方便我们的遍历
K getKey();和V getValue();
for (Object obj : set) {
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + "-" + entry.getValue());
}
Set set1 = map.keySet();
Collection values = map.values();
System.out.println(set1.getClass());
System.out.println(values.getClass());
输出：
class java.util.HashMap$KeySet
class java.util.HashMap$Values
- HashMap.小结
- Map接口的常用实现类：HashMap、Hashtable和Properties。
- HashMap是Map接口使用频率最高的实现类。
- HashMap是以key-val对的方式来存储数据[案例Entry]
- key不能重复，但是是值可以重复，允许使用null键（至多一个）和null（无数个）值。
- 如果添动加相同的key,则会覆盖原来的key-val,等同于修改.(key不会替换，val会替换)
- 与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的.
- HashMap没有实现同步，因此是线程不安全的
3.1 HasMap底层机制及源码剖析
- (k,v)是一个Node实现了Map.Entry<K,V>,查看HashMap的源码可以看到
- jdk7.0的hashmap底层实现[数组+链表]，jdk8.0底层[数组+链表+红黑树]
- 扩容机制【和HashSet相同】
- HashMap底层维护了Node类型的数组table,默认为null
- 当创建对象时，将加载因子(loadfactor)初始化为0.75.
- 当添加key-val时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素，如果没有元素直接添加。如果该索引处有元素，继续判断该元素的key是否和准备加入的key相等，如果相等，则直接替换val,如果不相等需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容。
- 第1次添加，则需要扩容table容量为16，临界值(threshold)为12.
- 以后再扩容，则需要扩容table容量为原来的2倍，临界值为原来的2倍，即24，依次类推.
- 在Java8中，如果一条链表的元素个数超过TREEIFY_THRESHOLD(默认是8)，并且tablel的大小>=MIN_TREEIFY_ CAPACITY(默认64)，就会进行树化（红黑树）
3.2 HashTable
- 基本介绍
- 存放的元素是键值对：即K-V
- hashtablel的键和值都不能为null,否则会抛出NullPointerException
- hashTable使用方法基本上和HashMap一样
- hashTable是线程安全的，hashMap是线程不安全的
- 简单看下底层结构
- 底层有数组Hashtable$Entry[]初始化大小为11
- 临界值threshold 8 = 11 * 0.75
- 扩容：按照自己的扩容机制来进行即可
- 执行方法
addEntry(hash,key,valve,index);添加K-V封装到Entry - 当if(count>=threshold)满足时，就进行扩容
- 按照
int newCapacity=(oldCapacity<<1)+1的大小扩容.
Hashtable和HashMap对比
| 版本 | 线程安全（同步） | 效率 | 允许null键null值 | |
|---|---|---|---|---|
| HashMap | 1.2 | 不安全 | 高效 | 可以 |
| Hashtable | 1.0 | 安全 | 较低 | 不可以 |
3.3 Properties
- Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形式来保存数据。
- 他的使用特点和Hashtable类似
- Properties 还可以用于从xx.properties文件中，加载数据到Properties类对象，并进行读取和修改
总结
-
先判断存储的类型（一组对象[单列]或一组键值对[双列]）
-
一组对象：Collection接口
允许重复：List 增删多：LinkedList[底层维护了一个双向链表]
改查多：ArrayList[底层维护Object类型的可变数组]
不允许重复：Set 无序：HashSet[底层是HashMap,维护了一个哈希表即（数组+链表+红黑树）]
排序：TreeSet 插入和取出顺序一致：LinkedHashSet,维护数组+双向链表3)
-
一组键值对：Map
键无序：HashMap[底层是：哈希表jdk7:数组+链表，jdk8:数组+链表+红黑树]
键排序：TreeMap 键插入和取出顺序一致：LinkedHashMap
读取文件Properties
-
扫一扫
5778
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
