迭代器工具-IterUtil
# 📚 介绍
IterUtil 是 Hutool 核心模块中的迭代器工具类，它提供了丰富的迭代器操作方法，包括迭代器创建、转换、操作、遍历和比较等功能，为 Java 开发者提供了便捷的迭代器操作解决方案。
# 设计理念
- 简化创建：提供多种方式创建迭代器
- 丰富操作：涵盖迭代器的各种常用操作
- 高效性能：底层实现经过优化，性能优异
- 易用性强：提供简洁的 API，一行代码即可完成复杂的迭代器操作
- 线程安全：所有工具类都是线程安全的，可以在多线程环境下安全使用
# 🔧 核心方法详解
# 1. 迭代器创建
# of(T... values)
功能：创建一个包含指定元素的迭代器
参数：
values：要包含在迭代器中的元素
返回值：包含指定元素的迭代器
示例：
// 创建包含指定元素的迭代器
Iterator<String> iterator = IterUtil.of("a", "b", "c");
// 遍历迭代器
while (iterator.hasNext()) {
Console.log(iterator.next());
}
// 输出：
// a
// b
// c
# empty()
功能：创建一个空迭代器
返回值：空迭代器
示例：
// 创建空迭代器
Iterator<String> emptyIterator = IterUtil.empty();
Console.log("是否有下一个元素：" + emptyIterator.hasNext()); // false
# 2. 迭代器转换
# toList(Iterator iterator)
功能：将迭代器转换为列表
参数：
iterator：要转换的迭代器
返回值：转换后的列表
示例：
Iterator<String> iterator = IterUtil.of("a", "b", "c");
// 转换为列表
List<String> list = IterUtil.toList(iterator);
Console.log(list); // [a, b, c]
# toSet(Iterator iterator)
功能：将迭代器转换为集合
参数：
iterator：要转换的迭代器
返回值：转换后的集合
示例：
Iterator<String> iterator = IterUtil.of("a", "b", "c", "a");
// 转换为集合（自动去重）
Set<String> set = IterUtil.toSet(iterator);
Console.log(set); // [a, b, c]
# toMap(Iterator iterator, Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper)
功能：将迭代器转换为映射
参数：
iterator：要转换的迭代器keyMapper：键映射函数valueMapper：值映射函数
返回值：转换后的映射
示例：
Iterator<String> iterator = IterUtil.of("a", "b", "c");
// 转换为映射，键为元素，值为元素长度
Map<String, Integer> map = IterUtil.toMap(iterator, s -> s, String::length);
Console.log(map); // {a=1, b=1, c=1}
# 3. 迭代器操作
# filter(Iterator iterator, Predicate<? super T> predicate)
功能：过滤迭代器中的元素
参数：
iterator：要过滤的迭代器predicate：过滤条件
返回值：过滤后的迭代器
示例：
Iterator<Integer> iterator = IterUtil.of(1, 2, 3, 4, 5);
// 过滤偶数
Iterator<Integer> filteredIterator = IterUtil.filter(iterator, num -> num % 2 == 0);
// 转换为列表查看结果
List<Integer> result = IterUtil.toList(filteredIterator);
Console.log(result); // [2, 4]
# map(Iterator iterator, Function<? super T, ? extends R> mapper)
功能：转换迭代器中的元素
参数：
iterator：要转换的迭代器mapper：转换函数
返回值：转换后的迭代器
示例：
Iterator<String> iterator = IterUtil.of("a", "b", "c");
// 将元素转换为大写
Iterator<String> mappedIterator = IterUtil.map(iterator, String::toUpperCase);
// 转换为列表查看结果
List<String> result = IterUtil.toList(mappedIterator);
Console.log(result); // [A, B, C]
# limit(Iterator iterator, long maxSize)
功能：限制迭代器的元素数量
参数：
iterator：要限制的迭代器maxSize：最大元素数量
返回值：限制后的迭代器
示例：
Iterator<Integer> iterator = IterUtil.of(1, 2, 3, 4, 5);
// 限制只返回前3个元素
Iterator<Integer> limitedIterator = IterUtil.limit(iterator, 3);
// 转换为列表查看结果
List<Integer> result = IterUtil.toList(limitedIterator);
Console.log(result); // [1, 2, 3]
# 4. 迭代器遍历
# forEach(Iterator iterator, Consumer<? super T> action)
功能：遍历迭代器并对每个元素执行指定操作
参数：
iterator：要遍历的迭代器action：对每个元素执行的操作
示例：
Iterator<String> iterator = IterUtil.of("a", "b", "c");
// 遍历迭代器并打印每个元素
IterUtil.forEach(iterator, element -> Console.log("元素：" + element));
// 输出：
// 元素：a
// 元素：b
// 元素：c
# forEach(Iterator iterator, BiConsumer<Integer, ? super T> action)
功能：遍历迭代器并对每个元素执行指定操作，同时提供元素索引
参数：
iterator：要遍历的迭代器action：对每个元素执行的操作，第一个参数是索引，第二个参数是元素
示例：
Iterator<String> iterator = IterUtil.of("a", "b", "c");
// 遍历迭代器并打印每个元素及其索引
IterUtil.forEach(iterator, (index, element) -> Console.log("索引" + index + ": " + element));
// 输出：
// 索引0: a
// 索引1: b
// 索引2: c
# 5. 迭代器比较
# equals(Iterator<?> iterator1, Iterator<?> iterator2)
功能：比较两个迭代器是否相等
参数：
iterator1：第一个迭代器iterator2：第二个迭代器
返回值：如果两个迭代器相等则返回 true，否则返回 false
示例：
Iterator<String> iterator1 = IterUtil.of("a", "b", "c");
Iterator<String> iterator2 = IterUtil.of("a", "b", "c");
Iterator<String> iterator3 = IterUtil.of("a", "c", "b");
// 比较迭代器
boolean equals1 = IterUtil.equals(iterator1, iterator2);
boolean equals2 = IterUtil.equals(iterator1, iterator3);
Console.log(equals1); // true
Console.log(equals2); // false
# 🚀 综合示例
# 示例1：迭代器操作综合应用
public void iterUtilTest() {
// 创建迭代器
Iterator<String> iterator = IterUtil.of("apple", "banana", "orange", "grape", "watermelon");
// 过滤长度大于5的元素
Iterator<String> filteredIterator = IterUtil.filter(iterator, s -> s.length() > 5);
// 将元素转换为大写
Iterator<String> mappedIterator = IterUtil.map(filteredIterator, String::toUpperCase);
// 限制只返回前2个元素
Iterator<String> limitedIterator = IterUtil.limit(mappedIterator, 2);
// 遍历迭代器并打印结果
IterUtil.forEach(limitedIterator, (index, element) -> {
Console.log("第" + (index + 1) + "个元素：" + element);
});
// 输出：
// 第1个元素：BANANA
// 第2个元素：ORANGE
}
# 示例2：迭代器在自定义集合中的应用
public class CustomCollection<T> implements Collection<T> {
private final List<T> elements = new ArrayList<>();
@Override
public Iterator<T> iterator() {
return elements.iterator();
}
@Override
public int size() {
return elements.size();
}
@Override
public boolean isEmpty() {
return elements.isEmpty();
}
@Override
public boolean contains(Object o) {
return elements.contains(o);
}
@Override
public Object[] toArray() {
return elements.toArray();
}
@Override
public <T1> T1[] toArray(T1[] a) {
return elements.toArray(a);
}
@Override
public boolean add(T t) {
return elements.add(t);
}
@Override
public boolean remove(Object o) {
return elements.remove(o);
}
@Override
public boolean containsAll(Collection<?> c) {
return elements.containsAll(c);
}
@Override
public boolean addAll(Collection<? extends T> c) {
return elements.addAll(c);
}
@Override
public boolean removeAll(Collection<?> c) {
return elements.removeAll(c);
}
@Override
public boolean retainAll(Collection<?> c) {
return elements.retainAll(c);
}
@Override
public void clear() {
elements.clear();
}
}
// 使用示例
public void customCollectionTest() {
// 创建自定义集合
CustomCollection<String> collection = new CustomCollection<>();
collection.add("a");
collection.add("b");
collection.add("c");
// 获取迭代器
Iterator<String> iterator = collection.iterator();
// 使用IterUtil操作迭代器
List<String> list = IterUtil.toList(iterator);
Console.log("转换为列表：" + list); // [a, b, c]
// 重新获取迭代器
iterator = collection.iterator();
// 遍历并打印每个元素
IterUtil.forEach(iterator, element -> {
Console.log("元素：" + element);
});
// 输出：
// 元素：a
// 元素：b
// 元素：c
}
# 示例3：迭代器在数据处理中的应用
public void dataProcessingTest() {
// 模拟从数据库获取的数据迭代器
Iterator<Map<String, Object>> dataIterator = getDataFromDatabase();
// 转换为用户对象列表
List<User> users = IterUtil.toList(IterUtil.map(dataIterator, this::mapToUser));
Console.log("用户数量：" + users.size());
// 过滤年龄大于25的用户
users = users.stream()
.filter(user -> user.getAge() > 25)
.collect(Collectors.toList());
Console.log("年龄大于25的用户数量：" + users.size());
// 打印用户信息
users.forEach(user -> {
Console.log("用户名：" + user.getName() + "，年龄：" + user.getAge());
});
}
// 模拟从数据库获取数据
private Iterator<Map<String, Object>> getDataFromDatabase() {
List<Map<String, Object>> data = new ArrayList<>();
Map<String, Object> user1 = new HashMap<>();
user1.put("name", "Alice");
user1.put("age", 23);
data.add(user1);
Map<String, Object> user2 = new HashMap<>();
user2.put("name", "Bob");
user2.put("age", 28);
data.add(user2);
Map<String, Object> user3 = new HashMap<>();
user3.put("name", "Charlie");
user3.put("age", 30);
data.add(user3);
Map<String, Object> user4 = new HashMap<>();
user4.put("name", "David");
user4.put("age", 21);
data.add(user4);
return data.iterator();
}
// 映射为用户对象
private User mapToUser(Map<String, Object> data) {
User user = new User();
user.setName((String) data.get("name"));
user.setAge((Integer) data.get("age"));
return user;
}
// 用户类
class User {
private String name;
private int age;
// getter and setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
# 🎯 设计优势
- 简化创建：提供了多种便捷的迭代器创建方式，包括直接创建、空迭代器创建等
- 丰富操作：涵盖了迭代器的各种常用操作，包括转换、过滤、转换、限制等
- 高效性能：底层实现经过优化，性能优异，特别是对于大规模数据
- 易用性强：提供了简洁的 API，一行代码即可完成复杂的迭代器操作
- 线程安全：所有方法都是线程安全的，可以在多线程环境下安全使用
- 兼容性好：兼容 Java 各种版本，支持各种迭代器实现
# 📌 注意事项
- 迭代器消耗：迭代器是一次性的，一旦遍历后，就不能再次使用
- 空值处理：大部分方法都进行了空值处理，但在使用时仍需注意
- 线程安全：虽然 IterUtil 本身是线程安全的，但迭代器的线程安全性取决于具体的迭代器实现
- 性能考虑：对于大规模数据，某些操作可能会影响性能，建议根据实际情况选择合适的方法
# 🚀 总结
IterUtil 是一个功能强大、使用便捷的迭代器操作工具类，为 Java 开发者提供了丰富的迭代器操作解决方案。它简化了迭代器的创建、转换、操作、遍历和比较等操作，提高了开发效率。
无论是简单的迭代器创建，还是复杂的数据处理，IterUtil 都能轻松应对。通过合理使用 IterUtil，可以简化迭代器操作的开发工作，提高开发效率，同时保证操作的准确性和性能。
IterUtil 是 Hutool 集合模块中的重要组成部分，与其他集合工具类一起，构成了完整的集合操作解决方案，为 Java 开发者提供了丰富的集合操作工具。