1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 //返回ArrayList的迭代器。
public Iterator<E> iterator() {
//创建私有内部类，该类实现了Iterator接口
return new Itr();
}
/**
* An optimized version of AbstractList.Itr
*/
private class Itr implements Iterator<E> {
int cursor;
// index of next element to return
光标,默认值就是0
//lastRet本质指的是迭代器迭代到的元素下标
int lastRet = -1; // index of last element returned; -1 if no such 返回的最后一个元素的索引；-1 如果没有
//将集合实际修改次数modCount赋值给预期修改数expectedModCount
int expectedModCount = modCount;
//判读集合是否有元素
public boolean hasNext() {
//光标不等于集合的size说明有元素
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
//检查预期修改数expectedModCount是否等于实际修改数modCount
checkForComodification();
//光标值赋给局部变量
int i = cursor;
//如果i其实也就是cursor大于等于size,则抛出异常
//因为ArrayList是用数组并且元素是连续存放的，所以数组的size的位置是没有数据的
if (i >= size)
throw new NoSuchElementException();
//ArrayList成员数组赋值给局部变量数组
Object[] elementData = ArrayList.this.elementData;
//如果id大于等于elementData数组的长度则抛出异常，
//因为如果i大于等于说明有其他线程修改了集合
if (i >= elementData.length)
throw new ConcurrentModificationException();
//游标cursor加1，也就是数组的下一个下标值
cursor = i + 1;
//获取并返回元素，并且lastRet赋值为i,即本次获取元素的数组下标
return (E) elementData[lastRet = i];
}
//迭代器本身的删除元素的方法
public void remove() {
//lastRet默认值就是小于零的，如果获取到集合迭代器直接掉用remove方法就会报异常
if (lastRet < 0)
throw new IllegalStateException();
//检查预期修改数expectedModCount是否等于实际修改数modCount
checkForComodification();
try {
//调用ArrayList集合的remove元素，
//ArrayList集合的remove方法内部会修改modCount
ArrayList.this.remove(lastRet);
//lastRet赋值给cursor，
//因为lastRet位置的元素删除了，调用ArrayList集合的remove方法，会把lastRet后边的元素往前移动一位
//即ArrayList.this.remove(lastRet)执行完成后，集合的lastRet位置的元素会是原来集合的lastRet+1位置的元素
//所以下次迭代元素应该继续从lastRet位置开始
cursor = lastRet;
//lastRet置为-1，这样说明迭代器中的remove()方法不能连用
lastRet = -1;
//将集合实际修改次数modCount重新赋值给预期修改数expectedModCount
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
//检查modCount 与expectedModCount是否相等
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

public static void main(String[] args) {
ArrayList<Integer> ar = new ArrayList();
for(int i=0;i<1000000;i++){
ar.add(i);
}
long start = System.currentTimeMillis();
//随机取出方式
for(int i=0;i<1000000;i++){
ar.get(i);
}
long end = System.currentTimeMillis();
System.out.println("随机取出方式时间：" + (end-start));
//顺序获取方式
start = System.currentTimeMillis();
Iterator<Integer> iterator = ar.iterator();
while (iterator.hasNext()){
iterator.next();
}
end = System.currentTimeMillis();
System.out.println("顺序获取方式：" + (end-start));
}
}
/*
随机取出方式时间：3
顺序获取方式：6
随机取出方式时间：5
顺序获取方式：7
随机取出方式时间：3
顺序获取方式：6
随机取出方式时间：4
顺序获取方式：7
通过4次对比发现随机获取效率高
ArrayList 实现了RandomAccess接口
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

public static void main(String[] args) {
//创建集合对象
List<String> list = new ArrayList<String>();
//添加元素
list.add("hello");
list.add("Java");
list.add("PHP");
//获取迭代器
Iterator<String> it = list.iterator();
//遍历集合
while (it.hasNext()) {
System.out.println(list);
String s = it.next();
System.out.println(s);
if(s.equals("PHP")) {
list.remove("PHP");
}
}
}
}
/**
* [hello, Java, PHP]
* hello
* [hello, Java, PHP]
* Java
* [hello, Java, PHP]
* PHP
* [hello, Java]
* Exception in thread "main" java.util.ConcurrentModificationException
*
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
*
at java.util.ArrayList$Itr.next(ArrayList.java:851)
*
at com.lcg.collection.arryList.iteratorDemo.Test02.main(Test02.java:28)
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

public static void main(String[] args) {
//创建集合对象
ArrayList<String> list = new ArrayList<String>();
//添加元素
list.add("hello");
list.add("Java1");
list.add("Java2");
list.add("PHP");
list.add("Java");
//获取迭代器
Iterator<String> it = list.iterator();
//遍历集合
while (it.hasNext()) {
System.out.println(list);
String s = it.next();
System.out.println(s);
if(s.equals("PHP")) {
list.remove("PHP");
}
}
System.out.println(list);
}
}
/**
* [hello, Java1, Java2, PHP, Java]
* hello
* [hello, Java1, Java2, PHP, Java]
* Java1
* [hello, Java1, Java2, PHP, Java]
* Java2
* [hello, Java1, Java2, PHP, Java]
* PHP
* [hello, Java1, Java2, Java]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

public static void main(String[] args) {
//创建集合对象
List<String> list = new ArrayList<String>();
//添加元素
list.add("hello");
list.add("PHP");
list.add("Java");
//获取迭代器
Iterator<String> it = list.iterator();
//遍历集合
while (it.hasNext()) {
String s = it.next();
if(s.equals("hello")) {
it.remove();
}
}
System.out.println(list);
//[PHP, Java]
}