ArrayList的remove、序列化（一）

ArrayList作为常用的集合，经常使用，这里有两个需要注意一下的地方，分别是remove方法和序列化操作。

remove

先举个小示例：

public class t{
public static void main(String[] args){
ArrayList<String> arr=new ArrayList<String>();
arr.add("a");
arr.add("b");
arr.add("c");
for(int i=0;i<arr.size();i++){
if(arr.get(i).equals("a")||arr.get(i).equals("b")){
arr.remove(i);
}
}
System.out.println(arr.toString());
}
}
//输出结果:[b,c]

原因很简单，大家都知道是因为元素虽然被删除，但是访问下标依然在递增。避免方式就是改为由后向前遍历查询删除即可。

另一种出错方式：

public class t{
public static void main(String[] args){
ArrayList<String> arr=new ArrayList<String>();
arr.add("a");
arr.add("b");
arr.add("c");
for(String s:arr){
if(s.equals("a")||s.equals("b")){
System.out.println("before:"+s);
arr.remove(s);
System.out.println("after:"+s);
}
}
System.out.println(arr.toString());
}
}//抛出异常

在第一个删除元素操作之后，如果存在下一个待检查元素，则会抛出著名的ConcurrentModificationException，并且此处仍然没有避免上一个示例的错误区，使用for-each方式即使没有抛出异常，也会忽略掉已删除元素的下一个元素，例如：

public class t{
public static void main(String[] args){
ArrayList<String> arr=new ArrayList<String>();
arr.add("a");
arr.add("b");
arr.add("c");
for(String s:arr){
if(s.equals("c")||s.equals("b")){
System.out.println("before:"+s);
arr.remove(s);
System.out.println("after:"+s);
}
}
System.out.println(arr.toString());
}
}
//最后输出为：[a,c]

避免忽略检查元素很简单，倒序判断即可，此处重点观察ConcurrentModificationException异常。

使用for-each方式遍历元素，即为使用Iterator迭代查询，在说Iterator之前，先看一下ArrayList中的remove方法。

ArrayList中有两个remove方法：

public E remove(int index) {
rangeCheck(index);

modCount++;//修改次数 +1
E oldValue = elementData(index);

int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);  //System类中的一个本地方法复制
elementData[--size] = null; // 删除数组最后一个元素并修改大小

return oldValue;
}
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);  //调用fastRemove修改
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);   //调用fastRemove修改
return true;
}
}
return false;
}

使用下标删除元素，modCount++修改次数加一，使用查找对象删除，调用fastRemove方法

private void fastRemove(int index) {
modCount++;  //修改计数+1
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);//System类中的一个本地方法复制
elementData[--size] = null; // 删除数组最后一个元素并修改大小
}

此时比较remove(int index)与remove(Object o)+fastRemove(int index)

可以很明显看出，前后两种方式差别只有两处：

1.后者的删除多了一个查找定位index

2.将返回类型修改为boolean类型

差别神马的我们不关心，只关心共同点：

都有：modCount++

ArrayList中for-each循环下的remove操作使得modCount发生了变化，for-each是一个Iterator迭代，Iterator接口中只有三个方法：

public interface Iterator<E> {
boolean hasNext();
E next();
void remove();
}

ArrayList中使用迭代的方式为一个实现Iterator接口的内部类：

public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
public boolean hasNext() {
return cursor != size;
}
public E next() {
checkForComodification();
......................
}
public void remove() {
...............
checkForComodification();
...............
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}

Itr类中增加了一个checkForComodification方法，比较modCount与expectedModCount的值，使用ArrayList的两个remove方法都只是修改了modCount，所以在迭代hasNext返回true时，next方法会抛出异常。修改方式很简单，使用Iterator的remove方法即可，remove函数为：

public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();

try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;//修改expectedModCount值
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}

使用示例：

public class t{
public static void main(String[] args){
ArrayList<String> arr=new ArrayList<String>();
arr.add("a");
arr.add("b");
arr.add("c");

Iterator<String> it=arr.iterator();
while(it.hasNext()){
String s=it.next();
if(s.equals("c")||s.equals("b")){
System.out.println("before:"+s);
it.remove();
System.out.println("after:"+s);
}
}
System.out.println(arr.toString());
}
}
//最后输出为：[a]

最后多说一句，此处ArrayList的元素类型为String，如果是Integer类，可能存在一个小的情况：

public class t{
public static void main(String[] args){
ArrayList<Integer> arr=new ArrayList<Integer>();
arr.add(2);
arr.add(1);
arr.add(3);
arr.remove(2);//基本类型使用  remove(int index);  删除元素：3
arr.remove((Integer)2);//使用remove(Object o);删除元素：2
}
}

总结：

如果遍历中用到ArrayList的remove时，使用倒序查询删除即可。使用for-each图操作简化的话，就别有remove行为了，最简单还是直接使用Iterator的删除操作，免得写个遍历还要顾虑许多。