21 迭代器(Iterator)详解

已于 2025-03-13 10:26:04 修改
阅读量186 收藏
点赞数 2
CC 4.0 BY-SA版权
分类专栏： Python基础 文章标签： python 开发语言 迭代器
于 2025-03-13 10:15:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dchlove/article/details/146223864

1、定义：

python Iterator（迭代器）是一个可以记住遍历位置的对象。它从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器有两个基本方法：__iter__()和__next__()。

  • __iter__() 方法返回迭代器对象本身。这是为了使迭代器对象能够与for循环等使用迭代协议的代码兼容。
  • __next__() 方法返回容器中的下一个值。如果没有更多的元素可供返回，则会触发 StopIteration 异常来通知调用者。

2、迭代器的工作原理

当你使用一个循环如for循环去遍历时，背后实际上是在重复调用迭代器的__next__()方法，并且在捕获到StopIteration异常时自动停止循环。这种机制使得我们可以高效地遍历大型数据集，而不需要一次性将所有数据加载进内存。

3、快速掌握迭代器的要点

1、基本概念：

  • 迭代器是实现了__iter__和__next__方法的对象
  • 迭代器一次只处理一个元素，节省内存
  • 迭代器只能向前移动，不能回退

2、创建方式：

  • 使用iter()函数从可迭代对象获取迭代器
  • 创建自定义类实现迭代器协议
  • 使用生成器函数（带yield）创建迭代器

3、常用工具：

  • itertools模块提供了强大的迭代器工具
  • 无限迭代器：count, cycle, repeat
  • 组合迭代器：chain, zip_longest
  • 过滤和映射：filter, map

4、实际应用：

  • 数据处理管道
  • 大数据集处理
  • 日期范围生成

示例代码：

"""
Python迭代器(Iterator)详解

迭代器是Python中一个重要的概念，它提供了一种访问集合元素的方式，而不需要暴露集合的内部结构。
迭代器对象实现了__iter__()和__next__()两个方法（迭代器协议）。

迭代器的核心优势:
1. 内存效率高 - 一次只在内存中保存一个元素
2. 惰性计算 - 只在需要时才计算下一个值
3. 可以表示无限序列 - 不需要预先计算所有值
4. 组合性强 - 可以构建复杂的数据处理管道

"""

# 第一部分：迭代器基础概念
print("=" * 50)
print("第一部分：迭代器基础概念")
print("=" * 50)

# 1.1 可迭代对象(Iterable)与迭代器(Iterator)的区别
print("\n1.1 可迭代对象与迭代器的区别:")
print("可迭代对象: 实现了__iter__()方法，可以返回迭代器")
print("迭代器: 实现了__iter__()和__next__()方法，可以逐个返回元素")
# 补充说明：for循环可以遍历任何可迭代对象，它会自动调用iter()获取迭代器，然后重复调用next()

# 1.2 内置可迭代对象示例
print("\n1.2 内置可迭代对象示例:")
# 使用dir()函数检查对象是否包含__iter__方法，从而判断是否可迭代
print(f"列表是可迭代的: {'__iter__' in dir([])}")  # 列表是最常见的可迭代对象
print(f"字典是可迭代的: {'__iter__' in dir({})}")  # 字典默认迭代键
print(f"集合是可迭代的: {'__iter__' in dir(set())}")  # 集合中的元素无序且唯一
print(f"元组是可迭代的: {'__iter__' in dir(())}")  # 元组是不可变的序列
print(f"字符串是可迭代的: {'__iter__' in dir('')}")  # 字符串可以按字符迭代

# 1.3 获取迭代器并使用
print("\n1.3 获取迭代器并使用:")
my_list = [1, 2, 3, 4, 5]
# 获取迭代器 - iter()函数是获取迭代器的标准方式
iterator = iter(my_list)  # 等同于 my_list.__iter__()
print(f"迭代器类型: {type(iterator)}")  # 显示迭代器的实际类型

# 使用next()获取下一个元素 - next()是从迭代器获取值的标准方式
print(f"第一个元素: {next(iterator)}")  # 等同于 iterator.__next__()
print(f"第二个元素: {next(iterator)}")  # 每次调用next()都会返回下一个元素
print(f"第三个元素: {next(iterator)}")  # 并且迭代器会记住当前位置

# 迭代器用尽后会抛出StopIteration异常 - 这是Python标准的迭代结束信号
print("\n迭代器耗尽示例:")
try:
    # 继续获取剩余元素
    print(f"第四个元素: {next(iterator)}")  # 正常获取第四个元素
    print(f"第五个元素: {next(iterator)}")  # 正常获取第五个元素
    # 超出范围 - 列表只有5个元素，所以第六次调用next()会抛出异常
    print(next(iterator))
except StopIteration:
    print("迭代器已耗尽，抛出StopIteration异常")  # for循环会自动处理这个异常并停止迭代


# 第二部分：创建自定义迭代器
print("\n" + "=" * 50)
print("第二部分：创建自定义迭代器")
print("=" * 50)
# 自定义迭代器需要实现迭代器协议：__iter__()和__next__()方法

# 2.1 基本迭代器类
print("\n2.1 基本迭代器类:")


class CountDown:
    """一个简单的倒计时迭代器

    这个类演示了如何创建一个基本的迭代器，从指定数字倒数到1
    """

    def __init__(self, start):
        """初始化倒计时的起始值

        参数:
            start: 倒计时的起始数字
        """
        self.start = start  # 保存初始值，这将是我们开始倒数的数字

    def __iter__(self):
        """返回迭代器对象自身

        这个方法使对象可迭代。在迭代器类中，它应该返回self。
        当使用for循环时，Python会自动调用这个方法获取迭代器。
        """
        # 迭代器必须返回自身，这样才能在for循环中使用
        return self

    def __next__(self):
        """返回下一个值或抛出StopIteration异常

        这个方法定义了如何获取序列中的下一个值。
        当没有更多值可返回时，应该抛出StopIteration异常。
        """
        if self.start <= 0:
            # 当没有更多元素时抛出异常，这会通知for循环停止迭代
            raise StopIteration

        # 保存当前值，因为我们要在返回前修改self.start
        current = self.start
        # 更新状态，为下次迭代做准备
        self.start -= 1
        # 返回当前值
        return current


# 使用自定义迭代器
countdown = CountDown(5)  # 创建一个从5倒数的迭代器
print("倒计时:")
for num in countdown:  # for循环会自动调用__iter__()和__next__()
    print(num, end=" ")  # 输出: 5 4 3 2 1
print("\n")

# 2.2 斐波那契数列迭代器
print("2.2 斐波那契数列迭代器:")


class Fibonacci:
    """生成斐波那契数列的迭代器

    斐波那契数列：每个数是前两个数的和，从0和1开始
    例如：0, 1, 1, 2, 3, 5, 8, 13, ...
    """

    def __init__(self, limit):
        """初始化，设置上限

        参数:
            limit: 要生成的斐波那契数的数量
        """
        self.limit = limit  # 限制生成的数量
        self.a, self.b = 0, 1  # 初始化前两个数
        self.count = 0  # 计数器，跟踪已生成的数量

    def __iter__(self):
        """返回迭代器自身"""
        return self  # 同样，迭代器的__iter__方法返回self

    def __next__(self):
        """返回下一个斐波那契数"""
        if self.count >= self.limit:
            # 达到限制数量时停止迭代
            raise StopIteration

        # 保存当前值(a)作为结果
        result = self.a
        # 更新状态：a变为b，b变为a+b（斐波那契数列的核心逻辑）
        self.a, self.b = self.b, self.a + self.b
        self.count += 1  # 增加计数器

        return result  # 返回当前的斐波那契数


# 使用斐波那契迭代器
fib = Fibonacci(10)  # 创建一个生成10个斐波那契数的迭代器
print("斐波那契数列前10项:")
for num in fib:  # 自动迭代
    print(num, end=" ")  # 输出: 0 1 1 2 3 5 8 13 21 34
print("\n")


# 第三部分：迭代器的高级用法
print("=" * 50)
print("第三部分：迭代器的高级用法")
print("=" * 50)
# Python的itertools模块提供了许多强大的迭代器工具

# 3.1 无限迭代器
print("\n3.1 无限迭代器:")
import itertools  # 导入itertools模块，它包含许多有用的迭代器函数

# count: 从n开始无限计数 - 创建一个永不停止的计数器
counter = itertools.count(10, 2)  # 从10开始，步长为2：10, 12, 14, 16, ...
print("itertools.count示例(从10开始，步长为2):")
for i, num in enumerate(counter):  # enumerate返回索引和值的元组
    if i >= 5:  # 只显示前5个，否则会无限循环
        break
    print(num, end=" ")  # 输出: 10 12 14 16 18
print()

# cycle: 无限循环迭代元素 - 循环遍历一个序列，到末尾后重新开始
cycler = itertools.cycle(["A", "B", "C"])  # 无限循环A, B, C, A, B, C, ...
print("itertools.cycle示例(循环ABC):")
for i, char in enumerate(cycler):
    if i >= 6:  # 只显示前6个，否则会无限循环
        break
    print(char, end=" ")  # 输出: A B C A B C
print()

# repeat: 重复元素n次或无限次 - 简单地重复同一个值
repeater = itertools.repeat("Python", 3)  # 重复"Python"三次
print("itertools.repeat示例(重复Python 3次):")
for item in repeater:  # 这个迭代器会自动在3次后停止
    print(item, end=" ")  # 输出: Python Python Python
print("\n")

# 3.2 组合迭代器
print("3.2 组合迭代器:")

# chain: 连接多个迭代器 - 将多个迭代器首尾相连
print("itertools.chain示例(连接多个迭代器):")
# 连接三个不同类型的可迭代对象
combined = itertools.chain([1, 2], ["a", "b"], (True, False))
for item in combined:
    print(item, end=" ")  # 输出: 1 2 a b True False
print()

# zip_longest: 合并迭代器，可处理不等长情况
# 与内置zip不同，zip_longest会继续迭代到最长的迭代器结束
print("itertools.zip_longest示例(合并不等长迭代器):")
for item in itertools.zip_longest([1, 2], [3, 4, 5, 6], fillvalue="N/A"):
    # fillvalue指定短序列的填充值
    print(item)  # 输出: (1, 3), (2, 4), ('N/A', 5), ('N/A', 6)

# 3.3 过滤和映射
print("\n3.3 过滤和映射:")

# filter: 过滤元素 - 只保留满足条件的元素
print("filter示例(过滤偶数):")
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# lambda x: x % 2 == 0 是一个匿名函数，检查x是否为偶数
even_numbers = filter(lambda x: x % 2 == 0, numbers)
for num in even_numbers:
    print(num, end=" ")  # 输出: 2 4 6 8 10
print()

# map: 映射转换 - 对每个元素应用函数
print("map示例(平方运算):")
# lambda x: x**2 是一个匿名函数，计算x的平方
squared = map(lambda x: x**2, numbers)
for num in squared:
    print(num, end=" ")  # 输出: 1 4 9 16 25 36 49 64 81 100
print("\n")

# 3.4 排列组合迭代器
print("3.4 排列组合迭代器:")

# combinations: 返回指定长度的所有组合（不考虑顺序）
print("itertools.combinations示例(3选2组合):")
# 从[1,2,3]中选择2个元素的所有可能组合
for combo in itertools.combinations([1, 2, 3], 2):
    print(combo, end=" ")  # 输出: (1, 2) (1, 3) (2, 3)
print()

# permutations: 返回指定长度的所有排列（考虑顺序）
print("itertools.permutations示例(3选2排列):")
# 从[1,2,3]中选择2个元素的所有可能排列
for perm in itertools.permutations([1, 2, 3], 2):
    print(perm, end=" ")  # 输出: (1, 2) (1, 3) (2, 1) (2, 3) (3, 1) (3, 2)
print()

# product: 返回多个可迭代对象的笛卡尔积
print("itertools.product示例(笛卡尔积):")
# 计算"AB"和[1,2]的笛卡尔积（所有可能的组合）
for prod in itertools.product("AB", [1, 2]):
    print(prod, end=" ")  # 输出: ('A', 1) ('A', 2) ('B', 1) ('B', 2)
print("\n")


# 第四部分：迭代器与生成器的关系
print("=" * 50)
print("第四部分：迭代器与生成器的关系")
print("=" * 50)

print("\n生成器是一种特殊的迭代器，使用yield语句简化迭代器的创建")
print("生成器函数示例(等价于上面的Fibonacci类):")


def fibonacci_generator(limit):
    """使用生成器函数创建斐波那契数列

    这个函数使用yield语句，比上面的类实现更简洁
    yield会暂停函数执行并返回一个值，下次调用时从暂停处继续
    """
    a, b = 0, 1  # 初始化前两个数
    count = 0  # 计数器

    while count < limit:
        yield a  # yield暂停执行并返回值，保存当前状态
        a, b = b, a + b  # 更新状态
        count += 1  # 增加计数器


# 使用生成器
print("使用生成器的斐波那契数列:")
# 生成器函数调用时返回一个生成器对象，它是一个迭代器
for num in fibonacci_generator(10):  # 自动迭代
    print(num, end=" ")  # 输出: 0 1 1 2 3 5 8 13 21 34
print("\n")


# 第五部分：迭代器的实际应用
print("=" * 50)
print("第五部分：迭代器的实际应用")
print("=" * 50)

# 5.1 数据处理管道
print("\n5.1 数据处理管道:")
# 数据处理管道是迭代器的一个重要应用，可以分阶段处理数据


def data_source():
    """数据源 - 生成初始数据"""
    for i in range(1, 11):  # 生成1到10的数字
        yield i  # 一次返回一个数字


def process_data(data_iterator):
    """处理数据 - 对数据进行转换"""
    for item in data_iterator:  # 接收一个迭代器作为输入
        yield item * 10  # 将每个数字乘以10


def filter_data(data_iterator):
    """过滤数据 - 只保留符合条件的数据"""
    for item in data_iterator:  # 接收一个迭代器作为输入
        if item > 50:  # 只保留大于50的数字
            yield item  # 返回符合条件的数字


# 构建数据处理管道 - 将多个处理步骤连接起来
source = data_source()  # 创建数据源
processed = process_data(source)  # 处理数据
filtered = filter_data(processed)  # 过滤数据

print("数据处理管道结果:")
for result in filtered:  # 迭代最终结果
    print(result, end=" ")  # 输出: 60 70 80 90 100
print("\n")

# 5.2 内存高效的数据处理
print("5.2 内存高效的数据处理:")


def process_large_dataset(data):
    """处理大型数据集的示例

    这个函数展示了如何使用迭代器处理大型数据集，
    而不需要一次性将所有数据加载到内存中。
    """
    # 假设这是一个非常大的数据集
    # 使用迭代器可以一次只处理一个元素，不必全部加载到内存

    # 1. 过滤数据 - 只保留正数
    filtered_data = filter(lambda x: x > 0, data)

    # 2. 转换数据 - 将每个数字乘以2
    transformed_data = map(lambda x: x * 2, filtered_data)

    # 3. 限制结果数量 - 只取前5个结果
    limited_data = itertools.islice(transformed_data, 5)

    return limited_data  # 返回处理后的迭代器


# 模拟大数据集
sample_data = [-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
results = process_large_dataset(sample_data)

print("大数据处理结果:")
for result in results:  # 迭代处理结果
    print(result, end=" ")  # 输出: 2 4 6 8 10
print("\n")

# 5.3 自定义迭代器实际应用
print("5.3 自定义迭代器实际应用:")


class DateRange:
    """日期范围迭代器

    这个迭代器生成两个日期之间的所有日期。
    它展示了如何创建一个实用的自定义迭代器。
    """

    from datetime import datetime, timedelta

    def __init__(self, start_date, end_date):
        """初始化日期范围

        参数:
            start_date: 开始日期
            end_date: 结束日期
        """
        self.start_date = start_date  # 保存开始日期
        self.end_date = end_date  # 保存结束日期
        self.current_date = start_date  # 当前日期，初始为开始日期

    def __iter__(self):
        """返回迭代器自身"""
        self.current_date = self.start_date  # 重置当前日期
        return self

    def __next__(self):
        """返回下一个日期"""
        if self.current_date > self.end_date:
            # 如果当前日期超过结束日期，停止迭代
            raise StopIteration

        today = self.current_date  # 保存当前日期
        self.current_date += self.timedelta(days=1)  # 增加一天
        return today.strftime("%Y-%m-%d")  # 返回格式化的日期字符串


# 使用日期范围迭代器
from datetime import datetime, timedelta

start = datetime(2023, 1, 1)  # 开始日期：2023年1月1日
end = datetime(2023, 1, 5)  # 结束日期：2023年1月5日
date_range = DateRange(start, end)  # 创建日期范围迭代器

print("日期范围:")
for date in date_range:  # 迭代日期范围
    print(date)  # 输出每一天的日期


# 总结
print("\n" + "=" * 50)
print("迭代器总结")
print("=" * 50)

print(
    """
1. 迭代器核心特点:
   - 实现了__iter__()和__next__()方法
   - 惰性计算，按需生成数据
   - 只能向前迭代，不能回退
   - 迭代完成后抛出StopIteration异常

2. 迭代器的优势:
   - 内存效率高，适合处理大数据集
   - 支持无限序列
   - 可组合构建数据处理管道
   - 延迟计算，提高性能

3. 常用迭代器工具:
   - 内置函数: iter(), next()
   - itertools模块: count(), cycle(), chain()等
   - 函数式工具: map(), filter()

4. 最佳实践:
   - 使用生成器简化迭代器创建
   - 组合使用itertools提高效率
   - 构建处理管道提高代码可读性
   - 利用迭代器协议实现自定义集合类
"""
)

print("\n迭代器是Python中非常强大的工具，掌握它可以编写更高效、更优雅的代码！")


打印结果

==================================================
第一部分：迭代器基础概念
==================================================

1.1 可迭代对象与迭代器的区别:
可迭代对象: 实现了__iter__()方法，可以返回迭代器
迭代器: 实现了__iter__()和__next__()方法，可以逐个返回元素

1.2 内置可迭代对象示例:
列表是可迭代的: True
字典是可迭代的: True
集合是可迭代的: True
元组是可迭代的: True
字符串是可迭代的: True

1.3 获取迭代器并使用:
迭代器类型: <class 'list_iterator'>
第一个元素: 1
第二个元素: 2
第三个元素: 3

迭代器耗尽示例:
第四个元素: 4
第五个元素: 5
迭代器已耗尽，抛出StopIteration异常

==================================================
第二部分：创建自定义迭代器
==================================================

2.1 基本迭代器类:
倒计时:
5 4 3 2 1 

2.2 斐波那契数列迭代器:
斐波那契数列前10项:
0 1 1 2 3 5 8 13 21 34 

==================================================
第三部分：迭代器的高级用法
==================================================

3.1 无限迭代器:
itertools.count示例(从10开始，步长为2):
10 12 14 16 18 
itertools.cycle示例(循环ABC):
A B C A B C 
itertools.repeat示例(重复Python 3次):
Python Python Python 

3.2 组合迭代器:
itertools.chain示例(连接多个迭代器):
1 2 a b True False 
itertools.zip_longest示例(合并不等长迭代器):
(1, 3)
(2, 4)
('N/A', 5)
('N/A', 6)

3.3 过滤和映射:
filter示例(过滤偶数):
2 4 6 8 10 
map示例(平方运算):
1 4 9 16 25 36 49 64 81 100 

3.4 排列组合迭代器:
itertools.combinations示例(3选2组合):
(1, 2) (1, 3) (2, 3) 
itertools.permutations示例(3选2排列):
(1, 2) (1, 3) (2, 1) (2, 3) (3, 1) (3, 2) 
itertools.product示例(笛卡尔积):
('A', 1) ('A', 2) ('B', 1) ('B', 2) 

==================================================
第四部分：迭代器与生成器的关系
==================================================

生成器是一种特殊的迭代器，使用yield语句简化迭代器的创建
生成器函数示例(等价于上面的Fibonacci类):
使用生成器的斐波那契数列:
0 1 1 2 3 5 8 13 21 34 

==================================================
第五部分：迭代器的实际应用
==================================================

5.1 数据处理管道:
数据处理管道结果:
60 70 80 90 100 

5.2 内存高效的数据处理:
大数据处理结果:
2 4 6 8 10 

5.3 自定义迭代器实际应用:
日期范围:
2023-01-01
2023-01-02
2023-01-03
2023-01-04
2023-01-05

==================================================
迭代器总结
==================================================

1. 迭代器核心特点:
   - 实现了__iter__()和__next__()方法
   - 惰性计算，按需生成数据
   - 只能向前迭代，不能回退
   - 迭代完成后抛出StopIteration异常

2. 迭代器的优势:
   - 内存效率高，适合处理大数据集
   - 支持无限序列
   - 可组合构建数据处理管道
   - 延迟计算，提高性能

3. 常用迭代器工具:
   - 内置函数: iter(), next()
   - itertools模块: count(), cycle(), chain()等
   - 函数式工具: map(), filter()

4. 最佳实践:
   - 使用生成器简化迭代器创建
   - 组合使用itertools提高效率
   - 构建处理管道提高代码可读性
   - 利用迭代器协议实现自定义集合类


迭代器是Python中非常强大的工具，掌握它可以编写更高效、更优雅的代码！

C++之迭代器（Iterator）篇
优快云_564174144的博客
07-28 3万+
迭代器（Iterator）的介绍 背景：指针可以用来遍历存储空间连续的数据结构，但是对于存储空间费连续的，就需要寻找一个行为类似指针的类，来对非数组的数据结构进行遍历。 定义：迭代器提供对一个容器中的对象的访问方法，并且定义了容器中对象的范围。 迭代器（Iterator）是指针（pointer）的泛化，它允许程序员用相同的方式处理不同的数据结构（容器）。 （1）迭代器类似于C语言里面的指针类
【JavaSe】容器篇(二) Iterator迭代器
不想当架构师的程序员不是好程序员
08-25 1273
JavaSe·容器篇(二) Iterator迭代器 1. Iterator接口 在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口 java.util.Iterator 。 Iterator 接口也是Java集合中的一员，但它与 Collection 、 Map 接口有所不同，Collection 接口与 Map 接口主要用于存储元素，而 Iterator ...
Iterator迭代器详解
移动开发记录
07-20 255
迭代器模式(Iterator pattern) 一、 引言迭代这个名词对于熟悉Java的人来说绝对不陌生。我们常常使用JDK提供的迭代接口进行java collection的遍历：Iterator it = list.iterator();while(it.hasNext()){//using “it.next();”do some businesss logic}而这就是关于迭代器模式...
Python 中的 Iterable、Iterator 与生成器
最新发布
Cavewang的博客
03-23 1445
Iterable 是数据容器，Iterator 是遍历工具，生成器 是特殊的 Iterator。生成器通过 yield 关键字实现，代码简洁且内存效率高。理解这三者的区别和联系，有助于更好掌握 Python 的迭代机制，并在需要时自定义迭代行为。希望这篇博客对你有所帮助！如果还有疑问，欢迎留言讨论。
java提高篇（三十）-----Iterator
热门推荐
chenssy 的技术博客
07-07 7万+
迭代对于我们搞Java的来说绝对不陌生。我们常常使用JDK提供的迭代接口进行Java集合的迭代。Iterator iterator = list.iterator(); while(iterator.hasNext()){ String string = iterator.next(); //do something
Java 中的 Iterator 迭代器详解
Q54665642ljf的博客
11-08 2626
在程序开发中，经常需要遍历集合中的所有元素。在调用 Iterator 的 next 方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的 next 方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用 next 方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到 hasNext 方法返回 false，表示到达了集合的末尾，终止对元素的遍历。public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。
C++迭代器iterator详解
ljy的博客
12-31 1819
迭代器有什么用处？泛型算法的参数为什么接收的都是迭代器？迭代器iterator是C++ STL的组件之一，作用是用来遍历容器，而且是通用的遍历容器元素的方式，无论容器是基于什么数据结构实现的，尽管不同的数据结构，遍历元素的方式不一样，但是用迭代器遍历不同容器的代码是完全一样的。实际上，C++11新标准的foreach语句，对于容器的遍历就是通过迭代器迭代器一般实现为容器的嵌套类型，在容器内部提供具体的实现。但是容器不同，底层元素遍历的方式也不同，那么为什么说迭代器遍历所有容器的方式是一样的呢？
Java Iterator接口遍历单列集合迭代器原理详解
08-25
"Java Iterator接口遍历单列集合迭代器原理详解" Java Iterator接口是Java集合框架中的一员，它主要用于遍历集合中的所有元素。 Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection...
C++迭代器 iterator详解
流楚丶格念的博客
04-05 8126
要访问顺序容器和关联容器中的元素，需要通过“迭代器（iterator）”进行。迭代器是一个变量，相当于容器和操纵容器的算法之间的中介。迭代器可以指向容器中的某个元素，通过迭代器就可以读写它指向的元素。从这一点上看，迭代器和指针类似。 迭代器按照定义方式分成以下四种。 正向迭代器，定义方法如下： 容器类名::iterator 迭代器名; 常量正向迭代器，定义方法如下： 容器类名::cons...
详解Java中的迭代迭代器Iterator与枚举器Enumeration
09-02
Java中的迭代器（Iterator）与枚举器（Enumeration）是两种用于遍历集合（Collection）的接口。在Java集合框架中，集合提供了多种数据结构存储对象，而迭代器与枚举器提供了访问这些集合中元素的方法。尽管它们的...
JAVA-Iterator迭代器详解
AlbenXie的博客
03-23 493
1.定义 Iterator的定义为：对Collection进行迭代的迭代器，Iterator取代了Java Collection Framework中的 Enumeration。Iterator与Enumeration主要有两点不一样： 迭代器允许在调用者从集合中删除元素 迭代器的方法名有所改进 以上是Java Api对Iterator的介绍，该接口主要定义了如下代码的规则 public...
详解Java中Iterator迭代器的用法
09-01
主要介绍了Java中Iterator迭代器的用法,比较简单易懂，非常不错，具有参考借鉴价值，需要的朋友可以参考下
java 迭代器Iterator详解
weixin_44026997的博客
07-07 1073
java 迭代器Iterator详解 迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。 （一）Iterator在Collection接口中的使用。 　　　虽然Collection接口的相关类实现了get()方法，但将Iterator用在它们身上仍然是合适的，下面以ArrayList为例，讨论...
迭代器 java_JAVA学习-Iterator迭代器详解
weixin_33217202的博客
02-12 185
1.定义Iterator的定义为：对Collection进行迭代的迭代器，Iterator取代了Java Collection Framework中的 Enumeration。Iterator与Enumeration主要有两点不一样：1.迭代器允许在调用者从集合中删除元素2.迭代器的方法名有所改进以上是Java Api对Iterator的介绍，该接口主要定义了如下代码的规则public inter...
C++迭代器（STL迭代器）iterator详解
又帅又酷的红头发10号
04-14 1万+
转自http://c.biancheng.net/view/338.html。侵删。 要访问顺序容器和关联容器中的元素，需要通过“迭代器（iterator）”进行。迭代器是一个变量，相当于容器和操纵容器的算法之间的中介。迭代器可以指向容器中的某个元素，通过迭代器就可以读写它指向的元素。从这一点上看，迭代器和指针类似。 迭代器按照定义方式分成以下四种。 1) 正向迭代器，定义方法如下： 容器类名...
Java Iterator 迭代器使用详解
Late_whale的博客 作者：代码搬运工老李的二师兄
12-13 2852
文章目录Java Iterator简介常用方法使用详解 Java Iterator 简介 Java Iterator 不是一个集合，是一个用于访问集合的方法，可用于迭代 ArrayList HashSet 等集合 Iterator 是 Java 迭代器最简单的实现 常用方法 序号 方法 作用 1 boolean hasNext() 判断Iterator 中是否还有元素 2 <T> next() 返回下一个元素，并更新Iterator的状态 3 void remove(
Rust 10：迭代器（Iterator）详解
编程架构三分天下：分层、分治、分时序。
04-05 6487
Iterator迭代器； 构造；取出元素；变换map()/filter()/reduce()；求值结算fold()。 求值：fold()/sum()/max()/min()
java中迭代器_JAVA学习-Iterator迭代器详解
weixin_42513215的博客
02-21 272
1.定义Iterator的定义为：对Collection进行迭代的迭代器，Iterator取代了Java Collection Framework中的 Enumeration。Iterator与Enumeration主要有两点不一样：1.迭代器允许在调用者从集合中删除元素2.迭代器的方法名有所改进以上是Java Api对Iterator的介绍，该接口主要定义了如下代码的规则public inter...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值