本文聚焦Java SE中ArrayList的内部类ListItr，详细分析其作为列表迭代器的实现。通过源码解析，展示了set(E e)和add(E e)方法的使用，并探讨了内部类的应用。文章末尾邀请读者互动交流，共同探讨Java SE的相关知识。
Java SE 是什么，包括哪些内容(二十一)？
本文内容参考自Java8标准
在上一篇博文中讨论了集合(容器)类的通用迭代器类型Iterator，这篇博文来讨论以下有关列表的专门迭代器：
ListIterator
它是专门遍历迭代列表的一个类型标准，下面来看一下ArrayList类有关于它的具体实现
ArrayList类是通过内部类来提供的具体实现，至于为什么使用内部类，可以参考我有关内部类知识点的博文。
下面就从具体的源代码开始：
为了省略篇幅，以下所有的代码都是内部类的代码部分，就不再涉及外部类ArrayList的部分了。
//private类,extends类Itr,implements接口ListIterator<E>
//它的作用是：ArrayList实例对象的迭代器,用于元素的迭代遍历(列表专用)。
private class ListItr extends Itr implements ListIterator<E> {
//构造方法一：带一个int类型的形式参数index
//它的作用是：创建一个从当前列表指定索引位置index开始迭代的迭代器。
ListItr(int index) {
//调用父类无参的构造方法
super();
//将index的值赋值给cursor,表示将当前迭代器所在元素的索引
//直接设置为index,也可以说是将游标的位置设置为index。
cursor = index;
}
//public方法,供对象实例调用
//返回类型为a,不带任何形式参数
//它的作用是：判断当前迭代器所在的位置是否还有上一个元素
public boolean hasPrevious() {
//只要表达式cursor != 0成立,就表示当前迭代器所在元素的索引不是0.
//那就肯定还有上一个元素。
return cursor != 0;
}
//public方法,供对象实例调用
//返回类型为a,不带任何形式参数
//它的作用是：返回下一个元素的索引值
public int nextIndex() {
//下一个元素的索引值就是cursor,
//有兴趣可以看看内部类Itr的next()方法的源码。
return cursor;
}
//public方法,供对象实例调用
//返回类型为a,不带任何形式参数
//它的作用是：返回上一个元素的索引值
public int previousIndex() {
//上一个元素的索引值就是cursor-1,
//有兴趣可以看看内部类Itr的next()方法的源码。
//可能会有人疑惑为什么不是return lastRet.
//因为lastRet的值在remove()方法之后就是-1了。
//不能适用所有的情况.只有cursor始终代表了迭代器所在的元素索引
return cursor - 1;
}
//注解
@SuppressWarnings("unchecked")
//public方法,供对象实例调用
//返回类型为a,不带任何形式参数
//它的作用是：返回上一个元素
public E previous() {
//判断集合是否被修改过。
//在返回元素之前需要判断集合是否被修改过,
//如果被除迭代器提供的修改方式修改过
//立即触发快速失败机制。
checkForComodification();
//获取上一个元素的索引值cursor - 1
int i = cursor - 1;
//首次下标的判断.
//如果i的值小于0,那么无法返回元素
//因为迭代器当前所在的元素不存在。
if (i < 0)
//抛出NoSuchElementException异常
throw new NoSuchElementException();
//将当前列表存储元素的数组的引用复制一遍,赋值给引用elementData
//因为可能存在多线程的并发访问.所以这里赋值以后继续进行下标的再判断
//判断是否其它线程修改了集合。
Object[] elementData = ArrayList.this.elementData;
//再次进行下标的判断。
//如果i的值大于等于数组elementData的长度
//说明数组被其它线程修改过。
if (i >= elementData.length)
//抛出ConcurrentModificationException异常
throw new ConcurrentModificationException();
//因为是获取上一个元素的值,那么上一个元素自然就变成了当前元素,自然要将
//cursor的值设置为当前元素的索引值,也就是i,可以形象地认为,需要将游标移回来
cursor = i;
//返回当前元素,也就是elementData[lastRet = i],同时给lastRet赋值.
//你会发现迭代器的操作都是在操作元素之前先确定cursor的值,
//操作元素之后确定lastRet的值。
return (E) elementData[lastRet = i];
}
//public方法,供对象实例调用
//返回类型为a,不带任何形式参数
//它的作用是：用指定元素e替换当前位置的元素。
//在末尾会附上使用此方法的代码示例。
public void set(E e) {
//如果lastRet的值小于0
if (lastRet < 0)
//抛出IllegalStateException异常
throw new IllegalStateException();
//判断集合是否被修改过。
//在返回元素之前需要判断集合是否被修改过,
//如果被除迭代器提供的修改方式修改过
//立即触发快速失败机制。
checkForComodification();
//try...catch块,Java捕捉异常的机制
try {
//调用外部类的srt(int index,E e)完成当前功能
//为什么这里使用的是lastRet的值,而不是cursor的值?
//因为必须在调用了方法next()获得元素之后,才能调用方法set(),
//在next()方法的内部cursor和lastRet的值大部分时间都是相等的
//注意最后一行代码：elementData[lastRet = i],这个时候
//将当前元素的索引赋值给了lastRet
//而在此之前就进行了游标下移的操作：cursor = i + 1
//所以在next()方法之后cursor代表的下一个元素的索引值。
ArrayList.this.set(lastRet, e);
//捕捉IndexOutOfBoundsException异常
} catch (IndexOutOfBoundsException ex) {
//抛出ConcurrentModificationException异常
throw new ConcurrentModificationException();
}
}
//public方法,供对象实例调用
//返回类型为a,不带任何形式参数
//它的作用是：添加指定元素e
public void add(E e) {
//判断集合是否被修改过。
//在返回元素之前需要判断集合是否被修改过,
//如果被除迭代器提供的修改方式修改过
//立即触发快速失败机制。
checkForComodification();
//try...catch块,Java捕捉异常的机制
try {
//为什么这里是将cursor的值赋值给i?
//很明显,add(E e)方法必须在调用next()获取元素之后操作才有效
//而在next()方法的末尾,进行了cursor = i + 1操作
//将cursor指向了下一个元素.
//所以很明显,add(E e)方法是在当前元素的后面添加一个元素。
int i = cursor;
//调用外部类的add(int index,E element)方法完成当前功能
ArrayList.this.add(i, e);
//将cursor的值指向下一个元素(移动游标,准备操作下一个元素)。
//这是为了在同一个线程中添加元素不影响元素的遍历。
cursor = i + 1;
//当调用了remove()和add()方法后,lastRet的值都会设置为-1
//保证了当前迭代器是不可逆的。
//如果在操作了remove()和add()方法后,还想继续使用当前的迭代器
//对象,都会抛出异常。
lastRet = -1;
//将modCount的值赋值给expectedModCount,保证快速失败机制的运行正常。
//所以允许使用迭代器的方法添加删除元素,不允许除此之外的其它方法。
expectedModCount = modCount;
//捕捉IndexOutOfBoundsException异常
} catch (IndexOutOfBoundsException ex) {
//抛出ConcurrentModificationException异常
throw new ConcurrentModificationException();
}
}
}
方法set(E e)的使用代码示例：
//类FirstWithLambda
public class FirstWithLambda{
//程序执行入口main方法
public static void main(String[] args){
//创建ArrayList对象实例
//这里只打算添加5个元素.使用默认的构造方法
//从之前ArrayList的源码中知道,第一次添加元素的时候
//存储元素的数组的默认空间是10,足够了
//如果打算添加50个元素,要么使用带参数的构造函数
//要么使用方法ensureCapacity(50),一次性创建足够的空间
//以提高程序的执行效率。
ArrayList<String> list = new ArrayList<>();
//添加元素
list.add("ad");
list.add("bs");
list.add("ga");
list.add("da");
list.add("ed");
list.add("fs");
//获取ListIterator类型的列表迭代器对象
ListIterator<String> it = list.listIterator();
//遍历当前列表
it.forEachRemaining((String -> {
//获取当前元素s
String s = it.next();
//如果它包含字符串"a"
if(s.contains("a")) {
//将它设置为"a"
//或者解释为用字符串"a"替换
it.set("a");
}
}));
//再次获取迭代器对象it1,之前的迭代器对象it失效了,这个就是不可逆。
ListIterator<String> it1 = list.listIterator();
//输出当前列表的所有元素。
it1.forEachRemaining((String -> System.out.println(String)));
}
}
结果示例：
在上面的代码基础上加上方法add(E e)的示例代码：
public class FirstWithLambda{
//程序执行入口main方法
public static void main(String[] args){
ArrayList<String> list = new ArrayList<>();
list.add("ad");
list.add("bs");
list.add("ga");
list.add("da");
list.add("ed");
list.add("fs");
ListIterator<String> it = list.listIterator();
it.forEachRemaining((String -> {
String s = it.next();
if(s.contains("a")) {
it.set("a");
}
}));
ListIterator<String> it1 = list.listIterator();
it1.forEachRemaining((String -> System.out.println(String)));
//重新获取迭代器对象it2
ListIterator<String> it2 = list.listIterator();
//遍历当前列表
it2.forEachRemaining((String -> {
//获取当前元素
String s = it2.next();
//如果元素包含"a"
if(s.contains("a")) {
//在它后面加上字符串"s"
it2.add("s");
}
}));
//重新获取迭代器对象it3
ListIterator<String> it3= list.listIterator();
//输出当前列表的所有元素。
it3.forEachRemaining((String -> System.out.println(String)));
}
}
结果示例：
最突出的特点是：每次都要重新获取迭代器对象。
PS：时间有限，有关Java SE的内容会持续更新！今天就先写这么多，如果有疑问或者有兴趣，可以加QQ：2649160693，并注明优快云，我会就博文中有疑义的问题做出解答。同时希望博文中不正确的地方各位加以指正。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
