集合架构图
List集合特点
Vecter：线程安全，
ArrayList:线程不安全，底层实现数组，有索引，查询快，修改快。
LinkedList:线程不安全，底层实现双向链表，增加和删除快。
·ArrayList源码分析
属性：
/**
* 数组的默认容量
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 默认空数组
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* 默认空数组
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* 数组元素存放位置
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* 数组的大小
*/
private int size;先看看构造方法：
/**
* 给定初始大小实例化对象
* @param initialCapacity
*/
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
/**
* 实例化对象，默认设为空数组
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 给定一个Collection接口对象实例化对象
* @param c Collection接口对象
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}源码分析无参构造和添加方法：
ArrayList list = new ArrayList();
/**
* 看看空参构造方法做了什么?
* public ArrayList() {
* this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
* }
* 只做了一件事，给elementData赋值了一个空数组。
*/
list.add("第一次添加");
/**
* 第一次添加做了什么？
* 1)添加的方法
* public boolean add(E e) {
* // 给对象本身的数组计算容量
* ensureCapacityInternal(size + 1); // Increments modCount!!
* // 给对象本身添加新的元素到数组最后面。
* elementData[size++] = e;
* return true;
* }
* 2）
* private void ensureCapacityInternal(int minCapacity) {
* ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
* }
* 3） 参数：1.对象本身的数组 2.旧数组的大小+1
*
* private static int calculateCapacity(Object[] elementData, int minCapacity) {
* // 如果对象数组 是一个空数组（DEFAULTCAPACITY_EMPTY_ELEMENTDATA），返回一个默认大小10和旧数组的大小+1的对比值的最大值。
* // 如果不是空，返回size+1的大小 。
* if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
* return Math.max(DEFAULT_CAPACITY, minCapacity);
* }
* return minCapacity;
* }
* 4) 参数：新的数组大小 。
* private void ensureExplicitCapacity(int minCapacity) {
* // 数组操作的次数
* modCount++;
*
* // 如果新数组的大小比list本身数组的长度大，就需要扩容
* if (minCapacity - elementData.length > 0)
* grow(minCapacity);
* }
* 5) 参数：新数组大小
* private void grow(int minCapacity) {
* // 暂存旧数组长度
* int oldCapacity = elementData.length;
* // 计算要扩容的新数组容量大小，等于旧数组大小 + 旧数组大小除以2 （>>位移运算符，2进制数向右移一位）
* int newCapacity = oldCapacity + (oldCapacity >> 1);
* // 要扩容的数组容量大小 - 新数组的容量 小于0，要扩容的数组容量等于新数组的容量
* //（第一次添加数据会走这里，因为新数组大小是默认值10，要扩容的数组容量大小是0）。
* if (newCapacity - minCapacity < 0)
* newCapacity = minCapacity;
* // 要扩容的数组容量大小 大于最大数组大小（2147483639）整型-8，给数组最大容量。（一般都用不到吧，这么大的数组还没见过）
* if (newCapacity - MAX_ARRAY_SIZE > 0)
* newCapacity = hugeCapacity(minCapacity);
* // 返回一个新的数组，大小为要扩容的数组容量大小，赋值给对象本身的数组。
* elementData = Arrays.copyOf(elementData, newCapacity);
* }
*
* 6) 给数组最大容量
* private static int hugeCapacity(int minCapacity) {
* if (minCapacity < 0) // overflow
* throw new OutOfMemoryError();
* return (minCapacity > MAX_ARRAY_SIZE) ?
* Integer.MAX_VALUE :
* MAX_ARRAY_SIZE;
* }
* 7） 源码1里面的这行代码在最后执行。
* 给对象本身添加新的元素到数组最后面。
* elementData[size++] = e;
*
*/
图解：
删除源码分析：
// ArrayList的删除方法
public E remove(int index) {
// 检查要删除的元素是否超出数组长度
rangeCheck(index);
// 数组操作次数+1
modCount++;
// 把要删除的元素拿出来
E oldValue = elementData(index);
// 要复制的数组的大小
int numMoved = size - index - 1;
if (numMoved > 0)
// 复制数组，参数：1.源数组 2.源数组的起始位置 3.目标数组 4.目标数组的起始位置 5，要复制的数组个数
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// list大小-1
elementData[--size] = null; // clear to let GC do its work
// 返回删除的元素
return oldValue;
}图解：
查询和修改方法比较简单就不说了。
LinkedList源码分析：
LinkedList的底层是双向链表结构。
public class LinkedList_ {
public static void main(String[] args) {
// 链表实现
Node java = new Node("java");
Node php = new Node("php");
Node py = new Node("py");
java.setNext(php);
php.setNext(py);
php.setPrve(java);
py.setPrve(php);
Node node = java;
while (node != null){
System.out.println(node);
node = node.next;
}
}
static class Node{
private String node;
private Node next;
private Node prve;
@Override
public String toString() {
return "Node{" +
"node='" + node +"'}";
}
public Node(){
}
public Node(String node){
this.node = node;
}
public void setNext(Node next) {
this.next = next;
}
public void setPrve(Node prve) {
this.prve = prve;
}
}
}图解：
添加方法源码分析：
public boolean add(E e) {
// 把新增的元素放到链表的最后面
linkLast(e);
return true;
}
void linkLast(E e) {
// 暂存对象本身的last元素
final LinkedList.Node<E> l = last;
// 实例化新增元素
final LinkedList.Node<E> newNode = new LinkedList.Node<>(l, e, null);
// 新增元素对象放到最后
last = newNode;
// 如果最后的元素为空，就把新增的元素放到第一个，否则对象本身的下一个节点是新增元素。
if (l == null)
first = newNode;
else
l.next = newNode;
// 长度加1
size++;
// 操作次数+1
modCount++;
}修改方法源码分析：
public E set(int index, E element) {
// 检查要修改的索引大小。
checkElementIndex(index);
// 查询要修改的索引位置的元素
LinkedList.Node<E> x = node(index);
// 替换元素
E oldVal = x.item;
x.item = element;
// 返回旧的元素
return oldVal;
}
LinkedList.Node<E> node(int index) {
// assert isElementIndex(index);
// 这里是找到索引位置的元素，如果小于size的一半就从前面找起，否则从后面打起。
if (index < (size >> 1)) {
LinkedList.Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
LinkedList.Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}指定索引位置添加源码分析：
public void add(int index, E element) {
// 检查要添加的索引大小，可以是size+1，因为可以添加到链表的最后
checkPositionIndex(index);
// 如果等于size直接添加到链表的最后
if (index == size)
linkLast(element);
else
// 插入到中间的处理
linkBefore(element, node(index));
}
void linkBefore(E e, LinkedList.Node<E> succ) {
// assert succ != null;
// 链表旧元素的前一个元素
final LinkedList.Node<E> pred = succ.prev;
// 创建新的元素，新元素的前一个元素是旧元素的前一个元素。新元素的后一个元素是旧元素
final LinkedList.Node<E> newNode = new LinkedList.Node<>(pred, e, succ);
// 旧元素的前一个元素为前元素
succ.prev = newNode;
if (pred == null)
first = newNode;
else
// 旧元素的下一个元素是新元素
pred.next = newNode;
size++;
modCount++;
}图解：
Set集合
特点：1.不能有重复元素 2.无序（LinkedList链表有序）3.没有索引
HashSet源码分析
// 底层其实是个HashMap
private transient HashMap<E,Object> map;
// 一个默认的放到HashMap的value填充值
private static final Object PRESENT = new Object();
// 空参构造，其实是实例化一个HashMap对象
public HashSet() {
map = new HashMap<>();
}
// 参数Collection的实现对象的构造方法
public HashSet(Collection<? extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}
// 指定集合初始容量和扩容系数的构造方法
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}
// 指定集合初始容量
public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}
// 指定集合初始容量和扩容系数的构造方法,dummy参数作为一个标识，专门给LinkedHashSet使用。
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}看看实例化一个空参构造方法做了什么：
HashSet set = new HashSet();
public HashSet() {
map = new HashMap<>();
}
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}看看添加方法：
// 添加方法其实是调用的HashMap的put方法，参数是要添加的元素和默认的value值
/* public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
// 计算存储位置，用key的hashCode值与hashCode值无符号位移16位作异或运算
// ^ 对比二进制，相同为0，不同为1
// >>> 二进制无符号位移16位
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// 初始化变量，1.tab用于暂存对象table，2.p记录新元素要存放的位置是不是已经有元素，有就记录
3.n用于暂存table的length 4.i新元素要放在table的位置
HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
// resize() 初始化table的大小或者给table大小加倍。
n = (tab = resize()).length;
// (n - 1) & hash table的索引最大值与新加入的值做与运算，然后看tab里面是不是已经有值。
if ((p = tab[i = (n - 1) & hash]) == null)
// 没有值直接放在运算后的i的位置
tab[i] = newNode(hash, key, value, null);
else {
// e:记录旧元素的，k记录旧元素的key
HashMap.Node<K,V> e; K k;
// 如果旧值与新值的hash一样，并且key值相等或者equals对比相等。就直接覆盖。
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如果p也就是旧值元素的类型是TreeNode
else if (p instanceof HashMap.TreeNode)
e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 其它情况。。。（测试了hash值一样，值不一样走这里 ）
// 查询这个单链表下的最后一个元素，把新元素放到最后一个元素的下一个元素。
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;
}
// 判断单链表里面的每一个元素的hash值还有key是否相同，如果相同直接跳过。不添加该值。
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// 记录单链表的下一个元素，用于在次循环
p = e;
}
}
// 如果对象table的元素里面有跟新添加的值一样，就添加失败返回要添加的值
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 操作次数+1
++modCount;
// 达到扩容零界值，走扩容方法。
if (++size > threshold)
resize();
// 给LinkedHashMap用的方法，什么都没做
afterNodeInsertion(evict);
return null;
}
final Node<K,V>[] resize() {
// 记录对象table
Node<K,V>[] oldTab = table;
// 记录table对象的大小
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 下一个要增加的大小
int oldThr = threshold;
// newCap新table对象的大小，newThr新table扩容临界值
int newCap, newThr = 0;
// 旧table对象的大小大于0
if (oldCap > 0) {
// 旧table对象的大小大于最大值(2的30次方)直接返回旧table对象
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 旧table对象的大小左移一位小于最大值(2的30次方)并且大于初始化值16，计算新table扩容临界值
// newCap = oldCap << 1 新table的大小是旧table大小往左移一位
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
// 初始化新table对象的大小 ，和新对象的下一个要增加的大小
newCap = DEFAULT_INITIAL_CAPACITY;
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);
}
// HashMap的threshold扩容临界值更新
threshold = newThr;
// 扩容后的table对象newTab
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
// 把旧table对象的元素复制到新的table对象
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 单链表的链表元素只有一个，赋值到新table对象的 元素对象与新table对象的大小作与操作的索引位置
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
// 如果元素类型是TreeNode
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;
// 这里有一个算法，(e.hash & oldCap) == 0 就证明不需要换数组的位置，不等于0就换位置（j+16的位置）
// 16的二进制是10000，31的二进制是11111。出现0的情况就是hash值二进制后5位与16比较，只有比16小的才为0也就是从00000到01111.
// 这个时候在31也就是11111里面是不需要换位的。 如果是10000到11111这个时候就需要换位，换到数组16到31索引位置。
// 数组的前部分（0-15）
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 数组后部分（16-31）
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;
}图解：
Map集合
扩容规则
HashMap的初始化数组长度16，当链表长度大于等于8或者数组长度大于等于16*0.75，扩容至数组长度扩容至32。当链表长度大于等于8或者数组长度大于等于32*0.75，数组长度扩容至64。当链表长度大于等于8或者数组长度大于等于64*0.75，转化成红黑树。
扫一扫
523
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
