遍历方式(迭代器，增强for，lambda表达式，普通for，列表迭代器)
迭代器
迭代器在Java中的类是Iterator，迭代器是集合专用的遍历方式
- Collection集合获取迭代器
方法名 说明
Iterator
- Iterator中的常用方法
方法名 说明
boolean hasNext() 判断当前位置是否有元素，有元素返回true，没有返回false
E next() 获取当前位置的元素，并将迭代器对象移向下一个位置
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo2 {
public static void main(String[] args) {
Collection<String> list=new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
Iterator<String> it=list.iterator();//创建指针
//
// while (it.hasNext()){ //判断是否有元素
// String str=it.next(); //获取元素并且移动指针
// System.out.println(str); //获取到的元素打印
// }
//细节注意
//1.报错NoSuchElementException（没有这个元素异常）
//2.迭代器遍历完毕，指针不会复位，指针会到最后没有元素的位置，如果想第二次遍历，就要再创建一个迭代器对象
//3.循环中只能使用一次next方法
//4.迭代器遍历的时候，不能用集合的方法进行增加或者删除，这里是因为迭代出来的元素会交给第三方变量管理，不会影响集合中的元素
//暂时作为结论，待会会通过源码进行分析
//如果实在要删除，只能使用迭代器为我们提供的remove()方法进行删除
//添加暂时没法实现
//演示4.
while (it.hasNext()){
String str=it.next();
if (str.equals("bbb")){
it.remove();
}
}
System.out.println(list);
}
}
- 小结
-
迭代器遍历的时候不依赖索引
-
迭代器需要掌握的三个方法
while (it.hasNext()){ //判断是否有元素 String str=it.next(); //获取元素并且移动指针 System.out.println(str); //获取到的元素打印 }
3.迭代器四个细节
1.报错NoSuchElementException（没有这个元素异常），这个出现在当前位置没有元素，还要强行获取的情况
2.迭代器遍历完毕，指针不会复位，指针会到最后没有元素的位置，如果想第二次遍历，就要再创建一个迭代器对象
3.循环中只能使用一次next方法
4.迭代器遍历的时候，不能用集合的方法进行增加或者删除，这里是因为迭代出来的元素会交给第三方变量管理，不会影响集合中的元
增强for及lambda表达式
增强for
- 增强for的底层就是迭代器，为了简化迭代器的代码书写的
- 他是JDK5之后出现的，其内部原理就是一个Iterator迭代器
- 所以的单列集合和数组才能用增强for进行遍历
格式：
for（元素的数据类型 变量名：数组或者集合）{
}
import java.util.ArrayList;
import java.util.Collection;
public class Demo3 {
public static void main(String[] args) {
// 格式：
//
//for（元素的数据类型 变量名：数组或者集合）{
//
//}
//1.创建集合并且添加元素
Collection<String> coll=new ArrayList<>();
coll.add("zhangsan");
coll.add("lisi");
coll.add("wangwu");
//s就是一个第三方变量，在循环的过程中依次表示集合中的每一个数据
//细节：修改增强for中的变量，不会改变集合中原本的数据
//原因就是因为数据是存储在第三方变量中的打印的也是第三方变量的值
for(String s:coll){
System.out.println(s);
}
}
}
lambda表达式
- 得益于JDK8开始的新技术lambda表达式，提供了一种更简单，更直接的遍历集合的方式。
import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;
public class Demo4 {
public static void main(String[] args) {
//lambda表达式遍历
// default void forEach(Consumer<? super T>action);
//1.创建集合添加元素
Collection<String> coll=new ArrayList<>();
coll.add("zhangsan");
coll.add("lisi");
coll.add("wangwu");
//2.没用lambda表达式之前，使用匿名内部类的方式
coll.forEach(new Consumer<String>() {
@Override
//s依次表示集合中的每一个数据
public void accept(String s) {
System.out.println(s);
}
});
//3.学了lambda表达式后
//（）->{}
coll.forEach((s)-> System.out.println(s));
}
}
小结：
- Collection是单列集合的顶层接口，所有方法被List和Set系列集合共享
- 常见成员方法：add，clear，remove，contains，isEmpty，size
- 三种通用的遍历方式
- 迭代器：在遍历的过程中需要删除元素，请使用迭代器
- 增强for，Lambda表达式：仅仅想遍历时候使用
List集合的特有方法
- Collection的方法都继承了
- List集合因为有索引，所以多了很多可以操作索引的方法
方法名 说明
void add(int index,E element) 在此集合中的指定位置插入指定的元素
E remove(int index) 删除指定索引处的元素，返回被删除的元素
E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
E get(int index) 返回指定索引处的元素
只演示删除元素的方法
import java.util.ArrayList;
import java.util.List;
public class Demo5 {
public static void main(String[] args) {
//List系列集合中的两个删除方法
//1.直接删除元素
//2.通过索引进行删除
//创建集合并添加元素
List<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
//删除元素
//请问：此时删除的是1这个元素还是，索引是1的元素?
//为什么
//因为在调用方法的时候，如果方法出现了重载现象
//优先调用，实际参数跟形参一样的那个方法
// list.remove(1);
// System.out.println(list);
Integer i=Integer.valueOf(1);
list.add(i);
System.out.println(list);
}
}
List系列集合的五种遍历方式
- 迭代器
- 增强for
- Lambda表达式
- 普通for
- 列表迭代器
列表迭代器还多了一些方法
hasPrevious()和previous()
这两种可以对比hasNext()和next()，前者是往前面移动指针，后者是往后面移动指针
演示
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class Demo6 {
public static void main(String[] args) {
/*1. 迭代器
2. 增强for
3. Lambda表达式
4. 普通for
5. 列表迭代器*/
//创建集合并且添加元素
List<String> list=new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
//1.迭代器
// Iterator<String> it=list.listIterator();
// while (it.hasNext()){
// String str=it.next();
// System.out.println(str);
// }
//2. 增强for
// for (String s : list) {
// System.out.println(s);
// }
//3.Lambda表达式
//forEach方法的底层其实就是一个循环遍历，依次的到每个集合中的每一个元素
//并且把每一个元素传递给下面的accept方法
//accept方法的形参s，依次表示集合中的每一个元素
// list.forEach(s-> System.out.println(s));
//4.普通for
// for (int i = 0; i < list.size(); i++) {
// System.out.println(list.get(i));
// }
//5.列表迭代器
//获取一个列表迭代器的对象，里面的指针默认也是指向0索引的
//额外添加了一个方法，就是可以遍历的过程中，可以添加元素
ListIterator<String> it=list.listIterator();
while (it.hasNext()){
String str=it.next();
if("bbb".equals(str)){
it.add("qqq");
}
}
System.out.println(list);
}
}
五种遍历方式对比
- 迭代器：在遍历过程中需要删除元素，使用迭代器
- 增强for：
- Lambda表达式：2和3使用仅仅只想遍历
- 普通for：如果遍历的时候想操作索引，使用普通for
- 列表迭代器：在遍历的过程中需要添加元素，使用列表迭代器
