一、Vector和ArrayList、LinkedList联系和区别?分别的使用场景
答案:
线程安全
ArrayList:底层是数组实现,线程不安全,查询和修改非常快,但是增加和删除慢
LinkedList: 底层是双向链表,线程不安全,查询和修改速度慢,但是增加和删除速度快
Vector: 底层是数组实现,线程安全的,操作的时候使用synchronized进行加锁
使用场景
Vector已经很少用了
增加和删除场景多则用LinkedList
查询和修改多则用ArrayList
二、基于List进行继续追问,连环炮
- 如果需要保证线程安全,ArrayList应该怎么做,用有几种方式
方式一:自己写个包装类,根据业务一般是add/update/remove加锁
方式二:Collections.synchronizedList(new ArrayList<>()); 使用synchronized加锁
方式三:CopyOnWriteArrayList<>() 使用ReentrantLock加锁
三、基于List追问,追杀篇
- 了解CopyOnWriteArrayList吗?和 Collections.synchronizedList实现线程安全有什么区别, 使用场景是怎样的?
答:CopyOnWriteArrayList:执行修改操作时,会拷贝一份新的数组进行操作(add、set、remove等),代价十分昂贵,在执行完修改后将原来集合指向新的集合来完成修改操作,源码里面用ReentrantLock可重入锁来保证不会有多个线程同时拷贝一份数组
场景:读高性能,适用读操作远远大于写操作的场景中使用(读的时候是不需要加锁的,直接获取,删除和增加是需要加锁的, 读多写少)
Collections.synchronizedList:线程安全的原因是因为它几乎在每个方法中都使用了synchronized同步*锁
场景:写操作性能比CopyOnWriteArrayList好,读操作性能并不如CopyOnWriteArrayList
- CopyOnWriteArrayList的设计思想是怎样的,有什么缺点?
答案:设计思想:读写分离+最终一致
缺点:内存占用问题,写时复制机制,内存里会同时驻扎两个对象的内存,旧的对象和新写入的对象,如果对象大则容易发生Yong GC和Full GC
四、基于List进行继续追问-暗器篇
问:说下ArrayList的扩容机制是怎样的
注意:JDK1.7之前ArrayList默认大小是10,JDk1.7之后是0
未指定集合容量,默认是0,若已经指定大小则集合大小为指定的;
当集合第一次添加元素的时候,集合大小扩容为10
ArrayList的元素个数大于其容量,扩容的大小= 原始大小+原始大小/2
问: 为什么是1.5倍?
其计算的时候是利用 >> 位移1位的方式把原本的值减半,这种方式是CPU操作的方式性能很快。至于为什么是 位移一位,或许是1.5倍是一个比较合适的扩容大小。
五、基于list继续追问-大招篇
手写ArrayList
- 设计一个简单的ArrayList【需要包含 构造函数(有参和无参)、add(obj)、 扩容机制】
public class MyArrayList implements Serializable {
//第一次扩容的容量 默认 10
private static final int DEFAULT_CAPACITY = 10;
//用于初始化空的list
private static final Object[] EMPTY_ELEMENT_DATA = {};
//实际存储的元素
transient Object[] elementData;
//实际list集合大小,从0开始
private int size;
public MyArrayList(){
this.elementData = EMPTY_ELEMENT_DATA;
}
public MyArrayList(int initialCapcity){
if(initialCapcity > 0){
this.elementData = new Object[initialCapcity];
} else if(initialCapcity == 0){
this.elementData = EMPTY_ELEMENT_DATA;
} else {
throw new IllegalArgumentException("参数异常");
}
}
public boolean add(Object e){
//判断容量
ensureCapacityInternal(size+1);
this.elementData[size++] = e;
return true;
}
//计算容量+确保容量
private void ensureCapacityInternal(int minCapacity){
//如果是初次扩容,则使用默认的容量
if(elementData == EMPTY_ELEMENT_DATA){
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
if(minCapacity - elementData.length > 0){
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果新容量 < 最小容量, 则将最新的容量赋值给新的容量
if(newCapacity - minCapacity < 0){
newCapacity = minCapacity;
}
//创建新数组
Object[] objects = new Object[newCapacity];
//将旧的数组复制到新的数组里面
System.arraycopy(elementData,0, objects,0,elementData.length);
//修改引用
elementData = objects;
}
}
/**
* 通过下标获取对象
* @param index
* @return
*/
public Object get(int index){
rangeCheck(index);
return elementData[index];
}
private void rangeCheck(int index){
if(index > size || size < 0){
throw new IndexOutOfBoundsException("数组越界");
}
}
/**
* 判断对象所在的位置
* @param o
* @return
*/
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;
}
public Object set(int index, Object obj){
rangeCheck(index);
Object oldValue = elementData[index];
elementData[index] = obj;
return oldValue;
}
/**
* 根据索引删除元素
* @param index
* @return
*/
public Object remove(int index){
rangeCheck(index);
Object oldValue = elementData[index];
//计算要删除的位置后面有几个元素
int numMoved = size - index -1;
if(numMoved>0){
System.arraycopy(elementData,index+1,elementData,index,numMoved);
}
//将多出的位置为空,没有引用对象,垃圾收集器可以回收,如果不为空,将会保存一个引用,可能会造成内存泄露
elementData[--size] = null;
return oldValue;
}
//获取数组实际大小
public int size(){
return this.size;
}
}
System.arraycopy(Object src, int srcPos, Object dest, int destPos,int length)参数介绍
Object src : 原数组
int srcPos : 从元数据的起始位置开始
Object dest : 目标数组
int destPos : 目标数组的开始起始位置
int length : 要copy的数组的长度
The end