文章目录
- 迭代器
- Iterator
- 1、什么是Iterator
- 2,iterator接口的API
- 3、Irerator()方法细节解释
- 4. Irerator的原理示意图
- 4. 1 Irerator的案例
- 5. forEach循环与Iterator遍历的区别与联系
- ListIterator
- 1.ListIterator的概述
- (1) 概念
- (2) 解析
- 2.ListIterator的生成
- 3.ListIterator的API
- 4.ListIterator的add方法解析
- 5.ListIterator与Iterator的区别
- java集合遍历
- 1. ArrayList的遍历方式
- 第一种,通过迭代器遍历。即通过Iterator去遍历。
- 第二种,随机访问index,通过索引值去遍历。
- 第三种,增强for循环遍历。如下:
- 第四种,forEach遍历。如下:
- 第五种,stream流式遍历
- 第六种,forEachRemaining方法遍历:继续输出其余的元素
- 2. LinkedList的遍历方式
- 第七种:通过pollFirst()来遍历LinkedList,获取并移除此列表的第一个元素;如果此列表为空,则返回 null
- 第八种:通过pollLast()来遍历LinkedList,获取并移除此列表的最后一个元素;如果此列表为空,则返回 null。
- 第九种:通过removeFirst()来遍历LinkedList,移除并返回此列表的第一个元素。 NoSuchElementException - 如果此列表为空。
- 第十种:通过removeLast()来遍历LinkedList,移除并返回此列表的最后一个元素。NoSuchElementException - 如果此列表为空。
- 3. Set集合的遍历方式
- 4. Map集合的遍历方式
- ①for-each + keySet()/values()遍历key/Value
- ②[重要]for-each + entrySet()遍历
- ③for-each + keySet() + get()方法遍历
- ④Iterator + entrySet()遍历
- ⑤[重要]lambda表达式遍历
- ⑥stream流遍历
- 总结——简洁又好用的遍历方式
迭代器
Iterator
1、什么是Iterator
迭代的概念: Collection集合元素的通用获取方式,再取元素之前要先判断集合中有没有元素,如果有,就把这个元素取出来,继续在进行判断,如果还有就再取出来,一直把集合中的所有元素取出,这种取出方式专业术语就叫做迭代
一些集合类提供了内容遍历的功能,通过java.util.Iterator接口。这些接口允许遍历对象的集合。依次操作每个元素对象。当使用 Iterators时,在获得Iterator的时候包含一个集合快照。通常在遍历一个Iterator的时候不建议修改集合本身。
2、Iterator与ListIterator有什么区别?
Iterator:只能正向遍历集合,适用于获取移除元素。ListIerator:继承Iterator,可以双向列表的遍历,同样支持元素的修改。
2,iterator接口的API
boolean hasNext() 如果仍有元素就可以迭代,返回的就是true,
判断集合中还有没有下一个元素,有就返回true,没有就返回false
E next() 返回迭代的下一个元素。
void remove() 从迭代器指向的集合中移除迭代器返回的最后一个元素(可选操作)。
Iterator也是一个接口,我们无法直接使用,需要使用Iterator接口的实现类。
在Collection接口中有一个方法,Iterator(),这个方法的返回值就是迭代器的实现类
3、Irerator()方法细节解释
Iterator iterator = col.iterator();//获取迭代器对象
hasNext(): 判断游标右边是否还有下一个元素,默认游标都在集合的第一个元素之前。
注意:此时只是判断是否有下一个元素,并不移动指针。
while(iterator.hasNext()){
//next():①指针下移 ②将下移以后集合位置上的元素返回
Object next = iterator.next();
System.out.println(“next=”+next);
}
迭代过程如图所示:
(1)、如果iterato.next()指向的内存中如果没有元素会抛出异常
(2)、当退出while后,iterator.hasNext()中next已经走到尾部,若继续调用iterator.hasNext()将会报错(若要继续遍历,可通过重置迭代器解决)
(3)、void remove()方法 :删除当前指针所指向的元素,一般和next方法一起用,这时候的作用就是删除next方法返回的元素,如果当前指针指向的内存中没有元素,那么会抛出异常
4. Irerator的原理示意图
4. 1 Irerator的案例
Collection coll = new ArrayList(); //面向对象中的多态coll.add(1);
coll.add("abc");
coll.add(1.23);
coll.add("张三");
for(Iterator it = coll.iterator();it.hasNext();){
Object obj = it.next();
System.out.println(obj);//输出1 abc 1.23 张三
}
Iterator it = coll.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);//输出结果;1 abc 1.23 张三
}
5. forEach循环与Iterator遍历的区别与联系
(1)使用范围不同
forEach: 不仅可以在集合中使用,也可以在数组中遍历使用
Iterator:专门为遍历集合而生,集合并没有提供专门的遍历的方法。在数组中不能遍历用
(2)遍历过程不同
iterator.remove() 删除当前遍历到的值
foreach遍历集合元素时不能调用remove删除元素,否则会出现ConcurrentModificationException
(3)增强的for循环和Iterator的联系
增强的for循环(遍历集合)时,底层使用的是Iterator
凡是可以使用增强的for循环(遍历的集合),肯定也可以使用Iterator进行遍历
ListIterator
1.ListIterator的概述
(1) 概念
官方文档说,此接口只是用于List的迭代器,通过它我们可以从任意方向遍历列表、在迭代期间修改列表、获取迭代器在列表中的当前位置。ListIterator没有当前元素(current element),它的光标总是处于调用previous()方法返回的元素和next()方法返回的元素之间。长度为n的列表,它的迭代器有n+1个光标位置
绿色代表ListIterator迭代器的位置,在ListItarator中迭代器的位置都是指的光标的位置。红色代表List列表中的元素,把这张图存脑袋里,把这张图存脑袋里,把这张图存脑袋里,这个接口的所有操作都没啥障碍了。
(2) 解析
在使用java集合的时候,都需要使用Iterator。但是java集合中还有一个迭代器ListIterator,在使用List、ArrayList、LinkedList和Vector的时候可以使用。这两种迭代器有什么区别呢?下面我们详细分析。这里有一点需要明确的时候,迭代器指向的位置是元素之前的位置,如下图所示:
这里假设集合List由四个元素List1、List2、List3和List4组成,当使用语句Iterator it = List.Iterator()时,迭代器it指向的位置是上图中Iterator1指向的位置,当执行语句it.next()之后,迭代器指向的位置后移到上图Iterator2所指向的位置。
2.ListIterator的生成
List<Integer> list =Arrays.asList(1,2,3,4);
ListIterator<Integer> it = list.listIterator(); 无参
ListIterator<Integer> it1 = list.listIterator(list.size()); 有参
3.ListIterator的API
add(E e):
将指定的元素插入列表,插入位置为迭代器当前位置之前
hasNext():
以正向遍历列表时,如果列表迭代器后面还有元素,则返回 true,否则返回false
hasPrevious():
如果以逆向遍历列表,列表迭代器前面还有元素,则返回 true,否则返回false
next():
返回列表中ListIterator指向位置后面的元素
nextIndex():
返回列表中ListIterator所需位置后面元素的索引
previous():
返回列表中ListIterator指向位置前面的元素
previousIndex():
返回列表中ListIterator所需位置前面元素的索引
remove():
从列表中删除最后一次执行next()或previous()方法返回的元素。(有点拗口,意思就是对迭代器使用hasNext()方法时,删除ListIterator指向位置后面的元素;当对迭代器使用hasPrevious()方法时,删除ListIterator指向位置前面的元素)
remove使用时注意三点:
1.调用remove()方法之前,一定要有next()或previous()方法执行,
否则报错:java.lang.IllegalStateException
2.执行next() 或 previous()之后与执行remove()之前,不能执行add(E)方法,
'否则报错: java.lang.IllegalStateException
3.就近原则。
set(E e):
从列表中将next()或previous()返回的最后一个元素返回的最后一个元素更改为指定元素e
在调用set(E)方法前,不能调用remove() 和 add(E) 方法
,否则会报错:java.lang.IllegalStateException。
4.ListIterator的add方法解析
void add ( E e ) 将指定元素插入到previous()返回的元素与当前光标位置之间。如何理解呢?上图:
就是说不仅将元素插入到e1和e2之间,也插入到了e1和cursor之间。
此时调用next()方法,仍然返回的是e2,调用previous()返回的就是新插入的元素了。
值得注意的是,当光标位置处于0(第一个元素左边)时,调用add(E)方法会出现异常,因为现在光标左边还没有元素呀
5.ListIterator与Iterator的区别
一.相同点
都是迭代器,都可以对集合中的元素进行遍历 。当需要对集合中元素进行遍历不需要干涉其遍历过程时,这两种迭代器都可以使用。
二.不同点
(1): 范围不同:Iterator可应用于Collection及其子类型所有的集合,
而ListIterator只能用于List及其子类型,如List、ArrayList、LinkedList和Vector等
(2): 遍历功能略微不同:Iterator和ListIterator都有hasNext()和next()方法,可以实现顺序向后遍历,
但是ListIterator有hasPrevious()和previous()方法,可以实现逆向(顺序向前)遍历。
Iterator则不可以逆向遍历。即 ListIterator 因为有hasPrevious()和previous()方法,所以可实现双向遍历,
而terator只能单向顺序向前遍历。
(3): Iterator在遍历过程中仅仅有一个remove移除元素的方法, 故Iterator在遍历过程中不能够往集合里新增、修改元素;
而ListIterator在遍历过程中有add()方法、remove方法、set方法,
可以在遍历过程中向List中添加/删除集合中的元素,或者修改集合元素。
(4): Iterator在遍历过程中不能定位到索引位置,
ListIterator可以定位当前的索引位置,nextIndex()和previousIndex()可以实现。
注意: map并没有实现Iterator,ListIterator接口,所以其不能使用这两种迭代器直接进行遍历
java集合遍历
1. ArrayList的遍历方式
第一种,通过迭代器遍历。即通过Iterator去遍历。
List<Integer> list =Arrays.asList(1,2,3,4);
Iterator<Integer> iter = list.iterator();
while (iter.hasNext()) {
Integer value = iter.next();
System.out.println("v..."+value);
}
或者通过for的方式
List<Integer> list =Arrays.asList(1,2,3,4);
for(Iterator iter = list.iterator(); iter.hasNext();){
Integer value = iter.next();
System.out.println("v..."+value);
}
第二种,随机访问index,通过索引值去遍历。
由于ArrayList实现了RandomAccess接口,它支持通过索引值去随机访问元素。
List<Integer> list =Arrays.asList(1,2,3,4);
for (int i=0; i<list.size(); i++) {
System.out.println("i= "+i+"....v..."+list.get(i));
}
第三种,增强for循环遍历。如下:
List<Integer> list =Arrays.asList(1,2,3,4);
for (Integer value : list) {
System.out.println("v..."+value);
}
第四种,forEach遍历。如下:
List<Integer> list =Arrays.asList(1,2,3,4);
list.forEach(v->System.out.println("v..."+value));
也可以简写为
list.forEach(System.out::println);
第五种,stream流式遍历
List<Integer> list =Arrays.asList(1,2,3,4);
list.stream.map(x->x++).collect(Collectors.toList());
或者
list.stream.forEach(v->System.out.println("v..."+value));
第六种,forEachRemaining方法遍历:继续输出其余的元素
由于某种原因导致遍历停止了,然后在通过foreachRemaing 遍历的时候,只会遍历剩余集合中还存在的元素。
ArrayList<Integer> arrayList=new ArrayList<>();
for (int i = 0; i <10; i++) {
arrayList.add(i);
}
System.out.println("迭代器第一次遍历");
Iterator<Integer> iterator=arrayList.iterator();
while(iterator.hasNext()){
int num=iterator.next();
System.out.print(num);
if(num==5){
break;
}
}
System.out.println("");
System.out.println("输出其余元素:");
iterator.forEachRemaining(new Consumer<Integer>() {
@Override
public void accept(Integer s) {
System.out.print(s);
}
});
遍历ArrayList时,使用随机访问(即,通过索引序号访问)效率最高,而使用迭代器的效率最低
2. LinkedList的遍历方式
由于LinkedList与ArrayList实现同一个接口List,故ArrayList的六种遍历方式对于LinkedList同样适用
,这里只对LinkedList的特有遍历方式做解释说明
数据准备:
List<Integer> list = new LinkedList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
知识回顾:
pollFirst():删除头;并且返回头,如果列表为空,则不会给出任何异常,并且返回null。 特有方法
pollLast():删除尾; 并且返回尾,如果列表为空,则不会给出任何异常,并且返回null。特有方法
removeFirst(E e):删除头,获取元素并删除,返回头;如果列表为空,抛出NoSuchElementException异常。 特有方法
removeLast(E e):删除尾;获取元素并删除,返回尾;如果列表为空,抛出NoSuchElementException异常。 特有方法
第七种:通过pollFirst()来遍历LinkedList,获取并移除此列表的第一个元素;如果此列表为空,则返回 null
while(list.pollFirst() != null){
}
第八种:通过pollLast()来遍历LinkedList,获取并移除此列表的最后一个元素;如果此列表为空,则返回 null。
while(list.pollLast() != null) {
}
第九种:通过removeFirst()来遍历LinkedList,移除并返回此列表的第一个元素。 NoSuchElementException - 如果此列表为空。
try {
while(list.removeFirst() != null) {
}
} catch (NoSuchElementException e) {
}
第十种:通过removeLast()来遍历LinkedList,移除并返回此列表的最后一个元素。NoSuchElementException - 如果此列表为空。
try {
while(list.removeLast() != null) {
}
} catch (NoSuchElementException e) {
}
注意:增强for循环(也称为for each循环)是jdk 1.5以后出来的一个高级的for循环,专们用来遍历数组,它的内部原理其实是Iterator迭代器
,所以在遍历的过程中,不能对集合进行增删
操作;Iterator迭代器遍历时可以做删除
3. Set集合的遍历方式
set集合支持的遍历方式同ArrayList集合的六种遍历方式
,这里就不在列举了,有疑问的看ArrayList集合的遍历方式
4. Map集合的遍历方式
①for-each + keySet()/values()遍历key/Value
for-each:一种遍历形式
可以遍历集合或者数组,实际上是迭代器遍历的简化写法,也称增强for循环。
each表示每个;for-each表示循环数组或集合中的对象、数据。
keySet()方法:拿到全部的Key
将Map中所有的键(Key)存入到Set集合中。
Key表示键值;Set表示Set集合。
values()方法:拿到全部的Value
返回一个新的Iterator(迭代器)对象,该对象包含Map中存在的每个元素的值(Value)。
vluees是值的复数形式,表示它有很多的值。
HashMap<String, Integer> map1 = new HashMap<>();
map1.put("小明", 1);
map1.put("小红", 2);
map1.put("小张", 3);
//for-each + keySet()遍历key
for (String key : map1.keySet()) { //遍历key
System.out.println("key = " + key);
}
//for-each + values()遍历value
for (Integer value : map1.values()) { //遍历value
System.out.println("value = " + value);
}
遍历结果:
key = 小明
key = 小红
key = 小张
value = 1
value = 2
value = 3
一次只能取出Key的值或者Value的值,这样显然是很不方便的。
②[重要]for-each + entrySet()遍历
Map.Entry是为了更方便的输出map键值对。一般情况下,想要输出Map中的key 和 value,就必须先得到key的集合keySet(),然后再循环每个key得到每个value。values()方法是获取集合中的所有值,不包含键,没有对应关系。而Entry可以一次性获得这两个值。
entrySet()方法:拿到全部的键值对
将Map中所有的键(Key)-值(Value)对存入到Set集合中,这个方法返回的是一个Set<Map.Entry<K,V>>。
entry表示条目、清单;Set表示Set集合。
entry里面的内容如下:
Key1, Value1
Key2, Value2
Key3, Value3
… , …
Key65535, Value65535
HashMap<String, Integer> map1 = new HashMap<>();
map1.put("小明", 1);
map1.put("小红", 2);
map1.put("小张", 3);
//for-each + entrySet()遍历
for (Map.Entry<String, Integer> entry : map1.entrySet()) {
System.out.print("key = " + entry.getKey());
System.out.println(", value = " + entry.getValue());
}
执行结果:
key = 小明, value = 1
key = 小红, value = 2
key = 小张, value = 3
Map.Entry是最常见也最常用的遍历Map的方式
③for-each + keySet() + get()方法遍历
get()方法:传入Key,返回对应的Value
将要返回的元素的键(Key)作为参数,找到并返回对应该键(Key)的值(Value)。
如果没有找到键(Key),返回undefined。
因为键(Key)是唯一的,所以不用担心找到第一个后第二个不输出的问题。
HashMap<String, Integer> map1 = new HashMap<>();
map1.put("小明", 1);
map1.put("小红", 2);
map1.put("小张", 3);
//for-each + keySet() + get()方法遍历
for (String key : map1.keySet()) {
Integer value = map1.get(key);
System.out.print("key = " + key);
System.out.println(", value = " + value);
}
执行结果:
key = 小明, value = 1
key = 小红, value = 2
key = 小张, value = 3
一般不推荐使用这种方法,因为多了一步根据key查找value的操作,效率会相对慢一些。写法和最开始的for-each遍历很相似,不同的是value使用了get()方法来获取。
map.get(key)方法的底层实现:
先调用Key的Hashcode方法得到哈希值,通过哈希算法得到对应的数组的下标,通过数组下标快速定位到某个位置上,如果这个位置上什么也没有,则返回null,如果这个位置上有单向链表,那么会拿着参数k和单项链表中的每个节点的k进行比较(equals()),如果所有的节点都返回false,那么最终该方法返回null,如果有一个节点的k和我们的k相匹配,那么该k节点所对应的value就是我们要找的value。
原文链接:https://blog.csdn.net/qq_51960163/article/details/117530311
④Iterator + entrySet()遍历
iterator() 方法:返回一个用于遍历当前集合的迭代器
HashMap<String, Integer> map1 = new HashMap<>();
map1.put("小明", 1);
map1.put("小红", 2);
map1.put("小张", 3);
//Iterator + entrySet()遍历
Iterator<Map.Entry<String, Integer>> iter = map1.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<String, Integer> entry = iter.next();
System.out.print("key = " + entry.getKey());
System.out.println(", value = " + entry.getValue());
}
执行结果:
key = 小明, value = 1
key = 小红, value = 2
key = 小张, value = 3
使用Iterator创建一个迭代器来遍历这个Map,和方法②类似,但区别在于:
for-each通常用于一次性遍历整个集合,大大提升了代码的简洁性和可阅读性,但期间无法控制遍历的过程。而Iterator通过hasNext(),next() 更好地控制便利过程的每一步。
for-each在遍历过程中严禁改变集合的长度,且无法对集合的删除或添加等操作。而Iterator可以在遍历过程中对集合元素进行删除操作。
但是在idea编译器中,编译器会给出警告,提示说该写法可以简化,简化后的写法和for-each + entrySet()方法遍历一致:
for (Map.Entry<String, Integer> entry : map1.entrySet()) {
System.out.print("key = " + entry.getKey());
System.out.println(", value = " + entry.getValue());
}
⑤[重要]lambda表达式遍历
forEach() 方法:遍历数组中每一个元素并执行特定操作
Lambda表达式:能够非常简练地表达特定的操作行为。在遍历集合中的元素时,如果对每个元素都执行同样的操作,也可以用Lambda表达式来指定对元素的操作行为,从而简化遍历访问集合的代码。
HashMap<String, Integer> map1 = new HashMap<>();
map1.put("小明", 1);
map1.put("小红", 2);
map1.put("小张", 3);
//lambda表达式遍历
map1.forEach((key, value) -> {
System.out.print("key = " + key);
System.out.println(", value = " + value);
});
执行结果:
key = 小明, value = 1
key = 小红, value = 2
key = 小张, value = 3
forEach方法遍历了map1,同时获取到key和value的值。美观,简洁,大气。
⑥stream流遍历
Stream流的作用:区别于IO流,用来对容器(集合,数组)操作进行书写简化,配合众多函数式接口以及lambda表达式,方法引用,集合的遍历,计数,过滤,映射,截取等操作变得异常优雅,上流。
HashMap<String, Integer> map1 = new HashMap<>();
map1.put("小明", 1);
map1.put("小红", 2);
map1.put("小张", 3);
//stream流遍历
map1.entrySet().stream().forEach((Map.Entry<String, Integer> entry) -> {
System.out.print("key = " + entry.getKey());
System.out.println(", value = " + entry.getValue());
});
执行结果:
key = 小明, value = 1
key = 小红, value = 2
key = 小张, value = 3
但是在idea编译器中,编译器会给出警告,提示说该写法可以简化,简化后的写法和lambda表达式一致:
map1.forEach((key, value) -> {
System.out.print("key = " + key);
System.out.println(", value = " + value);
});
总结——简洁又好用的遍历方式
①for-each + entrySet()遍历
HashMap<String, Integer> map1 = new HashMap<>();
map1.put("小明", 1);
map1.put("小红", 2);
map1.put("小张", 3);
//for-each + entrySet()遍历
for (Map.Entry<String, Integer> entry : map1.entrySet()) {
System.out.print("key = " + entry.getKey());
System.out.println(", value = " + entry.getValue());
}
②lambda表达式遍历
HashMap<String, Integer> map1 = new HashMap<>();
map1.put("小明", 1);
map1.put("小红", 2);
map1.put("小张", 3);
//lambda表达式遍历
map1.forEach((key, value)->{
System.out.print("key = " + key);
System.out.println(", value = " + value);
});
鸣谢:https://blog.csdn.net/qq_52430605/article/details/132159145