目录
1⃣️set(int index, E element)将列表中指定位置的元素替换
3⃣️ add(int index, E element)添加元素到指定位置
5⃣️removeRange(int fromIndex, int toIndex)删除指定范围内容
6⃣️removeAll(Collection c)删除列表中所有未包含在此集合的元素(此列表只保留集合中包含元素)
8⃣️addAll(Collection c)添加指定集合元素到队尾
1⃣️set(int index, E element)将列表中指定位置的元素替换
public E set(int index, E element) {
//使用锁，保护线程安全，防止多线程复制数组
final ReentrantLock lock = this.lock;
lock.lock();
try {
//获取数组内容放入旧数组
Object[] elements = getArray();
//获取指定位置内容封装到oldValue对象
E oldValue = get(elements, index);
//当旧内容不等于新内容
if (oldValue != element) {
//获取旧数组长度封装到len对象
int len = elements.length;
//复制旧数组内容放入新数组
Object[] newElements = Arrays.copyOf(elements, len);
//将指定位置内容替换为指定新内容
newElements[index] = element;
//将旧数组引用指向新数组
setArray(newElements);
} else {
//当旧数组指定位置的内容等于指定放入内容，数组引用指向原数组
// Not quite a no-op; ensures volatile write semantics
setArray(elements);
}
return oldValue;
} finally {
lock.unlock();
}
}2⃣️ add(E e)添加元素
public boolean add(E e) {
//加锁，保护线程安全，避免多个线程复制数组
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
//复制旧数组内容到新数组，新数组长度+1
Object[] newElements = Arrays.copyOf(elements, len + 1);
//添加元素到新数组的队尾
newElements[len] = e;
//旧数组引用指向新数组
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}3⃣️ add(int index, E element)添加元素到指定位置
public void add(int index, E element) {
//使用锁，保护线程安全，避免多个线程复制数组
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
//添加位置超出范围，抛出异常
if (index > len || index < 0)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+len);
Object[] newElements;
//计算添加位置
int numMoved = len - index;
//当添加位置为0
if (numMoved == 0)
//直接复制旧数组内容到新数组，数组长度+1
newElements = Arrays.copyOf(elements, len + 1);
else {
//新数组长度为旧数组长度+1
newElements = new Object[len + 1];
//复制下标（0到index位置的）旧数组内容到新数组（从0开始）
System.arraycopy(elements, 0, newElements, 0, index);
//复制下标（index到结束位置的）旧数组内容到新数组（从index+1开始）
System.arraycopy(elements, index, newElements, index + 1,
numMoved);
}
//在指定位置添加元素
newElements[index] = element;
//将旧数组引用指向新数组
setArray(newElements);
} finally {
lock.unlock();
}
}4⃣️remove(int index)删除指定位置元素
public E remove(int index) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
E oldValue = get(elements, index);
//计算删除位置
int numMoved = len - index - 1;
//当要删除位置为0
if (numMoved == 0)
//复制旧数组除最后一个元素的内容，到新数组
setArray(Arrays.copyOf(elements, len - 1));
else {
//设置新数组长度
Object[] newElements = new Object[len - 1];
//复制旧数组（从0到index位置的内容）到新数组（从0位置写入）
System.arraycopy(elements, 0, newElements, 0, index);
//复制旧数组（从index到结束位置的内容）到新数组（从index+1位置写入）
System.arraycopy(elements, index + 1, newElements, index,
numMoved);
setArray(newElements);
}
return oldValue;
} finally {
lock.unlock();
}
}5⃣️removeRange(int fromIndex, int toIndex)删除指定范围内容
void removeRange(int fromIndex, int toIndex) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
//当要删除内容超出范围，抛出异常
if (fromIndex < 0 || toIndex > len || toIndex < fromIndex)
throw new IndexOutOfBoundsException();
//新数组的长度
int newlen = len - (toIndex - fromIndex);
//计算numMoved值来判断从哪分割旧数组（旧数组长度-要删范围的末端）
int numMoved = len - toIndex;
//当计算为0
if (numMoved == 0)
//复制旧数组（从0到新数组长度位置）的内容到新数组
setArray(Arrays.copyOf(elements, newlen));
else {
Object[] newElements = new Object[newlen];
//复制旧数组（从0到fromIndex位置）的内容到新数组（从0位置开始写入）
System.arraycopy(elements, 0, newElements, 0, fromIndex);
//复制旧数组（从toIndex到结束位置）的内容到新数组（从fromIndex位置开始写入）
System.arraycopy(elements, toIndex, newElements,
fromIndex, numMoved);
setArray(newElements);
}
} finally {
lock.unlock();
}
}6⃣️removeAll(Collection<?> c)删除列表中所有未包含在此集合的元素(此列表只保留集合中包含元素)
public boolean removeAll(Collection<?> c) {
//集合为空则抛出异常
if (c == null) throw new NullPointerException();
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
// 当旧数组长度不为0时
if (len != 0) {
int newlen = 0;
//创建一个临时数组，长度为旧数组长度
Object[] temp = new Object[len];
for (int i = 0; i < len; ++i) {
//遍历旧数组内容封装在element对象
Object element = elements[i];
//集合中不包含这个旧数组的内容
if (!c.contains(element))
//将不包含的内容放入临时数组
temp[newlen++] = element;
}
//当临时数组长度不等于旧数组
if (newlen != len) {
//将引用指向复制的旧数组（从下标newlen）的内容
setArray(Arrays.copyOf(temp, newlen));
return true;
}
}
return false;
} finally {
lock.unlock();
}
}7⃣️clear()清空内容
public void clear() {
final ReentrantLock lock = this.lock;
lock.lock();
try {//将引用指向内容为0的新数组
setArray(new Object[0]);
} finally {
lock.unlock();
}
}8⃣️addAll(Collection<? extends E> c)添加指定集合元素到队尾
public boolean addAll(Collection<? extends E> c) {
//获取集合元素封装在cs数组
Object[] cs = (c.getClass() == CopyOnWriteArrayList.class) ?
((CopyOnWriteArrayList<?>)c).getArray() : c.toArray();
//当cs长度为0
if (cs.length == 0)
//则无需执行
return false;
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
//当旧数组内没有值并且cs的类型属于object类
if (len == 0 && cs.getClass() == Object[].class)
//直接将cs元素按顺序放入
setArray(cs);
else {
//将旧数组的内容都放入新数组，长度为旧数组长度加cs长度
Object[] newElements = Arrays.copyOf(elements, len + cs.length);
//将cs中的内容放入新数组（从旧数组的长度len开始放入
System.arraycopy(cs, 0, newElements, len, cs.length);
//引用指向新数组
setArray(newElements);
}
return true;
} finally {
lock.unlock();
}
}9⃣️sort(Comparator<? super E> c)排序
public void sort(Comparator<? super E> c) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
//将旧数组放入新数组
Object[] newElements = Arrays.copyOf(elements, elements.length);
// 将新数组强制转换为泛型类型E[]
@SuppressWarnings("unchecked") E[] es = (E[])newElements;
// 使用Arrays.sort方法对新数组进行排序
Arrays.sort(es, c);
//将新数组设为原始数组
setArray(newElements);
} finally {
lock.unlock();
}
}🔟equals(Object o)与列表进行相比较
public boolean equals(Object o) {
if (o == this)
//两个列表内存地址一样则返回正确
return true;
if (!(o instanceof List))
//如果这个列表没有继承自list类，则返回错误
return false;
List<?> list = (List<?>)(o);
//为list的对象
Iterator<?> it = list.iterator();
//获取旧数组内容
Object[] elements = getArray();
int len = elements.length;
//遍历旧数组
for (int i = 0; i < len; ++i)
//获取list对象的迭代器，传入List对象的元素进行比较。如果两个元素不相等，则返回false
if (!it.hasNext() || !eq(elements[i], it.next()))
return false;
//迭代器检查传入的List对象是否还有剩余元素，如果有则返回false。
if (it.hasNext())
return false;
return true;
}1⃣️1⃣️hashCode()重写了hashCode方法
public int hashCode() {
//初始化一个hashCode变量为1
int hashCode = 1;
//获取自身的元素数组
Object[] elements = getArray();
//获取数组的长度
int len = elements.length;
// 遍历元素数组，对每个元素进行hashCode的计算
for (int i = 0; i < len; ++i) {
Object obj = elements[i];
//将当前的hashCode乘以31，并加上当前元素的hashCode值（如果当前元素为null，则使用0代替其hashCode值。）
hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
}//这个hashCode值可以用于判断两个对象是否相等
return hashCode;
}
}
1272
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
