记一次使用list删除元素
常见list遍历方法
- 普通for循环遍历
- 增强for循环遍历
- 迭代器遍历
普通for循环
List<String> list = new ArrayList<>();
list.add("1");
list.add("1");
list.add("1");
list.add("2");
list.add("3");
for (int i = 0; i < list.size(); i++) {
if ("1".equals(list.get(i))) {
list.remove(list.get(i));
}
}
看似条件相等，进行删除，没有问题，实则失败…
原因：
ArrayList底层是数组结构，所以每一个元素下面会有对应下标，从上面list举例，下标为 0-4；当第一个元素进入if判断，返回true，进入if，删除，此时下标重新排列，原本下标为“1”的元素此时下标为“0”，此时，由于刚才循环结束，i++，i等于1；所以再次进入循环，进行判断，list.get(1)，得到了list中第二个元素，所以跳过了原本的第二个元素；得出结论，当list去重时，使用普通for循环会漏掉两个相邻且相同的第二位满足条件的元素。
解决办法：
这个想要解决也是很简单的，代码如下：
if ("1".equals(list.get(i))) {
list.remove(list.get(i));
i--;
}
当list移除满足条件之后，将循环次数i进行减一操作。
增强for循环
for (String str: list) {
if("1".equals(str)) {
list.remove(str);
}
}
同样看似没有问题，实则抛出java.util.ConcurrentModificationException。
原因：
先看ArralList源码
package com.workit.demo.array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.function.Predicate;
/**
* @author:
* @Date: 2020/6/9
* @Description:
*/
public class ArrayListDelete {
public static void main(String[] args) {
Predicate<String> predicate = p -> p.equals("a") || p.equals("b");
// 可以正常删除结果正确
deleteByIterator(getList(), predicate);
// 可以正常删除结果正确
deleteByReverseOrder(getList(), predicate);
// 可以删除 结果不正确
deleteByOrder(getList(), predicate);
// 不能删除 报错java.util.ConcurrentModificationException
deleteByArrayList(getList(), predicate);
// 不能删除 报错java.util.ConcurrentModificationException
deleteByForeach(getList(), predicate);
//不能删除 报错 java.util.ConcurrentModificationException
deleteByEnhancedForLoop(getList(), predicate);
// 正常删除数据
deleteAll(getList(), predicate);
}
public static List<String> getList() {
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
return list;
}
/**
* 普通for循环倒序删除
* 可以正常删除 结果正确
* @param list
* @param predicate
*/
public static void deleteByReverseOrder(List<String> list, Predicate<String> predicate) {
for (int i = list.size() - 1; i >= 0; i--) {
if (predicate.test(list.get(i))) {
list.remove(list.get(i));
}
}
System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()+":"+list.toString());
}
/**
* 普通for循环正序删除
*可以删除 结果不正确
* @param list
* @param predicate
*/
public static void deleteByOrder(List<String> list, Predicate<String> predicate) {
for (int i = 0; i < list.size(); i++) {
if (predicate.test(list.get(i))) {
list.remove(list.get(i));
}
}
System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()+":"+list.toString());
}
/**
* 迭代器循环，使用ArrayList的remove()方法删除
* 可以删除 结果不正确
* @param list
* @param predicate
*/
public static void deleteByArrayList(List<String> list, Predicate<String> predicate) {
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
if (predicate.test(iterator.next())) {
list.remove(iterator.next());
}
}
System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()+":"+list.toString());
}
/**
* 迭代器循环，使用迭代器的remove()方法删除
* 可以正常删除结果正确
* @param list
* @param predicate
*/
public static void deleteByIterator(List<String> list, Predicate<String> predicate) {
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
if (predicate.test(iterator.next())) {
iterator.remove();
}
}
System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()+":"+list.toString());
}
/**
* java8 forEach方法删除
*不能删除 报错 java.util.ConcurrentModificationException
* @param list
* @param predicate
*/
public static void deleteByForeach(List<String> list, Predicate<String> predicate) {
list.forEach(p -> {
if (predicate.test(p)) {
list.remove(p);
}
});
System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()+":"+list.toString());
}
/**
* 增强版for循环删除
*不能删除 报错 java.util.ConcurrentModificationException
* @param list
* @param predicate
*/
public static void deleteByEnhancedForLoop(List<String> list, Predicate<String> predicate) {
for (String string : list) {
if (predicate.test(string)) {
list.remove(string);
}
}
}
}
/**
* 调用批量删除方法
* @param list
* @param predicate
*/
public static void deleteAll(List<String> list, Predicate<String> predicate) {
List<String> removeList = new ArrayList<>();
for (String string : list) {
if (predicate.test(string)) {
removeList.add(string);
}
}
list.removeAll(removeList);
System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()+":"+list.toString());
}
增强版for循环删除 && 迭代器循环使用ArrayList.remove()方法删除
增强版for循环删除（deleteByEnhancedForLoop）、迭代器循环，使用ArrayList的remove()方法删除（deleteByArrayList）这两种姿势都会抛出java.util.ConcurrentModificationException，他们本质都是迭代器循环，每次循环都会checkForComodification这个方法检查modCount 和expectedModCount的值。
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
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];
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
而List的删除方法每次删除之后modCount都会进行加1操作，expectedModCount值不变还是原来的。
private void fastRemove(int index) {
modCount++; //modCount`都会进行加1操作
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
}
所以都会抛出ConcurrentModificationException异常。
推荐做法：迭代器循环
迭代器循环，使用迭代器的remove()方法删除（deleteByIterator）这个比较简单我们直接看迭代器的删除 关键代码就一行 expectedModCount = modCount。
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount; //调用ArrayList的删除方法后多了这么一句话。
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
当然，这种方式也是《阿里开发手册》当中所推荐的写法。
附 阿里开发手册 泰山版
网址：https://pan.baidu.com/s/13GVC43hsGISvuJhXFkDIjg
提取码：j863