java-ArrayList源码
ArrayLisrt 应该不陌生，对，就是可调整大小的动态数组，具体怎么实现的呢，就让咱们一探究竟吧！
初始化：
构造方法：
构建一个初始化容量为10的空数组
//默认初始化数据容器
private static final Object[] EMPTY_ELEMENTDATA = {};/**
/* 存储数组元素的数组缓冲区
* ArrayList的容量就是这个数组缓冲区的长度
*任何一个空的ArrayList将在添加第一个扩展元素添加后，为默认容量
*/
transient Object[] elementData; // 非私有 简化嵌套类访问
public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }
有參构造：
//创建指定大小的数组
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(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; } }
add（）：
将指定的元素添加到列表的末尾
/*
*
*@param e 新增数据元素
*
*/
public boolean add(E e) {
//确保数组具有存储空间，包括核心扩容算法 ensureCapacityInternal(size + 1); // Increments modCount!!
// 数组末尾追加，索引下标++；新增元素后索引加以 elementData[size++] = e; return true; }
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//确认数组具有存储空间，数组已开辟空间不够，进行扩容
private void ensureExplicitCapacity(int minCapacity) {
modCount++;//集合的修改次数
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//返回数组最小容量，默认容量10
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void grow(int minCapacity) {
//计算已有数组长度
int oldCapacity = elementData.length;
// >>：右移，相当于除以2的n次幂
// <<：左移，相当于乘以2的n次幂
//核心，扩容相当于原数组的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
//赋值操作
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//拷贝操作
elementData = Arrays.copyOf(elementData, newCapacity);
}
add(int index, E element)；
列表时指定位置插入指定元素
public void add(int index, E element) {
//校验新增索引位置 rangeCheckForAdd(index); //确认存储空间大，并扩容原大小1.5倍 ensureCapacityInternal(size + 1); // Increments modCount!!
//数组拷贝 System.arraycopy(elementData, index, elementData, index + 1,size - index); elementData[index] = element; size++; }
// 判断索引位置，大于数组大小或者小于0抛出异常
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
addAll(Collection<? extends E> c)
按照指定的集合的iterator返回的顺序将指定集合中的所有元素追加到列表末尾
public boolean addAll(Collection<? extends E> c) {
// 将新增的元素转化为数组 Object[] a = c.toArray();
// 获取数组a的长度 int numNew = a.length;
// 校验空间大小，并1.5倍扩容 ensureCapacityInternal(size + numNew); // Increments modCount
//拷贝元素 System.arraycopy(a, 0, elementData, size, numNew); //数组长度操作后，进行累加
size += numNew; return numNew != 0; }
addAll(int index, Collection<? extends E> c)
将指定集合中的所有元素插入到里列表，从指定的位置开始
public boolean addAll(int index, Collection<? extends E> c) { rangeCheckForAdd(index); Object[] a = c.toArray(); int numNew = a.length; ensureCapacityInternal(size + numNew); // Increments modCount //计算需要移动的个数（elementData） int numMoved = size - index; if (numMoved > 0)//判断移动个数是否大于0 System.arraycopy(elementData, index, elementData, index + numNew, numMoved); System.arraycopy(a, 0, elementData, index, numNew); size += numNew; return numNew != 0; }
set(int index, E element)
修改方法
public E set(int index, E element) {
//判断索引下标 rangeCheck(index); //获取数组中index索引所在位置的数据元素 E oldValue = elementData(index);
//替换数组中index索引所在位置的数据元素内容 elementData[index] = element; return oldValue;//返回修改园所原始内容 }
get(int index)
获取方法
public E get(int index) {
//判断索引位置 rangeCheck(index); //返回索引位置数据 return elementData(index); }
toString()
转换方法，将集合中所有元素转换为字符串
public String toString() {
//获取迭代器 Iterator<E> it = iterator(); if (! it.hasNext()) return "[]"; //进行字符串组装 StringBuilder sb = new StringBuilder(); sb.append('[');
//无线循环 for (;;) { E e = it.next(); sb.append(e == this ? "(this Collection)" : e); if (! it.hasNext()) return sb.append(']').toString(); sb.append(',').append(' '); } }
Iterator<E> iterator()
获取迭代器
public Iterator<E> iterator() { return new Itr(); }
//迭代器
private class Itr implements Iterator<E> {
int cursor; // 当前位置
int lastRet = -1; // 记录- 1
int expectedModCount = modCount;//将集合实际修改次数复制给预期修改次数
Itr() {}
//判断集合是否有元素
public boolean hasNext() {
return cursor != size;
}
public E next() {
//检查预期修改次数和实际修改次数相等
checkForComodification();
//将光标复制给i变量
int i = cursor;
//进行集合大小判断
if (i >= size)
throw new NoSuchElementException();
//把集合存储数据的数组复制给局部变量
Object[] elementData = ArrayList.this.elementData;
//如果满足条件产生并发修改异常
if (i >= elementData.length)
throw new ConcurrentModificationException();
//光标移动
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
remove(Object o)
删除元素
public boolean remove(Object o) { if (o == null) { for (int index = 0; index < size; index++) if (elementData[index] == null) { fastRemove(index); return true; } } else { for (int index = 0; index < size; index++) if (o.equals(elementData[index])) { //删除操作
fastRemove(index); return true; } } return false; }
void clear()
清空方法
public void clear() { modCount++; // clear to let GC do its work for (int i = 0; i < size; i++) elementData[i] = null; size = 0; }
boolean contains(Object o)
判断集合中是否包含元素
public boolean contains(Object o) { return indexOf(o) >= 0; }
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
boolean isEmpty()
空实体判断
public boolean isEmpty() { return size == 0; }
1.ArrayList是如何扩容的？
第一次扩容10
以后每次扩容原有用量的1.5倍
2。数组新增海量数据，优化？
ArrayList底层，需要进行多次扩容，效率低下！
优化方案：使用构造，指定初始化容量
3.ArrayList插入或者删除元素一定比LinkedList慢？
不一定，因为LinkedList查找元素（node）很费时
ArrayList remove()
public E remove(int index) {
//索引校验 rangeCheck(index); //数组实际操作次数，多线程使用 modCount++;
//获取下标索引为index的元素 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; }
LinkedList remove()方法
public E remove(int index) {
//检查索引 checkElementIndex(index); return unlink(node(index)); }
//
E unlink(Node<E> x) {
//需要删除的元素
final E element = x.item;
//下一个元素
final Node<E> next = x.next;
//上一个元素
final Node<E> prev = x.prev;
if (prev == null) {//首节点
first = next;//把下一个节点置为首节点
} else {//非首节点
prev.next = next;//把当前节点置为下一个节点
x.prev = null;//把
}
if (next == null) {//尾节点
last = prev;//前一个节点置为尾节点
} else {
next.prev = prev;//
x.next = null;
}
//元素置为空
x.item = null;
//大小减1
size--;
//实际操作次数
modCount++;
return element;
}
//LinkedList 存储的第一个节点
transient Node<E> first;
//查找元素
Node<E> node(int index) {
// assert isElementIndex(index);
//判断索引是否小于数组大小的一般
if (index < (size >> 1)) {
//把第一个节点赋值给x
Node<E> x = first;
//从第一个节点开始往后读取，直到下标为index的元素
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
//把最后一个节点赋值给x
Node<E> x = last;
//从最后一个节点开始，以次往前读取，直到下标为index的元素
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
//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;
}
}
4.ArrayList是线程安全的吗？如何解决线程共享？
不是线程安全的
解决方案：
1.添加同步代码块或者同步方法
2.使用vector替代ArrayList；不考虑线程安全的情况，更推荐ArrayList
3.通过工具类实现Collections.synchronizedList(new ArrayList<String>())创建数组
5.如何复制ArrayList到另一个ArrayList？
1.使用clone()
2.使用ArrayList构造
3.使用AddAll方法
4.以及循环遍历逐个添加
6.已知成员变量集合存储N多用户名称，在多线程环境下，使用迭代器读取集合数据同时保证还可以正常的写入数据到集合？
使用CopyOnWriteArrayList
7.ArrayList和LinkedList区别？
ArrayList
基于动态数组的结构
对于随机访问的get和set，ArrayList由于LinkedList
对于随机的add和remove，AraayList不一定比Linkedlistman（ArrayList底层由于是动态数组，因此并不是每次add和remove都需要创建新的数组）
LinedList
基于链表的数据结构
对于顺序操作，LinkedList不一定比ArrayList慢
对于随机操作，LikedList效率明显较低
自定义ArrAyList
1.定义成员变量
2.构造方法
3.定义添加、移除、修改、扩容方法
