Java8ArrayList之forEach的使⽤⽬录
Java8 ArrayList之forEach使⽤
⼀、⽤法
⼆、效率
ArrayList在foreach中remove的问题分析
iterator
itr.hasNext 和 实现
倒数第⼆个元素的特殊
如何避坑
⽅法⼀，还是fori，位置前挪了减回去就⾏了, remove后i--：
⽅法⼆，不⽤ArrayList的remove⽅法，⽤Itr⾃⼰定义的remove⽅法，代码如下：Java8 ArrayList之forEach使⽤
之前使⽤Java8、顺便整理⾃⼰学到的⼀些
⼀、⽤法
常⽤写法
for (String str : list){
System.out.println(str);
}
Java8中
list.forEach(str-> System.out.println(str));
list.forEach(str-> {});//{}中可以写逻辑
代码看上去更简洁
⼆、效率
public static void main(String[] args) {
List<String> list = new ArrayList<>();
for (int i=0;i<1000000;i++){
list.add("str"+i);
}
for1(list);
for2(list);
for3(list);
for4(list);
}
public static void for1(List<String> list){
long startTime = System.currentTimeMillis();
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < list.size(); i++) {
stringBuilder.(i));
}
long endTime = System.currentTimeMillis();
System.out.println("for1 execute time : "+(endTime-startTime) +" ms");
}
public static void for2(List<String> list){
long startTime = System.currentTimeMillis();
StringBuilder stringBuilder = new StringBuilder();
for (String str : list){
stringBuilder.append(str);
}
long endTime = System.currentTimeMillis();
System.out.println("for2 execute time : "+(endTime-startTime) +" ms");
}
public static void for3(List<String> list){
long startTime = System.currentTimeMillis();
StringBuilder stringBuilder = new StringBuilder();
list.forEach(c -> {
stringBuilder.append(c);
});
long endTime = System.currentTimeMillis();
System.out.println("for3 execute time : "+(endTime-startTime) +" ms");
}
public static void for4(List<String> list){
long startTime = System.currentTimeMillis();
StringBuilder stringBuilder = new StringBuilder();
list.stream().forEach(c -> {
stringBuilder.append(c);
});
long endTime = System.currentTimeMillis();
System.out.println("for4 execute time : "+(endTime-startTime) +" ms");
}
执⾏结果：
for1 execute time : 33 ms
for2 execute time : 52 ms
for3 execute time : 78 ms
for4 execute time : 37 ms
结果分析：
虽然forEach使代码看上去更简洁，但是从效率上看却是相反的，最原始的循环效率最⾼，操作越⽅便的反⽽性能会下降，操作越⽅便的⽅法其内部都是层层调⽤
default void forEach(Consumer<? super T> action) {
for (T t : this) {
action.accept(t);
}
}
⾄于list.stream().forEach听说它可以⽀持多线程并⾏操作。
ArrayList在foreach中remove的问题分析
都说ArrayList在⽤foreach循环的时候，不能add元素，也不能remove元素，可能会抛异常，那我们就来分析⼀下它具体的实现。我⽬前的环境是Java8。
有下⾯⼀段代码：
public class TestForEachList extends BaseTests {
@Test
public void testForeach() {
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
for (String s : list) {
}
}
}
代码很简单，⼀个ArrayList添加3个元素，foreach循环⼀下，啥都不⼲。那么foreach到底是怎么实现的呢，暴⼒的⽅法看⼀下，编译改类，⽤ javap -c TestForEachList查看class⽂件的字节码，如下：
javap -c TestForEachList
Warning: Binary file TestForEachList contains collection.list.TestForEachList
Compiled from "TestForEachList.java"
public class collection.list.TestForEachList extends com.ferret.BaseTests {
public collection.list.TestForEachList();
Code:
0: aload_0
1: invokespecial #1 // Method com/ferret/BaseTests."<init>":()V
4: return
public void testForeach();
Code:
0: new #2 // class java/util/ArrayList
3: dup
4: invokespecial #3 // Method java/util/ArrayList."<init>":()V
7: astore_1
8: aload_1
9: ldc #4 // String 1
11: invokeinterface #5, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
16: pop
17: aload_1
18: ldc #6 // String 2
20: invokeinterface #5, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Zjava arraylist用法
25: pop
26: aload_1
27: ldc #7 // String 3
29: invokeinterface #5, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
34: pop
35: aload_1
36: invokeinterface #8, 1 // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
41: astore_2
42: aload_2
43: invokeinterface #9, 1 // InterfaceMethod java/util/Iterator.hasNext:()Z
48: ifeq 64
51: aload_2
52: invokeinterface #10, 1 // InterfaceMethod java/:()Ljava/lang/Object;
57: checkcast #11 // class java/lang/String
60: astore_3
61: goto 42
64: return
}
可以勉强读，⼤约是调⽤了List.iterator，然后根据iterator的hasNext⽅法返回结果判断是否有下⼀个，根据next⽅法取到下⼀个元素。
但是是总归是体验不好，我们是现代⼈，所以⽤⼀些现代化的⼿段，直接⽤idea打开该class⽂件⾃动反编译，得到如下内容：
public class TestForEachList extends BaseTests {
public TestForEachList() {
}
@Test
public void testForeach() {
List<String> list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
String var3;
for(Iterator var2 = list.iterator(); var2.hasNext(); var3 = (()) {
;
}
}
}
体验好多了，再对⽐上⾯的字节码⽂件，没错
for(Iterator var2 = list.iterator(); var2.hasNext(); var3 = (()) {
;
}
这就是脱掉语法糖外壳的foreach的真正实现。
接下来我们看看这三个⽅法具体都是怎么实现的：
iterator
ArrayList的iterator实现如下：
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
//省略部分实现
}
Itr是ArrayList中的内部类，所以list.iterator()的作⽤是返回了⼀个Itr对象赋值到var2，后⾯调⽤var2.hasNext()，()就是Itr的具体实现了。
这⾥还值的⼀提的是expectedModCount，这个变量记录被赋值为modCount， modCount是ArrayList的⽗类AbstractList的⼀个字段，这个字段的含义是list结构发⽣变更的次数，通常是add或remove等导致元素数量变更的会触发modCount++。
下⾯接着看itr.hasNext()``()的实现。
itr.hasNext 和 实现
hasNext很简单
public boolean hasNext() {
return cursor != size;
}
当前index不等于size则说明还没迭代完，这⾥的size是外部类ArrayList的字段，表⽰元素个数。
在看next实现：
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();
}
next⽅法第⼀步 checkForComodification()，它做了什么？如果modCount != expectedModCount就抛出异常ConcurrentModificationException。modCount是什么？外部类ArrayList的元素数量变更次数；expectedModCount是什么？初始化内部类Itr的时候外部类的元素数量变更次数。
所以，如果在foreach中做了add或者remove操作会导致程序异常ConcurrentModificationException。这⾥可以⾛两个例⼦： @Test(expected = ConcurrentModificationException.class)
public void testListForeachRemoveThrow() {
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
for (String s : list) {
}
}
@Test(expected = ConcurrentModificationException.class)
public void testListForeachAddThrow() {
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
for (String s : list) {
list.add(s);
}
}
单元测试跑过，都抛了ConcurrentModificationException。
checkForComodification()之后的代码⽐较简单这⾥就不分析了。
倒数第⼆个元素的特殊
到这⾥我们来捋⼀捋⼤致的流程：
1.获取到Itr对象赋值给var2
2.判断hasNext，也就是判断cursor != size，当前迭代元素下标不等于list的个数，则返回true继续迭代；反之退出循环
<取出迭代元素
checkForComodification()，判断modCount != expectedModCount，元素数量变更次数不等于初始化内部类Itr的时元素变更次数，也就是在迭代期间做过修改就抛ConcurrentModificationException。
如果检查通过cursor++
下⾯考虑⼀种情况：remove了倒数第⼆个元素会发⽣什么？代码如下：
@Test
public void testListForeachRemoveBack2NotThrow() {
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
for (String s : list) {
System.out.println(s);
if ("2".equals(s)) {
}
}
}
猜⼀下会抛出异常吗？答案是否定的。输出为：
1
2
发现少了3没有输出。分析⼀下
在倒数第⼆个元素"2"remove后，list的size-1变为了2，⽽此时itr中的cur在next⽅法中取出元素"2"后，做了加1，值变为2了，导致下次判断hasNext时，cursor==size，hasNext返回false，最终最后⼀个元素没有被输出。
如何避坑
foreach中remove 或 add 有坑，
在foreach中做导致元素个数发⽣变化的操作(remove, add等)时，会抛出ConcurrentModificationException异常
在foreach中remove倒数第⼆个元素时，会导致最后⼀个元素不被遍历
那么我们如何避免呢？不能⽤foreach我们就⽤fori嘛，如下代码：
@Test
public void testListForiMiss() {
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
for (int i = 0; i < list.size(); i++) {
System.out.(i));
}
}
很明显上⾯是⼀个错误的⽰范，输出如下：
1
3
原因很简单，原来的元素1被remove后，后⾯的向前拷贝，2到了原来1的位置（下标0），3到了原来2的位置（下标
1），size由3变2，i+1=1，输出(1)就成了3，2被漏掉了。
下⾯说下正确的⽰范：
⽅法⼀，还是fori，位置前挪了减回去就⾏了, remove后i--：
@Test
public void testListForiRight() {
List<String> list = new ArrayList<>();
list.add("1");
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论