IterUtil (hutool-core 5.6.7 API)

java.lang.Object
- cn.hutool.core.collection.IterUtil

```
public class IterUtil
extends Object
```
Iterable 和 Iterator 相关工具类

从以下版本开始:

3.1.0

作者:

Looly

构造器概要

构造器
构造器和说明

IterUtil()

构造器
构造器和说明
`IterUtil()`

方法概要

所有方法静态方法具体方法已过时的方法
限定符和类型	方法和说明
`static <E> Iterable<E>`	`asIterable(Iterator<E> iter)` `Iterator` 转为 `Iterable`
`static <E> Iterator<E>`	`asIterator(Enumeration<E> e)` Enumeration转换为Iterator Adapt the specified `Enumeration` to the `Iterator` interface
`static <T> Map<T,Integer>`	`countMap(Iterable<T> iter)` 已过时。如果对象同时实现Iterable和Iterator接口会产生歧义，请使用CollUtil.countMap
`static <T> Map<T,Integer>`	`countMap(Iterator<T> iter)` 根据集合返回一个元素计数的 `Map` 所谓元素计数就是假如这个集合中某个元素出现了n次，那将这个元素做为key，n做为value 例如：[a,b,c,c,c] 得到： a: 1 b: 1 c: 3
`static <T> Iterator<T>`	`empty()` 返回一个空Iterator
`static <K,V> Map<K,V>`	`fieldValueAsMap(Iterable<?> iterable, String fieldNameForKey, String fieldNameForValue)` 已过时。如果对象同时实现Iterable和Iterator接口会产生歧义，请使用CollUtil.fieldValueMap
`static <K,V> Map<K,V>`	`fieldValueAsMap(Iterator<?> iter, String fieldNameForKey, String fieldNameForValue)` 两个字段值组成新的Map
`static <V> List<Object>`	`fieldValueList(Iterable<V> iterable, String fieldName)` 获取指定Bean列表中某个字段，生成新的列表
`static <V> List<Object>`	`fieldValueList(Iterator<V> iter, String fieldName)` 获取指定Bean列表中某个字段，生成新的列表
`static <K,V> Map<K,V>`	`fieldValueMap(Iterable<V> iter, String fieldName)` 已过时。如果对象同时实现Iterable和Iterator接口会产生歧义，请使用CollUtil.fieldValueMap
`static <K,V> Map<K,V>`	`fieldValueMap(Iterator<V> iter, String fieldName)` 字段值与列表值对应的Map，常用于元素对象中有唯一ID时需要按照这个ID查找对象的情况例如：车牌号 =》车
`static <E> Iterator<E>`	`filter(Iterator<E> iter, Filter<E> filter)` 过滤集合，此方法在原集合上直接修改通过实现Filter接口，完成元素的过滤，这个Filter实现可以实现以下功能： 1、过滤出需要的对象，`Filter.accept(Object)`方法返回false的对象将被使用`Iterator.remove()`方法移除
`static <T extends Iterable<E>,E> T`	`filter(T iter, Filter<E> filter)` 过滤集合，此方法在原集合上直接修改通过实现Filter接口，完成元素的过滤，这个Filter实现可以实现以下功能： 1、过滤出需要的对象，`Filter.accept(Object)`方法返回false的对象将被使用`Iterator.remove()`方法移除
`static Class<?>`	`getElementType(Iterable<?> iterable)` 获得`Iterable`对象的元素类型（通过第一个非空元素判断）注意，此方法至少会调用多次next方法
`static Class<?>`	`getElementType(Iterator<?> iterator)` 获得`Iterator`对象的元素类型（通过第一个非空元素判断）注意，此方法至少会调用多次next方法
`static <T> T`	`getFirst(Iterable<T> iterable)` 获取集合的第一个元素
`static <T> T`	`getFirst(Iterator<T> iterator)` 获取集合的第一个元素
`static boolean`	`hasNull(Iterable<?> iter)` 是否包含`null`元素
`static boolean`	`hasNull(Iterator<?> iter)` 是否包含`null`元素
`static boolean`	`isAllNull(Iterable<?> iter)` 是否全部元素为null
`static boolean`	`isAllNull(Iterator<?> iter)` 是否全部元素为null
`static boolean`	`isEmpty(Iterable<?> iterable)` Iterable是否为空
`static boolean`	`isEmpty(Iterator<?> Iterator)` Iterator是否为空
`static boolean`	`isEqualList(Iterable<?> list1, Iterable<?> list2)` 判断两个`Iterable` 是否元素和顺序相同，返回`true`的条件是：两个`Iterable`必须长度相同两个`Iterable`元素相同index的对象必须equals，满足`Objects.equals(Object, Object)` 此方法来自Apache-Commons-Collections4。
`static boolean`	`isNotEmpty(Iterable<?> iterable)` Iterable是否为空
`static boolean`	`isNotEmpty(Iterator<?> Iterator)` Iterator是否为空
`static <T> String`	`join(Iterable<T> iterable, CharSequence conjunction)` 已过时。如果对象同时实现Iterable和Iterator接口会产生歧义，请使用CollUtil.join
`static <T> String`	`join(Iterable<T> iterable, CharSequence conjunction, String prefix, String suffix)` 已过时。如果对象同时实现Iterable和Iterator接口会产生歧义，请使用CollUtil.join
`static <T> String`	`join(Iterator<T> iterator, CharSequence conjunction)` 以 conjunction 为分隔符将集合转换为字符串如果集合元素为数组、`Iterable`或`Iterator`，则递归组合其为字符串
`static <T> String`	`join(Iterator<T> iterator, CharSequence conjunction, Function<T,? extends CharSequence> func)` 以 conjunction 为分隔符将集合转换为字符串如果集合元素为数组、`Iterable`或`Iterator`，则递归组合其为字符串
`static <T> String`	`join(Iterator<T> iterator, CharSequence conjunction, String prefix, String suffix)` 以 conjunction 为分隔符将集合转换为字符串如果集合元素为数组、`Iterable`或`Iterator`，则递归组合其为字符串
`static int`	`size(Iterable<?> iterable)` 返回 Iterable 对象的元素数量
`static int`	`size(Iterator<?> iterator)` 返回 Iterator 对象的元素数量
`static <E> List<E>`	`toList(Iterable<E> iter)` Iterator转List 不判断，直接生成新的List
`static <E> List<E>`	`toList(Iterator<E> iter)` Iterator转List 不判断，直接生成新的List
`static <T,K,V> Map<K,List<V>>`	`toListMap(Iterable<T> iterable, Function<T,K> keyMapper, Function<T,V> valueMapper)` 将列表转成值为List的HashMap
`static <K,V> Map<K,List<V>>`	`toListMap(Iterable<V> iterable, Function<V,K> keyMapper)` 将列表转成值为List的HashMap
`static <T,K,V> Map<K,List<V>>`	`toListMap(Map<K,List<V>> resultMap, Iterable<T> iterable, Function<T,K> keyMapper, Function<T,V> valueMapper)` 将列表转成值为List的HashMap
`static <K,V> Map<K,V>`	`toMap(Iterable<K> keys, Iterable<V> values)` 将键列表和值列表转换为Map 以键为准，值与键位置需对应。
`static <K,V> Map<K,V>`	`toMap(Iterable<K> keys, Iterable<V> values, boolean isOrder)` 将键列表和值列表转换为Map 以键为准，值与键位置需对应。
`static <K,V> HashMap<K,V>`	`toMap(Iterable<Map.Entry<K,V>> entryIter)` 将Entry集合转换为HashMap
`static <T,K,V> Map<K,V>`	`toMap(Iterable<T> iterable, Function<T,K> keyMapper, Function<T,V> valueMapper)` 将列表转成HashMap
`static <K,V> Map<K,V>`	`toMap(Iterable<V> iterable, Function<V,K> keyMapper)` 将列表转成HashMap
`static <K,V,E> Map<K,V>`	`toMap(Iterator<E> iterator, Map<K,V> map, Func1<E,K> keyFunc, Func1<E,V> valueFunc)` 集合转换为Map，转换规则为：按照keyFunc函数规则根据元素对象生成Key，按照valueFunc函数规则根据元素对象生成value组成新的Map
`static <K,V> Map<K,V>`	`toMap(Iterator<K> keys, Iterator<V> values)` 将键列表和值列表转换为Map 以键为准，值与键位置需对应。
`static <K,V> Map<K,V>`	`toMap(Iterator<K> keys, Iterator<V> values, boolean isOrder)` 将键列表和值列表转换为Map 以键为准，值与键位置需对应。
`static <K,V> Map<K,V>`	`toMap(Iterator<V> iterator, Map<K,V> map, Func1<V,K> keyFunc)` Iterator转换为Map，转换规则为：按照keyFunc函数规则根据元素对象生成Key，元素作为值
`static <T,K,V> Map<K,V>`	`toMap(Map<K,V> resultMap, Iterable<T> iterable, Function<T,K> keyMapper, Function<T,V> valueMapper)` 将列表转成Map
`static <F,T> Iterator<T>`	`trans(Iterator<F> iterator, Function<? super F,? extends T> function)` 按照给定函数，转换`Iterator`为另一种类型的`Iterator`

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 构造器详细资料
  - IterUtil
```
public IterUtil()
```
- 方法详细资料
  - isEmpty
```
public static boolean isEmpty(Iterable<?> iterable)
```
    Iterable是否为空
    
    参数:
    
    iterable - Iterable对象
    
    返回:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(Iterator<?> Iterator)
```
    Iterator是否为空
    
    参数:
    
    Iterator - Iterator对象
    
    返回:
    
    是否为空
  - isNotEmpty
```
public static boolean isNotEmpty(Iterable<?> iterable)
```
    Iterable是否为空
    
    参数:
    
    iterable - Iterable对象
    
    返回:
    
    是否为空
  - isNotEmpty
```
public static boolean isNotEmpty(Iterator<?> Iterator)
```
    Iterator是否为空
    
    参数:
    
    Iterator - Iterator对象
    
    返回:
    
    是否为空
  - hasNull
```
public static boolean hasNull(Iterable<?> iter)
```
    是否包含null元素
    
    参数:
    
    iter - 被检查的Iterable对象，如果为null 返回true
    
    返回:
    
    是否包含null元素
  - hasNull
```
public static boolean hasNull(Iterator<?> iter)
```
    是否包含null元素
    
    参数:
    
    iter - 被检查的Iterator对象，如果为null 返回true
    
    返回:
    
    是否包含null元素
  - isAllNull
```
public static boolean isAllNull(Iterable<?> iter)
```
    是否全部元素为null
    
    参数:
    
    iter - iter 被检查的Iterable对象，如果为null 返回true
    
    返回:
    
    是否全部元素为null
    
    从以下版本开始:
    
    3.3.0
  - isAllNull
```
public static boolean isAllNull(Iterator<?> iter)
```
    是否全部元素为null
    
    参数:
    
    iter - iter 被检查的Iterator对象，如果为null 返回true
    
    返回:
    
    是否全部元素为null
    
    从以下版本开始:
    
    3.3.0
  - countMap
```
@Deprecated
public static <T> Map<T,Integer> countMap(Iterable<T> iter)
```
    已过时。如果对象同时实现Iterable和Iterator接口会产生歧义，请使用CollUtil.countMap
    
    根据集合返回一个元素计数的 Map
    所谓元素计数就是假如这个集合中某个元素出现了n次，那将这个元素做为key，n做为value
    例如：[a,b,c,c,c] 得到：
    a: 1
    b: 1
    c: 3
    
    类型参数:
    
    T - 集合元素类型
    
    参数:
    
    iter - Iterable，如果为null返回一个空的Map
    
    返回:
    
    Map
  - countMap
```
public static <T> Map<T,Integer> countMap(Iterator<T> iter)
```
    根据集合返回一个元素计数的 Map
    所谓元素计数就是假如这个集合中某个元素出现了n次，那将这个元素做为key，n做为value
    例如：[a,b,c,c,c] 得到：
    a: 1
    b: 1
    c: 3
    
    类型参数:
    
    T - 集合元素类型
    
    参数:
    
    iter - Iterator，如果为null返回一个空的Map
    
    返回:
    
    Map
  - fieldValueMap
```
@Deprecated
public static <K,V> Map<K,V> fieldValueMap(Iterable<V> iter,
                                                        String fieldName)
```
    已过时。如果对象同时实现Iterable和Iterator接口会产生歧义，请使用CollUtil.fieldValueMap
    
    字段值与列表值对应的Map，常用于元素对象中有唯一ID时需要按照这个ID查找对象的情况
    例如：车牌号 =》车
    
    类型参数:
    
    K - 字段名对应值得类型，不确定请使用Object
    
    V - 对象类型
    
    参数:
    
    iter - 对象列表
    
    fieldName - 字段名（会通过反射获取其值）
    
    返回:
    
    某个字段值与对象对应Map
    
    从以下版本开始:
    
    4.0.4
  - fieldValueMap
```
public static <K,V> Map<K,V> fieldValueMap(Iterator<V> iter,
                                           String fieldName)
```
    字段值与列表值对应的Map，常用于元素对象中有唯一ID时需要按照这个ID查找对象的情况
    例如：车牌号 =》车
    
    类型参数:
    
    K - 字段名对应值得类型，不确定请使用Object
    
    V - 对象类型
    
    参数:
    
    iter - 对象列表
    
    fieldName - 字段名（会通过反射获取其值）
    
    返回:
    
    某个字段值与对象对应Map
    
    从以下版本开始:
    
    4.0.4
  - fieldValueAsMap
```
@Deprecated
public static <K,V> Map<K,V> fieldValueAsMap(Iterable<?> iterable,
                                                          String fieldNameForKey,
                                                          String fieldNameForValue)
```
    已过时。如果对象同时实现Iterable和Iterator接口会产生歧义，请使用CollUtil.fieldValueMap
    
    两个字段值组成新的Map
    
    类型参数:
    
    K - 字段名对应值得类型，不确定请使用Object
    
    V - 值类型，不确定使用Object
    
    参数:
    
    iterable - 对象列表
    
    fieldNameForKey - 做为键的字段名（会通过反射获取其值）
    
    fieldNameForValue - 做为值的字段名（会通过反射获取其值）
    
    返回:
    
    某个字段值与对象对应Map
    
    从以下版本开始:
    
    4.6.2
  - fieldValueAsMap
```
public static <K,V> Map<K,V> fieldValueAsMap(Iterator<?> iter,
                                             String fieldNameForKey,
                                             String fieldNameForValue)
```
    两个字段值组成新的Map
    
    类型参数:
    
    K - 字段名对应值得类型，不确定请使用Object
    
    V - 值类型，不确定使用Object
    
    参数:
    
    iter - 对象列表
    
    fieldNameForKey - 做为键的字段名（会通过反射获取其值）
    
    fieldNameForValue - 做为值的字段名（会通过反射获取其值）
    
    返回:
    
    某个字段值与对象对应Map
    
    从以下版本开始:
    
    4.0.10
  - fieldValueList
```
public static <V> List<Object> fieldValueList(Iterable<V> iterable,
                                              String fieldName)
```
    获取指定Bean列表中某个字段，生成新的列表
    
    类型参数:
    
    V - 对象类型
    
    参数:
    
    iterable - 对象列表
    
    fieldName - 字段名（会通过反射获取其值）
    
    返回:
    
    某个字段值与对象对应Map
    
    从以下版本开始:
    
    4.6.2
  - fieldValueList
```
public static <V> List<Object> fieldValueList(Iterator<V> iter,
                                              String fieldName)
```
    获取指定Bean列表中某个字段，生成新的列表
    
    类型参数:
    
    V - 对象类型
    
    参数:
    
    iter - 对象列表
    
    fieldName - 字段名（会通过反射获取其值）
    
    返回:
    
    某个字段值与对象对应Map
    
    从以下版本开始:
    
    4.0.10
  - join
```
@Deprecated
public static <T> String join(Iterable<T> iterable,
                                           CharSequence conjunction)
```
    已过时。如果对象同时实现Iterable和Iterator接口会产生歧义，请使用CollUtil.join
    
    以 conjunction 为分隔符将集合转换为字符串
    
    类型参数:
    
    T - 集合元素类型
    
    参数:
    
    iterable - Iterable
    
    conjunction - 分隔符
    
    返回:
    
    连接后的字符串
  - join
```
@Deprecated
public static <T> String join(Iterable<T> iterable,
                                           CharSequence conjunction,
                                           String prefix,
                                           String suffix)
```
    已过时。如果对象同时实现Iterable和Iterator接口会产生歧义，请使用CollUtil.join
    
    以 conjunction 为分隔符将集合转换为字符串
    
    类型参数:
    
    T - 集合元素类型
    
    参数:
    
    iterable - Iterable
    
    conjunction - 分隔符
    
    prefix - 每个元素添加的前缀，null表示不添加
    
    suffix - 每个元素添加的后缀，null表示不添加
    
    返回:
    
    连接后的字符串
    
    从以下版本开始:
    
    4.0.10
  - join
```
public static <T> String join(Iterator<T> iterator,
                              CharSequence conjunction)
```
    以 conjunction 为分隔符将集合转换为字符串
    如果集合元素为数组、Iterable或Iterator，则递归组合其为字符串
    
    类型参数:
    
    T - 集合元素类型
    
    参数:
    
    iterator - 集合
    
    conjunction - 分隔符
    
    返回:
    
    连接后的字符串
  - join
```
public static <T> String join(Iterator<T> iterator,
                              CharSequence conjunction,
                              String prefix,
                              String suffix)
```
    以 conjunction 为分隔符将集合转换为字符串
    如果集合元素为数组、Iterable或Iterator，则递归组合其为字符串
    
    类型参数:
    
    T - 集合元素类型
    
    参数:
    
    iterator - 集合
    
    conjunction - 分隔符
    
    prefix - 每个元素添加的前缀，null表示不添加
    
    suffix - 每个元素添加的后缀，null表示不添加
    
    返回:
    
    连接后的字符串
    
    从以下版本开始:
    
    4.0.10
  - join
```
public static <T> String join(Iterator<T> iterator,
                              CharSequence conjunction,
                              Function<T,? extends CharSequence> func)
```
    以 conjunction 为分隔符将集合转换为字符串
    如果集合元素为数组、Iterable或Iterator，则递归组合其为字符串
    
    类型参数:
    
    T - 集合元素类型
    
    参数:
    
    iterator - 集合
    
    conjunction - 分隔符
    
    func - 集合元素转换器，将元素转换为字符串
    
    返回:
    
    连接后的字符串
    
    从以下版本开始:
    
    5.6.7
  - toMap
```
public static <K,V> HashMap<K,V> toMap(Iterable<Map.Entry<K,V>> entryIter)
```
    将Entry集合转换为HashMap
    
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    entryIter - entry集合
    
    返回:
    
    Map
  - toMap
```
public static <K,V> Map<K,V> toMap(Iterable<K> keys,
                                   Iterable<V> values)
```
    将键列表和值列表转换为Map
    以键为准，值与键位置需对应。如果键元素数多于值元素，多余部分值用null代替。
    如果值多于键，忽略多余的值。
    
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    keys - 键列表
    
    values - 值列表
    
    返回:
    
    标题内容Map
    
    从以下版本开始:
    
    3.1.0
  - toMap
```
public static <K,V> Map<K,V> toMap(Iterable<K> keys,
                                   Iterable<V> values,
                                   boolean isOrder)
```
    将键列表和值列表转换为Map
    以键为准，值与键位置需对应。如果键元素数多于值元素，多余部分值用null代替。
    如果值多于键，忽略多余的值。
    
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    keys - 键列表
    
    values - 值列表
    
    isOrder - 是否有序
    
    返回:
    
    标题内容Map
    
    从以下版本开始:
    
    4.1.12
  - toMap
```
public static <K,V> Map<K,V> toMap(Iterator<K> keys,
                                   Iterator<V> values)
```
    将键列表和值列表转换为Map
    以键为准，值与键位置需对应。如果键元素数多于值元素，多余部分值用null代替。
    如果值多于键，忽略多余的值。
    
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    keys - 键列表
    
    values - 值列表
    
    返回:
    
    标题内容Map
    
    从以下版本开始:
    
    3.1.0
  - toMap
```
public static <K,V> Map<K,V> toMap(Iterator<K> keys,
                                   Iterator<V> values,
                                   boolean isOrder)
```
    将键列表和值列表转换为Map
    以键为准，值与键位置需对应。如果键元素数多于值元素，多余部分值用null代替。
    如果值多于键，忽略多余的值。
    
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    keys - 键列表
    
    values - 值列表
    
    isOrder - 是否有序
    
    返回:
    
    标题内容Map
    
    从以下版本开始:
    
    4.1.12
  - toListMap
```
public static <K,V> Map<K,List<V>> toListMap(Iterable<V> iterable,
                                             Function<V,K> keyMapper)
```
    将列表转成值为List的HashMap
    
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    iterable - 值列表
    
    keyMapper - Map的键映射
    
    返回:
    
    HashMap
    
    从以下版本开始:
    
    5.3.6
  - toListMap
```
public static <T,K,V> Map<K,List<V>> toListMap(Iterable<T> iterable,
                                               Function<T,K> keyMapper,
                                               Function<T,V> valueMapper)
```
    将列表转成值为List的HashMap
    
    类型参数:
    
    T - 列表值类型
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    iterable - 值列表
    
    keyMapper - Map的键映射
    
    valueMapper - Map中List的值映射
    
    返回:
    
    HashMap
    
    从以下版本开始:
    
    5.3.6
  - toListMap
```
public static <T,K,V> Map<K,List<V>> toListMap(Map<K,List<V>> resultMap,
                                               Iterable<T> iterable,
                                               Function<T,K> keyMapper,
                                               Function<T,V> valueMapper)
```
    将列表转成值为List的HashMap
    
    类型参数:
    
    T - 列表值类型
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    resultMap - 结果Map，可自定义结果Map类型
    
    iterable - 值列表
    
    keyMapper - Map的键映射
    
    valueMapper - Map中List的值映射
    
    返回:
    
    HashMap
    
    从以下版本开始:
    
    5.3.6
  - toMap
```
public static <K,V> Map<K,V> toMap(Iterable<V> iterable,
                                   Function<V,K> keyMapper)
```
    将列表转成HashMap
    
    类型参数:
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    iterable - 值列表
    
    keyMapper - Map的键映射
    
    返回:
    
    HashMap
    
    从以下版本开始:
    
    5.3.6
  - toMap
```
public static <T,K,V> Map<K,V> toMap(Iterable<T> iterable,
                                     Function<T,K> keyMapper,
                                     Function<T,V> valueMapper)
```
    将列表转成HashMap
    
    类型参数:
    
    T - 列表值类型
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    iterable - 值列表
    
    keyMapper - Map的键映射
    
    valueMapper - Map的值映射
    
    返回:
    
    HashMap
    
    从以下版本开始:
    
    5.3.6
  - toMap
```
public static <T,K,V> Map<K,V> toMap(Map<K,V> resultMap,
                                     Iterable<T> iterable,
                                     Function<T,K> keyMapper,
                                     Function<T,V> valueMapper)
```
    将列表转成Map
    
    类型参数:
    
    T - 列表值类型
    
    K - 键类型
    
    V - 值类型
    
    参数:
    
    resultMap - 结果Map，通过传入map对象决定结果的Map类型
    
    iterable - 值列表
    
    keyMapper - Map的键映射
    
    valueMapper - Map的值映射
    
    返回:
    
    HashMap
    
    从以下版本开始:
    
    5.3.6
  - toList
```
public static <E> List<E> toList(Iterable<E> iter)
```
    Iterator转List
    不判断，直接生成新的List
    
    类型参数:
    
    E - 元素类型
    
    参数:
    
    iter - Iterator
    
    返回:
    
    List
    
    从以下版本开始:
    
    4.0.6
  - toList
```
public static <E> List<E> toList(Iterator<E> iter)
```
    Iterator转List
    不判断，直接生成新的List
    
    类型参数:
    
    E - 元素类型
    
    参数:
    
    iter - Iterator
    
    返回:
    
    List
    
    从以下版本开始:
    
    4.0.6
  - asIterator
```
public static <E> Iterator<E> asIterator(Enumeration<E> e)
```
    Enumeration转换为Iterator
    Adapt the specified Enumeration to the Iterator interface
    
    类型参数:
    
    E - 集合元素类型
    
    参数:
    
    e - Enumeration
    
    返回:
    
    Iterator
  - asIterable
```
public static <E> Iterable<E> asIterable(Iterator<E> iter)
```
    Iterator 转为 Iterable
    
    类型参数:
    
    E - 元素类型
    
    参数:
    
    iter - Iterator
    
    返回:
    
    Iterable
  - getFirst
```
public static <T> T getFirst(Iterable<T> iterable)
```
    获取集合的第一个元素
    
    类型参数:
    
    T - 集合元素类型
    
    参数:
    
    iterable - Iterable
    
    返回:
    
    第一个元素
  - getFirst
```
public static <T> T getFirst(Iterator<T> iterator)
```
    获取集合的第一个元素
    
    类型参数:
    
    T - 集合元素类型
    
    参数:
    
    iterator - Iterator
    
    返回:
    
    第一个元素
  - getElementType
```
public static Class<?> getElementType(Iterable<?> iterable)
```
    获得Iterable对象的元素类型（通过第一个非空元素判断）
    注意，此方法至少会调用多次next方法
    
    参数:
    
    iterable - Iterable
    
    返回:
    
    元素类型，当列表为空或元素全部为null时，返回null
  - getElementType
```
public static Class<?> getElementType(Iterator<?> iterator)
```
    获得Iterator对象的元素类型（通过第一个非空元素判断）
    注意，此方法至少会调用多次next方法
    
    参数:
    
    iterator - Iterator
    
    返回:
    
    元素类型，当列表为空或元素全部为null时，返回null
  - filter
```
public static <T extends Iterable<E>,E> T filter(T iter,
                                                 Filter<E> filter)
```
    过滤集合，此方法在原集合上直接修改
    通过实现Filter接口，完成元素的过滤，这个Filter实现可以实现以下功能：
```
 1、过滤出需要的对象，Filter.accept(Object)方法返回false的对象将被使用Iterator.remove()方法移除
 
```
    类型参数:
    
    T - 集合类型
    
    E - 集合元素类型
    
    参数:
    
    iter - 集合
    
    filter - 过滤器接口
    
    返回:
    
    编辑后的集合
    
    从以下版本开始:
    
    4.6.5
  - filter
```
public static <E> Iterator<E> filter(Iterator<E> iter,
                                     Filter<E> filter)
```
    过滤集合，此方法在原集合上直接修改
    通过实现Filter接口，完成元素的过滤，这个Filter实现可以实现以下功能：
```
 1、过滤出需要的对象，Filter.accept(Object)方法返回false的对象将被使用Iterator.remove()方法移除
 
```
    类型参数:
    
    E - 集合元素类型
    
    参数:
    
    iter - 集合
    
    filter - 过滤器接口
    
    返回:
    
    编辑后的集合
    
    从以下版本开始:
    
    4.6.5
  - toMap
```
public static <K,V> Map<K,V> toMap(Iterator<V> iterator,
                                   Map<K,V> map,
                                   Func1<V,K> keyFunc)
```
    Iterator转换为Map，转换规则为：
    按照keyFunc函数规则根据元素对象生成Key，元素作为值
    
    类型参数:
    
    K - Map键类型
    
    V - Map值类型
    
    参数:
    
    iterator - 数据列表
    
    map - Map对象，转换后的键值对加入此Map，通过传入此对象自定义Map类型
    
    keyFunc - 生成key的函数
    
    返回:
    
    生成的map
    
    从以下版本开始:
    
    5.2.6
  - toMap
```
public static <K,V,E> Map<K,V> toMap(Iterator<E> iterator,
                                     Map<K,V> map,
                                     Func1<E,K> keyFunc,
                                     Func1<E,V> valueFunc)
```
    集合转换为Map，转换规则为：
    按照keyFunc函数规则根据元素对象生成Key，按照valueFunc函数规则根据元素对象生成value组成新的Map
    
    类型参数:
    
    K - Map键类型
    
    V - Map值类型
    
    E - 元素类型
    
    参数:
    
    iterator - 数据列表
    
    map - Map对象，转换后的键值对加入此Map，通过传入此对象自定义Map类型
    
    keyFunc - 生成key的函数
    
    valueFunc - 生成值的策略函数
    
    返回:
    
    生成的map
    
    从以下版本开始:
    
    5.2.6
  - empty
```
public static <T> Iterator<T> empty()
```
    返回一个空Iterator
    
    类型参数:
    
    T - 元素类型
    
    返回:
    
    空Iterator
    
    从以下版本开始:
    
    5.3.1
    
    另请参阅:
    
    Collections.emptyIterator()
  - trans
```
public static <F,T> Iterator<T> trans(Iterator<F> iterator,
                                      Function<? super F,? extends T> function)
```
    按照给定函数，转换Iterator为另一种类型的Iterator
    
    类型参数:
    
    F - 源元素类型
    
    T - 目标元素类型
    
    参数:
    
    iterator - 源Iterator
    
    function - 转换函数
    
    返回:
    
    转换后的Iterator
    
    从以下版本开始:
    
    5.4.3
  - size
```
public static int size(Iterable<?> iterable)
```
    返回 Iterable 对象的元素数量
    
    参数:
    
    iterable - Iterable对象
    
    返回:
    
    Iterable对象的元素数量
    
    从以下版本开始:
    
    5.5.0
  - size
```
public static int size(Iterator<?> iterator)
```
    返回 Iterator 对象的元素数量
    
    参数:
    
    iterator - Iterator对象
    
    返回:
    
    Iterator对象的元素数量
    
    从以下版本开始:
    
    5.5.0
  - isEqualList
```
public static boolean isEqualList(Iterable<?> list1,
                                  Iterable<?> list2)
```
    判断两个Iterable 是否元素和顺序相同，返回true的条件是：
    - 两个Iterable必须长度相同
    - 两个Iterable元素相同index的对象必须equals，满足Objects.equals(Object, Object)
    此方法来自Apache-Commons-Collections4。
    参数:
    
    list1 - 列表1
    
    list2 - 列表2
    
    返回:
    
    是否相同
    
    从以下版本开始:
    
    5.6.0

类 IterUtil

构造器概要

方法概要

从类继承的方法 java.lang.Object

构造器详细资料

IterUtil

方法详细资料

isEmpty

isEmpty

isNotEmpty

isNotEmpty

hasNull

hasNull

isAllNull

isAllNull

countMap

countMap

fieldValueMap

fieldValueMap

fieldValueAsMap

fieldValueAsMap

fieldValueList

fieldValueList

join

join

join

join

join

toMap

toMap

toMap

toMap

toMap

toListMap

toListMap

toListMap

toMap

toMap

toMap

toList

toList

asIterator

asIterable

getFirst

getFirst

getElementType

getElementType

filter

filter

toMap

toMap

empty

trans

size

size

isEqualList