不同的数据结构，性能不一样
1.数组
增删改查的时候都是根据改变的数组，新建一个数组然后加上变化的，所以很耗时!
2.链表
添加或者删除比较方便
查询效率低
因为存储不连续
删除：
然后那个节点就会被GC
插入：
双向链表：
3.树
整合数组和链表两个优点：
1，查询效率比较高
2，增加删除效率也比较高
查询的时候有点像二分查找
不平衡的二叉树查询效率不高
4.红黑树RBT
二、集合
（List接口）
6.集合初探
很多集合类
6.5. 类与类之间的关系
补充：类图类与类之间的关系
先有个比较基础的认知
（List)
7.图解ArrayList（上）
集合
为什么能一直添加呢？（怎么实现扩容的）
ArrayList本质上就是数组
源码：
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
}
内部属性：
private static final long serialVersionUID = 8683452581122892189L;
/**
* Default initial capacity.
默认数组的长度
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* Shared empty array instance used for empty instances.空数组
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* Shared empty array instance used for default sized empty instances. We
* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
* first element is added.
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer. Any
* empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
* will be expanded to DEFAULT_CAPACITY when the first element is added.
集合中存储数据的数组对象
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* The size of the ArrayList (the number of elements it contains).
* 集合中元素的个数
* @serial
*/
private int size;
modCount见下一章节
初始化源码
1）无参构造：
把default那个赋值给elementData
/**
* Constructs an empty list with an initial capacity of ten.
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
2）有参构造：
add方法源码
1）无参数构造器
第一次添加
假设初始size为0
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
//确定容量的 动态扩容 假设size初始0
ensureCapacityInternal(size + 1); // Increments modCount!!
//将要添加的元素添加到数组中 element[0]=1--->size = 1
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
//cal无参的话返回就是10
//传进来的参数是size+1
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// elementData是{},minCapacity是1
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 无参构造
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;//操作次数
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:数组复制，返回一个新的数组，长度为newCapacity
elementData = Arrays.copyOf(elementData, newCapacity);
}
2）有参数构造器
第二次添加
8.图解ArrayList（下）
第十一次添加
前9次的添加（2~10）都不会触发grow（）了
10>>1: 10的十进制是1010
正数左边补0，负数左边补1
变为0101，为5
动态扩容1.5倍
get方法源码
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
// 下标越界的异常
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
set方法
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
remove方法
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
9.并发场景下的FailFast机制详解
就是上面那个modCount
先举个例子：
添加线程
import java.util.List;
public class ThreadAdd extends Thread{
private List list;
public ThreadAdd(List list) {
this.list = list;
}
@Override
public void run(){
for(int i=0;i<100;i++){
System.out.println("循环次数"+i );
try {
Thread.sleep(5);
list.add(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
遍历线程:
import java.util.Iterator;
import java.util.List;
public class ThreadIterator extends Thread{
private List list;
public ThreadIterator(List list) {
this.list = list;
}
@Override
public void run(){
while(true){
for(Iterator iteratorTmp = list.iterator();iteratorTmp.hasNext();){
iteratorTmp.next();
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
main方法：
import java.util.ArrayList;
import java.util.List;
public class test01 {
private static List list = new ArrayList();
public static void main(String[] args) {
// 对list做遍历
new ThreadIterator(list).start();
// 对list做添加操作
new ThreadAdd(list).start();
}
}
ConcurrentModificationException 并发修改异常
我们点进去看看
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
修改的话，次数+1
这样就能理解上面那个例子了
比如在我读A的时候，这时候加进来一个B，modCount就变成了6，和我itr.next中的5不一样，读取的时候就会抛出异常。
10.LinkedList
LinkedList是通过双向链表去实现的，他的数据结构具有双向链表的优缺点，既然是双向链表，那么他的顺序访问的效率会非常高，随机访问效率比较低，它包含一个非常重要的私有内部静态类：Node
transient int size = 0;
/**
* Pointer to first node.
* Invariant: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
transient Node<E> first;
/**
* Pointer to last node.
* Invariant: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
transient Node<E> last;
Node:
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
现在举个例子：
public static void main(String[] args) {
LinkedList a = new LinkedList();
a.push("a1");
a.push("b1");
a.add(1);
}
push：
public void push(E e) {
addFirst(e);
}
public void addFirst(E e) {
linkFirst(e);
}
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}
图示：
原来的双向链表
添加一个节点
add方法（尾部添加）：
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
get:
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
本质上是分一半，然后遍历列表中的数据
set方法：
public E set(int index, E element) {
checkElementIndex(index);// 检查下标是否合法
Node<E> x = node(index);// 根据下标获取对应的值
E oldVal = x.item;// 记录原来的值
x.item = element;// 赋予新的值
return oldVal;// 返回修改之前的值
}
其实源码实现起来并没有那么复杂！
11.为啥不推荐使用Vector？
和 ArrayList 很类似，都是以动态数组的形式来存储数据
Vector是线程安全的
举例：
public static void main(String[] args) {
Vector a = new Vector();
a.add(1);
}
add:
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
注意synchronized同步关键词
但是，把每个方法都加上synchronized，对性能有很大影响！
所以慢慢就被放弃了。
ArrayList不是同步的，但是也可以让它是同步的
public static void main(String[] args) {
ArrayList list = new ArrayList();
List synList = Collections.synchronizedList(list);
}
实现原理类似于下面：
有同步需求的话Collections可以增加代码的灵活度
（Set接口）
12. HashSet 和 TreeSet
HashSet
HashSet实现Set接口，由哈希表支持，它不保证set的迭代顺序，特别是它不保证该顺序永久不变，允许使用null
public HashSet(){
map = new HashMap();
}
add方法：
public boolean add(E e){
return map.put(e,PRESENT)==null;
}
本质上是将数据保持在HashMap中，key就是我们添加的内容，value就是我们定义的一个Object对象
特点
底层数据结构是哈希表，HashSet的本质是一个“没有重复元素”的集合，他是通过HashMap实现的。HashSet中含有一个HashMap类型的成员变量map
TreeSet
基于TreeMap的NavigableSet实现。使用元素的自然顺序对元素进行排序，或者根据创建set是提供的Comparator进行排序，具体取决于使用的构造方法。
public TreeSet(){
this(new TreeMap<E, Object>());
}
本质是将数据保存在TreeMap中，key是我们添加的内容， value是定义的一个Object对象。和上面HashSet一样。
（Map接口）
Map集合的特点
- 能够存储唯一的列的数据（唯一、不可重复）Set（key）
- 能够存储重复的数据List
- 值的顺序取决于键的顺序
- 键和值都是可以存储null元素的
TreeMap
本质上就是红黑树的实现
static final class Entry<K,V> implements Map.Entry<K,V> {
K key;//key
V value;//value
Entry<K,V> left;//左子节点
Entry<K,V> right;//右子节点
Entry<K,V> parent;//父节点
boolean color = BLACK;//节点颜色（父节点默认黑色）
/**
* Make a new cell with given key, value, and parent, and with
* {@code null} child links, and BLACK color.
*/
Entry(K key, V value, Entry<K,V> parent) {
this.key = key;
this.value = value;
this.parent = parent;
}
}
红黑树插入节点的实现
以put为例子：
public V put(K key, V value) {
// 将root赋值给局部变量 null
Entry<K,V> t = root;
// if里面就是一开始，map为空（没有root结点）put的过程
if (t == null) {
// 初始操作
// 检查key是否为空
compare(key, key); // type (and possibly null) check
// 将key和value封装成一个对象并且赋值给root
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
// 下面是map不为空添加的逻辑
int cmp;
Entry<K,V> parent;// 父节点
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;// 获取比较器
// 如果比较器不为空
if (cpr != null) {
// 注意这里是一个循环，举个例子来说就是一直二分查找，直到找到要插入节点的父节点
// 恰好最后一次循环之后，parent节点就真成了parent节点
//这里的循环只是找到parent节点，并没有插入
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
// else同理，就是比较了一下比较器存不存在
else {
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
// 找到父节点之后进行最后一次二分比较
// 封装起来
Entry<K,V> e = new Entry<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
// 这个函数就是调整插入值之后的红黑树的平衡用的
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
如果上面红黑树理解的比较好，下面的函数理解就很简单
private void fixAfterInsertion(Entry<K,V> x) {
// 设置添加的颜色为红色
x.color = RED;
// 循环的条件 添加的节点不为空、不是root节点、父节点的颜色为红色
while (x != null && x != root && x.parent.color == RED) {
// 父节点是否是 祖父节点的左侧节点
if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
// 获取父节点的 兄弟节点 叔叔节点
Entry<K,V> y = rightOf(parentOf(parentOf(x)));
if (colorOf(y) == RED) { // 叔叔节点是红色
// 变色
setColor(parentOf(x), BLACK);// 设置父节点的颜色是黑色
setColor(y, BLACK);// 设置叔叔节点的颜色为 黑色
setColor(parentOf(parentOf(x)), RED);// 设置 祖父节点的颜色是 红色
// 将祖父节点你设置为插入节点，开启新一轮的循环
x = parentOf(parentOf(x));
} else {// 叔叔节点是黑色
// 判断x是不是父节点的右节点
if (x == rightOf(parentOf(x))) {
x = parentOf(x);
// 逻辑是先左旋后右旋
// 剩下三种情况一样逻辑
rotateLeft(x);
}
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateRight(parentOf(parentOf(x)));
}
} else {
Entry<K,V> y = leftOf(parentOf(parentOf(x)));
if (colorOf(y) == RED) {
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
if (x == leftOf(parentOf(x))) {
x = parentOf(x);
rotateRight(x);
}
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateLeft(parentOf(parentOf(x)));
}
}
}
root.color = BLACK;
}
旋转函数举例：
private void rotateRight(Entry<K,V> p) {
if (p != null) {
Entry<K,V> l = p.left;
p.left = l.right;
if (l.right != null) l.right.parent = p;
l.parent = p.parent;
if (p.parent == null)
root = l;
else if (p.parent.right == p)
p.parent.right = l;
else p.parent.left = l;
l.right = p;
p.parent = l;
}
}
HashMap
概念
HashMap数组没有64位的话，即使链表有8个结点以上了也不会转
put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
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)
// resize（）初始数组 扩容（resize详解在下面）
n = (tab = resize()).length;
// 确定插入的key在数组中的下标（原理是&1为原值）
if ((p = tab[i = (n - 1) & hash]) == null)
// 通过hash值找到数组的下标 里面没有内容就直接赋值
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&// hash值相同
((k = p.key) == key || (key != null && key.equals(k))))
// 插入的值的key和数组的当前位置的key是同一个，那么直接修改里面的内容
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;
}
final Node<K,V>[] resize() {
// table = null
Node<K,V>[] oldTab = table;
// oldCap = 0
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 原来的扩容因子
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {// 初始不执行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
// 初始数组容量为16
newCap = DEFAULT_INITIAL_CAPACITY;
// 新的扩容因子0.75*16 =12
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);
}
// 更新了 扩容的临界值 12
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
// 创建了一个容量为16的数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
// 更新了table
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;
}
链表和红黑树的转化
链表转红黑树
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
// tab为空 或者 数组长度小于64
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize(); // 扩容
else if ((e = tab[index = (n - 1) & hash]) != null) {
// 链表转红黑树的逻辑
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
这时候的扩容resize（）：
final Node<K,V>[] resize() {
// 假设【1,2,3,4,5,6,7,8,，9，10,11，，，，，，】
Node<K,V>[] oldTab = table;
// 16
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 12
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)
// 扩容临界值变成原来的两倍 24
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;
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"})
// 新创建了一个32的数组
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)
// 如果原来的数组就一个值（没有next），就直接赋值
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;
}
图示：
