1、ArrayList特点详解
存储结构:数组存储,
线程安全:非安全线程
查询速度:速度快
更新删除:速度慢
初始化:10个数组空间,后续以5个增加
/**
* 1、数据结构,数组存储类型
* 2、初始化:10个结构,后续以5个增加
* 3、速度:set,get,add,较快,。remove,add,慢[后面数据移位]
* 4、线程安全:不是安全线程
*/
private void testArrayList() {
//场景一:
ArrayList arrayList = new ArrayList();
arrayList.add(1);
arrayList.add(2);
arrayList.add(3);
arrayList.add(4);
//源码:
//初始定义一个常量为10,默认数据elementData,add时创建
/**
* Default initial capacity.
* private static final int DEFAULT_CAPACITY = 10;
* //调取add方法,创建一个elementData大小的数组
* public boolean add(E e) {
* ensureCapacityInternal(size + 1); // Increments modCount!!
* elementData[size++] = e;
* return true;
* }*/
/**
* 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;
/**
* 场景二:
* add,remove,数组位后移动,速度较慢
*/
Object oldValue = arrayList.remove(1);
/* 源码:
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;
return oldValue;*/
arrayList.add(1, "add");//源码同上,直接移动拷贝
/**
* 场景三:
* 非安全线程,多线程操作时,可能会数据操作失误。
*/
Object setOldValue = arrayList.set(2, "set");
/*源码:
没有进行,加锁操作,所以不安全
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}*/
}
2、LinkedList特点详解
存储结构:链表存储
线程安全:非安全线程
查询速度:速度慢
更新删除:速度快
/**
* 1、数据结构,双向链表存储结构
* 3、速度:add,remove,较快,get,,较慢
* 4、线程安全:不是安全线程
*/
private void testLinkedList() {
/**
* 场景一:
*add,remove双向链表插入,删除
*/
LinkedList linkedList = new LinkedList<>();
linkedList.add("add");
/*源码:
void linkLast(E e) {
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;
size++;
modCount++;
}*/
/**
* 场景二:
* get查询较慢,双向链表查询
*/
linkedList.get(1);
/*双向链表查询源码:
Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) { //链表长度size>>1一位,index比size小
Node<E> x = first;
for (int i = 0; i < index; i++) //循环查询下标,获取节点
x = x.next;//返回下一个节点
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--) //循环查询下标,获取节点
x = x.prev;
return x; //返回上一个节点
}
}*/
/**
* 场景三:
* 线程安全:非安全线程
*/
linkedList.set(1, "set");
/*源码:无线程安全
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}*/
}
3、Vector数组(和ArrayList相同,区别:实现了synchronized线程安全)
存储结构:数组存储,
线程安全:非安全线程
查询速度:速度快
更新删除:速度慢
初始化:10个数组空间,后续以5个增加
/**
* vector和arrayList完全相同
* 所有修改元素的操作,都进
*/
public void testVector() {
Vector vector = new Vector();
vector.add("add");
vector.set(1, "set");
vector.remove(0);
vector.get(1);
//如下源码,所以的增删改查,都实现了,synchronized 加锁的操作
/*源码:synchronized
public synchronized E get(int index) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}*/
}
面向开发过程,记录学习之路。