Java-集合（迭代器的使用与深入）

于 2024-06-01 23:32:30 发布
阅读量716 收藏 4
点赞数 24
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47234283/article/details/139381519
版权

迭代器

  1. 含义：遍历集合中的数据
  2. 分类：Iterator 和 ListIterator
  3. Iterator 和 ListIterator 区别
    Iterator ：Collection接口下所有的实现类都可以获取的迭代器，可以在遍历时删除元素
    ListIterator ：List接口下所有的实现类可以获取的迭代器，可以在遍历时删除、替换、添加元素，也可以指定下标开始遍历，还可以倒叙遍历
1 迭代器深入
1.1 深入迭代器-foreach
public class Test01 {
	/**
	 * 知识点：深入迭代器 -- foreach
	 */
	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<>();
		
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add("ddd");
		list.add("eee");
		
		for (String element : list) {
			System.out.println(element);
		}
		
		/**
		 * 使用foreach循环遍历集合的底层实现：
		 * 		String element;
				for(Iterator it = list.iterator();it.hasNext();System.out.println(element))
					element = (String) it.next();
		 */
	}
}
1.2 深入迭代器 – Iterator
1.2.1 需求：Iterator如何遍历元素
public class Test02 {
	/**
	 * 知识点：深入迭代器 -- Iterator
	 * 
	 * 深入：Iterator如何遍历元素
	 */
	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<>();
		
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add("ddd");
		list.add("eee");
		
		list.remove("bbb");
		
//		Iterator<String> it = list.iterator();
//		while(it.hasNext()){
//			String element = it.next();
//			System.out.println(element);
//		}
//		
		String element;
		for(Iterator<String> it = list.iterator();it.hasNext();System.out.println(element)){
			element = it.next();
		}
	}
}
1.2.2 使用Iterator遍历元素，遍历到"bbb"时删除该元素
public class Test03 {
	/**
	 * 知识点：深入迭代器 -- Iterator
	 * 
	 * 需求：使用Iterator遍历元素，遍历到"bbb"时删除该元素
	 */
	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<>();
		
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add("ddd");
		list.add("eee");
		//modCount - 5
		
		//expectedModCount - 5
		Iterator<String> it = list.iterator();
		
		while(it.hasNext()){
				
			String element = it.next();
			if(element.equals("bbb")){
				//list.remove(element);//modCount - 6
				it.remove();
			}
		}	
		for (String element : list) {
			System.out.println(element);
		}	
	}
}
1.3 深入迭代器 – ListIterator
1.3.1 使用ListIterator遍历元素
public class Test04 {
	/**
	 * 知识点：深入迭代器 -- ListIterator
	 * 
	 * 需求：使用ListIterator遍历元素
	 */
	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<>();
		
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add("ddd");
		list.add("eee");
		
		ListIterator<String> listIterator = list.listIterator();
		while(listIterator.hasNext()){
			String element = listIterator.next();
			System.out.println(element);
		}
	}
}
1.3.2 需求：使用ListIterator遍历元素，遍历到"bbb"时删除
public class Test05 {
	/**
	 * 知识点：深入迭代器 -- ListIterator
	 * 
	 * 需求：使用ListIterator遍历元素，遍历到"bbb"时删除
	 */
	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<>();
		
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add("ddd");
		list.add("eee");
		
		ListIterator<String> listIterator = list.listIterator();
		while(listIterator.hasNext()){
			String element = listIterator.next();
			if(element.equals("bbb")){
				listIterator.remove();
			}
		}
		
		for (String element : list) {
			System.out.println(element);
		}
	}
}
1.3.3 需求：使用ListIterator遍历元素，遍历到"bbb"时添加"xyz"
public class Test06 {
	/**
	 * 知识点：深入迭代器 -- ListIterator
	 * 
	 * 需求：使用ListIterator遍历元素，遍历到"bbb"时添加"xyz"
	 */
	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<>();
		
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add("ddd");
		list.add("eee");
		
		ListIterator<String> listIterator = list.listIterator();
		while(listIterator.hasNext()){
			String element = listIterator.next();
			if(element.equals("bbb")){
				listIterator.add("xyz");
			}
		}
		
		for (String element : list) {
			System.out.println(element);
		}
	}
}
1.3.4 需求：使用ListIterator遍历元素，遍历到"bbb"时替换成"xyz"
public class Test07 {
	/**
	 * 知识点：深入迭代器 -- ListIterator
	 * 
	 * 需求：使用ListIterator遍历元素，遍历到"bbb"时替换成"xyz"
	 */
	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<>();
		
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add("ddd");
		list.add("eee");
		
		ListIterator<String> listIterator = list.listIterator();
		while(listIterator.hasNext()){
			String element = listIterator.next();
			if(element.equals("bbb")){
				listIterator.set("xyz");
			}
		}
		
		for (String element : list) {
			System.out.println(element);
		}
	}
}
1.3.5 需求：使用ListIterator指定下标遍历元素
public class Test08 {
	/**
	 * 知识点：深入迭代器 -- ListIterator
	 * 
	 * 需求：使用ListIterator指定下标遍历元素
	 */
	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<>();
		
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add("ddd");
		list.add("eee");
		
		ListIterator<String> listIterator = list.listIterator(1);
		while(listIterator.hasNext()){
			String element = listIterator.next();
			System.out.println(element);
		}
	}
}
1.3.6 需求：使用ListIterator倒序遍历元素
package com.qf.iterator01;

import java.util.ArrayList;
import java.util.ListIterator;

public class Test09 {
	/**
	 * 知识点：深入迭代器 -- ListIterator
	 * 
	 * 需求：使用ListIterator倒序遍历元素
	 */
	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<>();
		
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add("ddd");
		list.add("eee");
		
		ListIterator<String> listIterator = list.listIterator(list.size());
		while(listIterator.hasPrevious()){
			String element = listIterator.previous();
			System.out.println(element);
		}
	}
}
2.迭代器底层

码源场景：
(注意：看源码找场景)

ArrayList<String> list = new ArrayList<>();
		
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("eee");

list.remove("bbb");

Iterator<String> it = list.iterator();
while(it.hasNext()){
    String element = it.next();
    System.out.println(element);
}

/**
* Iterator用于遍历Collection下的集合，Collection下的每个集合底层实现不一样，意味着遍历逻辑也不一样，
* 所以Java的设计者将Iterator设计成了接口，让Collection下的每个集合实现Iterator
*/
public interface Iterator<E> {
    //判断是否有可迭代的元素
    boolean hasNext();

   	//返回下一个元素
    E next();

    //删除（默认方法） -- 报错
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
}

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
	//外部操作数（记录集合添加、删除的次数）
	protected transient int modCount = 0;//6
}

public class ArrayList<E> extends AbstractList<E> implements List<E>{
	
    //数据容器 - ["aaa","ccc","ddd","eee",null,null,null,null,null,null]
    transient Object[] elementData;
    //数据个数（指针）
    private int size;//4

    //e - "eee"
	public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 判断是否扩容
        elementData[size++] = e;
        return true;
    }
    
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }
    
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    //o - "bbb"
    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            //线性查询（从头遍历到size的位置）
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    //删除元素（传入下标）
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }
    
    //index - 1
    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;//计算移动次数（移动长度）
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index, numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }
    
    public Iterator<E> iterator() {
        return new Itr();
    }
    
    //Itr是成员内部类，因为Itr中使用到了外部类(ArrayList)的成员属性（modCount、size）
    private class Itr implements Iterator<E> {
        int cursor;       // 游标 - 4
        int lastRet = -1; // 当前元素的下标 - 3
        int expectedModCount = modCount;//内部操作数 - 6

        public boolean hasNext() {
            return cursor != size;//4 != 4
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();//判断外部操作数和内部操作数是否相同
            int i = cursor;//i = 3
            if (i >= size)
                throw new NoSuchElementException();
            //elementData - ["aaa","ccc","ddd","eee",null,null,null,null,null,null]
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;//cursor - 4
            return (E) elementData[lastRet = i];
        }
        
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();//判断外部操作数和内部操作数是否相同

            try {
                //Itr依赖于ArrayList对象的remove()去删除元素
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                
                //重新将外部操作数赋值给内部操作数，保证内外部操作数一致不会出现脏数据
                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();
        }
  
    }
}
可可西不理
关注
Java中迭代器的使用方法是什么？
破损的天堂鸟博客
08-15 940
在Java中实现自定义迭代器，首先需要理解迭代器接口（Iterator）和可迭代接口（Iterable）。实现迭代器接口：创建一个类并实现Iterator接口。hasNext()next()remove()和。这些方法分别用于检查集合中是否有更多元素、获取下一个元素、移除当前元素以及遍历集合中的所有元素。实现可迭代接口：创建一个类并实现Iterable接口。这个接口要求实现一个名为iterator()的方法，该方法返回一个Iterator实例。使用自定义迭代器：在你的类中，你可以通过调用。
Iterator底层源码分析
最新发布
lv785的博客
05-15 440
【代码】Iterator底层源码分析。
集合中的迭代器
qq_38844728的博客
04-12 664
一.源码 public interface Iterator<E> { boolean hasNext(); E next(); default void remove() { throw new UnsupportedOperationException("remove"); } default void forEachRema...
集合里边迭代器的使用
qq_41876182的博客
07-05 253
1.集合里边迭代器（iterator）的使用 使用集合中的方法类iterator（）获取迭代器的实现类对象，使用iterator接口接发。 使用iterator接口的方法hasNext判断集合里边是否有下一个元素。 使用iterator接口中的next方法来取出集合的下一个元素。 public static void main(String[] args) { //创建集合对象 ArrayList<String> coll = new ArrayList&lt
集合之迭代器介绍和使用
hello_word_demo1的博客
03-15 1007
迭代器（集合遍历） 1.引入：普通的for遍历 List<String> list = new ArrayList<>(); for ( int i = 0; i < list.size(); i++ ) { System.out.println(list.get(i)); } 2.使用迭代器遍历 Iterator<String> iterator = list.iterator(); while (iterator.hasNext()) { String s
java基础 集合-22-迭代器设计模式
09-25
本文将深入探讨Java中的迭代器模式及其在集合框架中的应用。 迭代器模式是一种行为设计模式，它提供了一种方法来顺序访问聚合对象的元素，而不暴露其底层表示。在Java中，迭代器模式广泛用于遍历集合类，如...
设计模式--迭代器模式java例子
02-12
本示例将深入探讨如何在Java中实现和使用迭代器模式。 首先，我们需要理解迭代器模式中的几个关键角色： 1. **聚合类（Aggregate）**：它定义了存储、添加和删除元素的接口，通常是一个集合。在Java中，这些接口...
java集合迭代器Iterator中的remove陷阱
09-02
总结，理解和正确使用`Iterator`的`remove()`方法是Java集合操作的关键，特别是考虑到不同集合类型的行为差异。在遍历集合并删除元素时，务必确保在正确的时间点调用`remove()`，并根据集合类型选择合适的删除策略。...
详解Java中Iterator迭代器的用法
09-01
`Iterator`是Java集合框架的核心组成部分，它提供了一种灵活且安全的方式来遍历和修改集合中的元素。无论是在基本的集合操作还是在复杂的业务逻辑中，`Iterator`都扮演着至关重要的角色。理解并熟练运用`Iterator`，...
iterator-demo 迭代器设计模式demo
03-16
- 在Java中，`java.util.Iterator`接口和`java.util.ArrayList`、`java.util.LinkedList`等集合类提供了对迭代器模式的支持。通过调用`iterator()`方法，我们可以获取一个迭代器实例，然后使用`hasNext()`和`next()...
java中迭代器的使用
Dustmicro的博客
08-04 2012
迭代器 java中迭代器的作用就是循环的代换 *****遍历列表读取数据***** 两种遍历用法： //for循环遍历 for(iterator<类型名> 迭代器名 = 列表名.iterator();迭代器名.hasNext();）{ System.out.println(迭代器名.next()); } //while循环遍历 iterator<类型名>迭代器名 = 列表名.iterator(); while(迭代器名.hasNext()){ System.out.printl
Java中迭代器的使用
热门推荐
Korbin的博客
03-03 2万+
迭代器 1.概述： 帮助我们做集合遍历的工具。 2.作用： java中提供了很多种集合，它们在存储元素时，采用的存储方式不同。所以当我们要取出这些集合中的元素时，可以通过一种通用的获取方式来完成。 Collection集合元素的通用获取方式： 在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来；继续再判断，如果还有就再取出来。一直到把集合中的所有元素全部取出。这种取出方式专业术...
集合迭代器的使用
qq_1689651368的博客
07-26 365
//导入ArrayList和迭代器Iterator的包 import java.util.ArrayList; import java.util.Iterator; public class MyDemo { public static void main(String[] args) { //创建一个list集合 ArrayList list = new ArrayL
Java集合中使用迭代器
CodeCat
08-07 642
1、什么是迭代器 迭代器实际上是一种设计模式，廖老师的博客是这样解释的： 提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。 在java的集合中广泛的使用迭代器。 2、为什么要用迭代器 使用迭代器的好处是可以在不需要了解集合内部的实现过程的情况下实现对集合的遍历；另一方面，具体来看如果使用索引的方式遍历LinkedList会效率很低，set集合则无法使用索引，所以综合来看，最好是使用迭代器来遍历集合 3、怎么用迭代器 集合提供了获取迭代器的方法: 基本使用： public s
Java 基础之迭代器的使用
玖涯博客
12-06 5777
迭代器是一种设计模式，迭代器可以用于遍历集合，开发人员不必去了解这个集合的底层结构。迭代器封装了数据获取和预处理逻辑，屏蔽了容器的实现细节，无需暴露数据结构内部。在数据量非常庞大时使用迭代器进行数据迭代获取，避免全部取出占用过多的服务器资源，且可以对部分数据进行预加载，提升性能。本文将对 java 提供的 Iterator、Iterable 和 Spliterator 三个数据迭代接口做介绍，了解其使用场景。
Java中的迭代器用用法
沈行的博客
08-28 664
迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。 　　Java中的Iterator功能比较简单，并且只能单向移动： 　　(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterat
Iterator 源码
我的博客简介
12-16 1022
Iterator 源码 class Iterator { constructor(assemble) { let self = this; self.assemble = assemble; self.index = 0; } next() { let self = this; let assemble = self.assemble; if (self.index > assemb
Iterator源码
m0_52346373的博客
05-22 85
Iterator是一个接口，他的实现类都会在类的内部定义一个iterator方法类 public Iterator<E> iterator() { return new Itr(); } 可以看到方法中创建了一个Itr对象，Itr是一个内部类，可以方便的访问外部类中的成员。提供更小的封装性。 private class Itr implements Iterator<E> { int cursor; // index of nex
Java list迭代器
11-09
Java中的List是一种有序的集合，它允许我们在列表中添加或删除元素，并且可以通过索引访问列表中的元素。Java List迭代器是一种用于遍历List集合的接口，它提供了一种在不知道List大小的情况下遍历List的方法。List迭代器可以在List中向前或向后遍历，并且可以在遍历过程中修改List中的元素。在Java中，List迭代器是通过List接口的listIterator()方法获得的。List迭代器有两种遍历方式：迭代器遍历和普通for循环遍历。 迭代器遍历代码如下： ```java //迭代器遍历：集合特有的遍历方式 Iterator<Student> it = list.iterator(); while(it.hasNext()){ Student s = it.next(); System.out.println(s.getName()+" : "+s.getAge()); } ``` 普通for循环遍历代码如下： ```java //普通for循环：带有索引的方式遍历 for(int i=0;i<list.size();i++){ Student s = list.get(i); System.out.println(s.getName()+" : "+s.getAge()); } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值