diff --git a/hutool-core/src/main/java/cn/hutool/core/bean/BeanUtil.java b/hutool-core/src/main/java/cn/hutool/core/bean/BeanUtil.java
index e55c5a446..ed66d5b77 100755
--- a/hutool-core/src/main/java/cn/hutool/core/bean/BeanUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/bean/BeanUtil.java
@@ -4,6 +4,7 @@ import cn.hutool.core.bean.copier.BeanCopier;
import cn.hutool.core.bean.copier.CopyOptions;
import cn.hutool.core.bean.copier.ValueProvider;
import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.collection.SetUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.lang.func.Editor;
@@ -318,7 +319,7 @@ public class BeanUtil {
if (bean instanceof Map) {
((Map) bean).put(fieldNameOrIndex, value);
} else if (bean instanceof List) {
- CollUtil.setOrAppend((List) bean, Convert.toInt(fieldNameOrIndex), value);
+ ListUtil.setOrAppend((List) bean, Convert.toInt(fieldNameOrIndex), value);
} else if (ArrayUtil.isArray(bean)) {
ArrayUtil.setOrAppend(bean, Convert.toInt(fieldNameOrIndex), value);
} else {
diff --git a/hutool-core/src/main/java/cn/hutool/core/collection/CollUtil.java b/hutool-core/src/main/java/cn/hutool/core/collection/CollUtil.java
index ee785fa96..1358f12ce 100755
--- a/hutool-core/src/main/java/cn/hutool/core/collection/CollUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/collection/CollUtil.java
@@ -11,7 +11,6 @@ import cn.hutool.core.comparator.PropertyComparator;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.convert.ConverterRegistry;
import cn.hutool.core.exceptions.UtilException;
-import cn.hutool.core.lang.func.Func1;
import cn.hutool.core.lang.hash.Hash32;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.reflect.ClassUtil;
@@ -64,18 +63,16 @@ import java.util.stream.Collectors;
/**
* 集合相关工具类
*
- * 此工具方法针对{@link Collection}及其实现类封装的工具。
+ * 此工具方法针对{@link Collection}或{@link Iterable}及其实现类封装的工具。
*
- * 由于{@link Collection} 实现了{@link Iterable}接口，因此部分工具此类不提供，而是在{@link IterUtil} 中提供
*
- * @author xiaoleilu
+ * @author Looly
* @see IterUtil
* @since 3.1.1
*/
public class CollUtil {
// ---------------------------------------------------------------------- isEmpty
-
/**
* 集合是否为空
*
@@ -868,6 +865,44 @@ public class CollUtil {
return queue;
}
+ /**
+ * 根据给定的集合类型，返回对应的空集合，支持类型包括：
+ * *
+ *
+ * 1. NavigableSet
+ * 2. SortedSet
+ * 3. Set
+ * 4. List
+ *
+ *
+ * @param 元素类型
+ * @param 集合类型
+ * @param collectionClass 集合类型
+ * @return 空集合
+ * @since 5.3.1
+ */
+ @SuppressWarnings("unchecked")
+ public static > T empty(final Class collectionClass) {
+ if (null == collectionClass) {
+ return (T) Collections.emptyList();
+ }
+
+ if (Set.class.isAssignableFrom(collectionClass)) {
+ if (NavigableSet.class == collectionClass) {
+ return (T) Collections.emptyNavigableSet();
+ } else if (SortedSet.class == collectionClass) {
+ return (T) Collections.emptySortedSet();
+ } else {
+ return (T) Collections.emptySet();
+ }
+ } else if (List.class.isAssignableFrom(collectionClass)) {
+ return (T) Collections.emptyList();
+ }
+
+ // 不支持空集合的集合类型
+ throw new IllegalArgumentException(StrUtil.format("[{}] is not support to get empty!", collectionClass));
+ }
+
/**
* 创建新的集合对象
*
@@ -1085,17 +1120,26 @@ public class CollUtil {
}
/**
- * 去除指定元素，此方法直接修改原集合
+ * 移除集合中满足条件的所有元素，此方法在原集合上直接修改
+ * 通过实现{@link Predicate}接口，完成元素的移除，可以实现以下功能：
*
- * @param 集合类型
- * @param 集合元素类型
- * @param collection 集合
- * @param filter 过滤器
- * @return 处理后的集合
+ *
+ * 1、移除指定对象，{@link Predicate#test(Object)}方法返回{@code true}的对象将被使用{@link Iterator#remove()}方法移除。
+ *
+ *
+ * @param 集合类型
+ * @param 集合元素类型
+ * @param iter 集合
+ * @param predicate 过滤器接口
+ * @return 编辑后的集合
* @since 4.6.5
*/
- public static , E> T remove(final T collection, final Predicate filter) {
- return IterUtil.remove(collection, filter);
+ public static , E> T remove(final T iter, final Predicate predicate) {
+ if (null == iter) {
+ return null;
+ }
+ IterUtil.remove(iter.iterator(), predicate);
+ return iter;
}
/**
@@ -1297,6 +1341,29 @@ public class CollUtil {
return IterUtil.fieldValueAsMap(IterUtil.getIter(iterable), fieldNameForKey, fieldNameForValue);
}
+ /**
+ * 获取集合的第一个元素，如果集合为空（null或者空集合），返回{@code null}
+ *
+ * @param 集合元素类型
+ * @param iterable {@link Iterable}
+ * @return 第一个元素，为空返回{@code null}
+ */
+ public static T getFirst(final Iterable iterable) {
+ return IterUtil.getFirst(IterUtil.getIter(iterable));
+ }
+
+ /**
+ * 获取集合的第一个非空元素
+ *
+ * @param 集合元素类型
+ * @param iterable {@link Iterable}
+ * @return 第一个元素
+ * @since 5.7.2
+ */
+ public static T getFirstNoneNull(final Iterable iterable) {
+ return IterUtil.getFirstNoneNull(IterUtil.getIter(iterable));
+ }
+
/**
* 查找第一个匹配元素对象
*
@@ -1306,15 +1373,8 @@ public class CollUtil {
* @return 满足过滤条件的第一个元素
* @since 3.1.0
*/
- public static T findOne(final Iterable collection, final Predicate predicate) {
- if (null != collection) {
- for (final T t : collection) {
- if (predicate.test(t)) {
- return t;
- }
- }
- }
- return null;
+ public static T getFirst(final Iterable collection, final Predicate predicate) {
+ return IterUtil.getFirst(IterUtil.getIter(collection), predicate);
}
/**
@@ -1330,8 +1390,8 @@ public class CollUtil {
* @return 满足条件的第一个元素
* @since 3.1.0
*/
- public static T findOneByField(final Iterable collection, final String fieldName, final Object fieldValue) {
- return findOne(collection, t -> {
+ public static T getFirstByField(final Iterable collection, final String fieldName, final Object fieldValue) {
+ return getFirst(collection, t -> {
if (t instanceof Map) {
final Map map = (Map) t;
final Object value = map.get(fieldName);
@@ -1421,7 +1481,7 @@ public class CollUtil {
*
* @param 元素类型
* @param collection 集合
- * @param predicate 匹配器，为空则全部匹配
+ * @param predicate 匹配器，为空则全部匹配
* @return 位置数组
* @since 5.2.5
*/
@@ -1509,19 +1569,6 @@ public class CollUtil {
return map;
}
- /**
- * 将Entry集合转换为HashMap
- *
- * @param 键类型
- * @param 值类型
- * @param entryIter entry集合
- * @return Map
- * @see IterUtil#toMap(Iterable)
- */
- public static HashMap toMap(final Iterable> entryIter) {
- return IterUtil.toMap(entryIter);
- }
-
/**
* 将数组转换为Map（HashMap），支持数组元素类型为：
*
@@ -1685,40 +1732,6 @@ public class CollUtil {
return MapUtil.toMapList(listMap);
}
- /**
- * 集合转换为Map，转换规则为：
- * 按照keyFunc函数规则根据元素对象生成Key，元素作为值
- *
- * @param Map键类型
- * @param Map值类型
- * @param values 数据列表
- * @param map Map对象，转换后的键值对加入此Map，通过传入此对象自定义Map类型
- * @param keyFunc 生成key的函数
- * @return 生成的map
- * @since 5.2.6
- */
- public static Map toMap(final Iterable values, final Map map, final Func1 keyFunc) {
- return IterUtil.toMap(null == values ? null : values.iterator(), map, keyFunc);
- }
-
- /**
- * 集合转换为Map，转换规则为：
- * 按照keyFunc函数规则根据元素对象生成Key，按照valueFunc函数规则根据元素对象生成value组成新的Map
- *
- * @param Map键类型
- * @param Map值类型
- * @param 元素类型
- * @param values 数据列表
- * @param map Map对象，转换后的键值对加入此Map，通过传入此对象自定义Map类型
- * @param keyFunc 生成key的函数
- * @param valueFunc 生成值的策略函数
- * @return 生成的map
- * @since 5.2.6
- */
- public static Map toMap(final Iterable values, final Map map, final Func1 keyFunc, final Func1 valueFunc) {
- return IterUtil.toMap(null == values ? null : values.iterator(), map, keyFunc, valueFunc);
- }
-
/**
* 将指定对象全部加入到集合中
* 提供的对象如果为集合类型，会自动转换为目标元素类型
@@ -1844,6 +1857,18 @@ public class CollUtil {
return collection;
}
+ /**
+ * 获取集合的最后一个元素
+ *
+ * @param 集合元素类型
+ * @param collection {@link Collection}
+ * @return 最后一个元素
+ * @since 4.1.10
+ */
+ public static T getLast(final Collection collection) {
+ return get(collection, -1);
+ }
+
/**
* 获取集合中指定下标的元素值，下标可以为负数，例如-1表示最后一个元素
* 如果元素越界，返回null
@@ -1914,77 +1939,6 @@ public class CollUtil {
return result;
}
- /**
- * 获取集合的第一个元素
- *
- * @param 集合元素类型
- * @param iterable {@link Iterable}
- * @return 第一个元素
- * @see IterUtil#getFirst(Iterable)
- * @since 3.0.1
- */
- public static T getFirst(final Iterable iterable) {
- return IterUtil.getFirst(iterable);
- }
-
- /**
- * 获取集合的最后一个元素
- *
- * @param 集合元素类型
- * @param collection {@link Collection}
- * @return 最后一个元素
- * @since 4.1.10
- */
- public static T getLast(final Collection collection) {
- return get(collection, -1);
- }
-
- /**
- * 从Map中获取指定键列表对应的值列表
- * 如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
- *
- * @param 键类型
- * @param 值类型
- * @param map {@link Map}
- * @param keys 键列表
- * @return 值列表
- * @since 3.0.8
- */
- @SuppressWarnings("unchecked")
- public static ArrayList valuesOfKeys(final Map map, final K... keys) {
- return MapUtil.valuesOfKeys(map, new ArrayIter<>(keys));
- }
-
- /**
- * 从Map中获取指定键列表对应的值列表
- * 如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
- *
- * @param 键类型
- * @param 值类型
- * @param map {@link Map}
- * @param keys 键列表
- * @return 值列表
- * @since 3.0.9
- */
- public static ArrayList valuesOfKeys(final Map map, final Iterable keys) {
- return valuesOfKeys(map, keys.iterator());
- }
-
- /**
- * 从Map中获取指定键列表对应的值列表
- * 如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
- *
- * @param 键类型
- * @param 值类型
- * @param map {@link Map}
- * @param keys 键列表
- * @return 值列表
- * @since 3.0.9
- */
- public static ArrayList valuesOfKeys(final Map map, final Iterator keys) {
- return MapUtil.valuesOfKeys(map, keys);
- }
-
// ------------------------------------------------------------------------------------------------- sort
/**
@@ -2317,20 +2271,6 @@ public class CollUtil {
});
}
- /**
- * 设置或增加元素。当index小于List的长度时，替换指定位置的值，否则在尾部追加
- *
- * @param 元素类型
- * @param list List列表
- * @param index 位置
- * @param element 新元素
- * @return 原List
- * @since 4.1.2
- */
- public static List setOrAppend(final List list, final int index, final T element) {
- return ListUtil.setOrAppend(list, index, element);
- }
-
/**
* 获取指定Map列表中所有的Key
*
@@ -2409,44 +2349,6 @@ public class CollUtil {
return Collections.unmodifiableCollection(c);
}
- /**
- * 根据给定的集合类型，返回对应的空集合，支持类型包括：
- * *
- *
- * 1. NavigableSet
- * 2. SortedSet
- * 3. Set
- * 4. List
- *
- *
- * @param 元素类型
- * @param 集合类型
- * @param collectionClass 集合类型
- * @return 空集合
- * @since 5.3.1
- */
- @SuppressWarnings("unchecked")
- public static > T empty(final Class collectionClass) {
- if (null == collectionClass) {
- return (T) Collections.emptyList();
- }
-
- if (Set.class.isAssignableFrom(collectionClass)) {
- if (NavigableSet.class == collectionClass) {
- return (T) Collections.emptyNavigableSet();
- } else if (SortedSet.class == collectionClass) {
- return (T) Collections.emptySortedSet();
- } else {
- return (T) Collections.emptySet();
- }
- } else if (List.class.isAssignableFrom(collectionClass)) {
- return (T) Collections.emptyList();
- }
-
- // 不支持空集合的集合类型
- throw new IllegalArgumentException(StrUtil.format("[{}] is not support to get empty!", collectionClass));
- }
-
/**
* 清除一个或多个集合内的元素，每个集合调用clear()方法
*
@@ -2571,11 +2473,11 @@ public class CollUtil {
/**
* 获取Collection或者iterator的大小，此方法可以处理的对象类型如下：
*
- * - Collection - the collection size
- *
- Map - the map size
- *
- Array - the array size
- *
- Iterator - the number of elements remaining in the iterator
- *
- Enumeration - the number of elements remaining in the enumeration
+ *
- Collection - the collection size
+ * - Map - the map size
+ * - Array - the array size
+ * - Iterator - the number of elements remaining in the iterator
+ * - Enumeration - the number of elements remaining in the enumeration
*
*
* @param object 可以为空的对象
diff --git a/hutool-core/src/main/java/cn/hutool/core/collection/iter/IterUtil.java b/hutool-core/src/main/java/cn/hutool/core/collection/iter/IterUtil.java
index bbfebb164..45ad78135 100644
--- a/hutool-core/src/main/java/cn/hutool/core/collection/iter/IterUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/collection/iter/IterUtil.java
@@ -1,11 +1,8 @@
package cn.hutool.core.collection.iter;
import cn.hutool.core.collection.ListUtil;
-import cn.hutool.core.exceptions.UtilException;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.lang.func.Filter;
-import cn.hutool.core.lang.func.Func1;
-import cn.hutool.core.lang.func.Matcher;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.reflect.FieldUtil;
import cn.hutool.core.reflect.MethodUtil;
@@ -24,7 +21,6 @@ import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
-import java.util.Map.Entry;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Function;
@@ -179,7 +175,7 @@ public class IterUtil {
*/
@SuppressWarnings("unchecked")
public static Map fieldValueMap(final Iterator iter, final String fieldName) {
- return toMap(iter, new HashMap<>(), (value) -> (K) FieldUtil.getFieldValue(value, fieldName));
+ return MapUtil.putAll(new HashMap<>(), iter, (value) -> (K) FieldUtil.getFieldValue(value, fieldName));
}
/**
@@ -195,7 +191,7 @@ public class IterUtil {
*/
@SuppressWarnings("unchecked")
public static Map fieldValueAsMap(final Iterator iter, final String fieldNameForKey, final String fieldNameForValue) {
- return toMap(iter, new HashMap<>(),
+ return MapUtil.putAll(new HashMap<>(), iter,
(value) -> (K) FieldUtil.getFieldValue(value, fieldNameForKey),
(value) -> (V) FieldUtil.getFieldValue(value, fieldNameForValue)
);
@@ -287,24 +283,6 @@ public class IterUtil {
return StrJoiner.of(conjunction).append(iterator, func).toString();
}
- /**
- * 将Entry集合转换为HashMap
- *
- * @param 键类型
- * @param 值类型
- * @param entryIter entry集合
- * @return Map
- */
- public static HashMap toMap(final Iterable> entryIter) {
- final HashMap map = new HashMap<>();
- if (isNotEmpty(entryIter)) {
- for (final Entry entry : entryIter) {
- map.put(entry.getKey(), entry.getValue());
- }
- }
- return map;
- }
-
/**
* 将键列表和值列表转换为Map
* 以键为准，值与键位置需对应。如果键元素数多于值元素，多余部分值用null代替。
@@ -462,64 +440,7 @@ public class IterUtil {
* @since 5.3.6
*/
public static Map toMap(final Iterable iterable, final Function keyMapper, final Function valueMapper) {
- return toMap(MapUtil.newHashMap(), iterable, keyMapper, valueMapper);
- }
-
- /**
- * 将列表转成Map
- *
- * @param resultMap 结果Map，通过传入map对象决定结果的Map类型
- * @param iterable 值列表
- * @param keyMapper Map的键映射
- * @param valueMapper Map的值映射
- * @param 列表值类型
- * @param 键类型
- * @param 值类型
- * @return HashMap
- * @since 5.3.6
- */
- public static Map toMap(Map resultMap, final Iterable iterable, final Function keyMapper, final Function valueMapper) {
- if (null == resultMap) {
- resultMap = MapUtil.newHashMap();
- }
- if (ObjUtil.isNull(iterable)) {
- return resultMap;
- }
-
- for (final T value : iterable) {
- resultMap.put(keyMapper.apply(value), valueMapper.apply(value));
- }
-
- return resultMap;
- }
-
- /**
- * Iterator转List
- * 不判断，直接生成新的List
- *
- * @param 元素类型
- * @param iter {@link Iterator}
- * @return List
- * @since 4.0.6
- */
- public static List toList(final Iterable iter) {
- if (null == iter) {
- return null;
- }
- return toList(iter.iterator());
- }
-
- /**
- * Iterator转List
- * 不判断，直接生成新的List
- *
- * @param 元素类型
- * @param iter {@link Iterator}
- * @return List
- * @since 4.0.6
- */
- public static List toList(final Iterator iter) {
- return ListUtil.of(iter);
+ return MapUtil.putAll(MapUtil.newHashMap(), iterable, keyMapper, valueMapper);
}
/**
@@ -556,7 +477,7 @@ public class IterUtil {
* @since 5.8.0
*/
public static E get(final Iterator iterator, int index) throws IndexOutOfBoundsException {
- if(null == iterator){
+ if (null == iterator) {
return null;
}
Assert.isTrue(index >= 0, "[index] must be >= 0");
@@ -570,32 +491,6 @@ public class IterUtil {
return null;
}
- /**
- * 获取集合的第一个元素，如果集合为空（null或者空集合），返回{@code null}
- *
- * @param 集合元素类型
- * @param iterable {@link Iterable}
- * @return 第一个元素，为空返回{@code null}
- */
- public static T getFirst(final Iterable iterable) {
- return getFirst(getIter(iterable));
- }
-
- /**
- * 获取集合的第一个非空元素
- *
- * @param 集合元素类型
- * @param iterable {@link Iterable}
- * @return 第一个元素
- * @since 5.7.2
- */
- public static T getFirstNoneNull(final Iterable iterable) {
- if (null == iterable) {
- return null;
- }
- return getFirstNoneNull(iterable.iterator());
- }
-
/**
* 获取集合的第一个元素
*
@@ -616,24 +511,24 @@ public class IterUtil {
* @since 5.7.2
*/
public static T getFirstNoneNull(final Iterator iterator) {
- return firstMatch(iterator, Objects::nonNull);
+ return getFirst(iterator, Objects::nonNull);
}
/**
* 返回{@link Iterator}中第一个匹配规则的值
*
- * @param 数组元素类型
- * @param iterator {@link Iterator}
- * @param matcher 匹配接口，实现此接口自定义匹配规则
+ * @param 数组元素类型
+ * @param iterator {@link Iterator}
+ * @param predicate 匹配接口，实现此接口自定义匹配规则
* @return 匹配元素，如果不存在匹配元素或{@link Iterator}为空，返回 {@code null}
* @since 5.7.5
*/
- public static T firstMatch(final Iterator iterator, final Matcher matcher) {
- Assert.notNull(matcher, "Matcher must be not null !");
+ public static T getFirst(final Iterator iterator, final Predicate predicate) {
+ Assert.notNull(predicate, "Matcher must be not null !");
if (null != iterator) {
while (iterator.hasNext()) {
final T next = iterator.next();
- if (matcher.match(next)) {
+ if (predicate.test(next)) {
return next;
}
}
@@ -689,7 +584,7 @@ public class IterUtil {
}
T modified;
- while(iter.hasNext()){
+ while (iter.hasNext()) {
modified = (null == editor) ? iter.next() : editor.apply(iter.next());
if (null != modified) {
result.add(modified);
@@ -706,33 +601,8 @@ public class IterUtil {
* 1、移除指定对象，{@link Predicate#test(Object)}方法返回{@code true}的对象将被使用{@link Iterator#remove()}方法移除。
*
*
- * @param 集合类型
- * @param 集合元素类型
- * @param iter 集合
- * @param predicate 过滤器接口
- * @return 编辑后的集合
- * @since 4.6.5
- */
- public static , E> T remove(final T iter, final Predicate predicate) {
- if (null == iter) {
- return null;
- }
-
- remove(iter.iterator(), predicate);
-
- return iter;
- }
-
- /**
- * 移除集合中满足条件的所有元素，此方法在原集合上直接修改
- * 通过实现{@link Predicate}接口，完成元素的移除，可以实现以下功能：
- *
- *
- * 1、移除指定对象，{@link Predicate#test(Object)}方法返回{@code true}的对象将被使用{@link Iterator#remove()}方法移除。
- *
- *
- * @param 集合元素类型
- * @param iter 集合
+ * @param 集合元素类型
+ * @param iter 集合
* @param predicate 过滤器接口，删除{@link Predicate#test(Object)}为{@code true}的元素
* @return 编辑后的集合
* @since 6.0.0
@@ -760,7 +630,7 @@ public class IterUtil {
* @since 5.7.22
*/
public static List filterToList(final Iterator iter, final Predicate filter) {
- return toList(filtered(iter, filter));
+ return ListUtil.of(filtered(iter, filter));
}
/**
@@ -776,57 +646,6 @@ public class IterUtil {
return new FilterIter<>(iterator, filter);
}
- /**
- * Iterator转换为Map，转换规则为：
- * 按照keyFunc函数规则根据元素对象生成Key，元素作为值
- *
- * @param Map键类型
- * @param Map值类型
- * @param iterator 数据列表
- * @param map Map对象，转换后的键值对加入此Map，通过传入此对象自定义Map类型
- * @param keyFunc 生成key的函数
- * @return 生成的map
- * @since 5.2.6
- */
- public static Map toMap(final Iterator iterator, final Map map, final Func1 keyFunc) {
- return toMap(iterator, map, keyFunc, (value) -> value);
- }
-
- /**
- * 集合转换为Map，转换规则为：
- * 按照keyFunc函数规则根据元素对象生成Key，按照valueFunc函数规则根据元素对象生成value组成新的Map
- *
- * @param Map键类型
- * @param Map值类型
- * @param 元素类型
- * @param iterator 数据列表
- * @param map Map对象，转换后的键值对加入此Map，通过传入此对象自定义Map类型
- * @param keyFunc 生成key的函数
- * @param valueFunc 生成值的策略函数
- * @return 生成的map
- * @since 5.2.6
- */
- public static Map toMap(final Iterator iterator, Map map, final Func1 keyFunc, final Func1 valueFunc) {
- if (null == iterator) {
- return map;
- }
-
- if (null == map) {
- map = MapUtil.newHashMap(true);
- }
-
- E element;
- while (iterator.hasNext()) {
- element = iterator.next();
- try {
- map.put(keyFunc.call(element), valueFunc.call(element));
- } catch (final Exception e) {
- throw new UtilException(e);
- }
- }
- return map;
- }
-
/**
* 返回一个空Iterator
*
diff --git a/hutool-core/src/main/java/cn/hutool/core/convert/impl/ArrayConverter.java b/hutool-core/src/main/java/cn/hutool/core/convert/impl/ArrayConverter.java
index 86862b553..ce4220a6e 100644
--- a/hutool-core/src/main/java/cn/hutool/core/convert/impl/ArrayConverter.java
+++ b/hutool-core/src/main/java/cn/hutool/core/convert/impl/ArrayConverter.java
@@ -1,7 +1,7 @@
package cn.hutool.core.convert.impl;
import cn.hutool.core.codec.Base64;
-import cn.hutool.core.collection.iter.IterUtil;
+import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.convert.AbstractConverter;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.text.StrUtil;
@@ -143,14 +143,14 @@ public class ArrayConverter extends AbstractConverter {
}
} else if (value instanceof Iterable) {
// 可循环对象转数组，可循环对象无法获取长度，因此先转为List后转为数组
- final List list = IterUtil.toList((Iterable) value);
+ final List list = ListUtil.of((Iterable) value);
result = Array.newInstance(targetComponentType, list.size());
for (int i = 0; i < list.size(); i++) {
Array.set(result, i, convertComponentType(targetComponentType, list.get(i)));
}
} else if (value instanceof Iterator) {
// 可循环对象转数组，可循环对象无法获取长度，因此先转为List后转为数组
- final List list = IterUtil.toList((Iterator) value);
+ final List list = ListUtil.of((Iterator) value);
result = Array.newInstance(targetComponentType, list.size());
for (int i = 0; i < list.size(); i++) {
Array.set(result, i, convertComponentType(targetComponentType, list.get(i)));
diff --git a/hutool-core/src/main/java/cn/hutool/core/map/MapUtil.java b/hutool-core/src/main/java/cn/hutool/core/map/MapUtil.java
index a555a9192..e58cd2b25 100755
--- a/hutool-core/src/main/java/cn/hutool/core/map/MapUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/map/MapUtil.java
@@ -2,6 +2,8 @@ package cn.hutool.core.map;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.ListUtil;
+import cn.hutool.core.collection.iter.ArrayIter;
+import cn.hutool.core.collection.iter.IterUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.lang.func.Editor;
import cn.hutool.core.lang.func.Filter;
@@ -9,6 +11,7 @@ import cn.hutool.core.reflect.ConstructorUtil;
import cn.hutool.core.reflect.TypeReference;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.util.ArrayUtil;
+import cn.hutool.core.util.ObjUtil;
import java.util.AbstractMap;
import java.util.ArrayList;
@@ -28,6 +31,7 @@ import java.util.SortedMap;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BiFunction;
+import java.util.function.Function;
import java.util.stream.Collectors;
/**
@@ -292,9 +296,37 @@ public class MapUtil {
*/
@SafeVarargs
public static Map ofEntries(final Map.Entry... entries) {
- final Map map = new HashMap<>();
- for (final Map.Entry pair : entries) {
- map.put(pair.getKey(), pair.getValue());
+ return ofEntries((Iterator>) new ArrayIter<>(entries));
+ }
+
+ /**
+ * 将Entry集合转换为HashMap
+ *
+ * @param 键类型
+ * @param 值类型
+ * @param entryIter entry集合
+ * @return Map
+ */
+ public static HashMap ofEntries(final Iterable> entryIter) {
+ return ofEntries(IterUtil.getIter(entryIter));
+ }
+
+ /**
+ * 将Entry集合转换为HashMap
+ *
+ * @param 键类型
+ * @param 值类型
+ * @param entryIter entry集合
+ * @return Map
+ */
+ public static HashMap ofEntries(final Iterator> entryIter) {
+ final HashMap map = new HashMap<>();
+ if (IterUtil.isNotEmpty(entryIter)) {
+ Entry entry;
+ while (entryIter.hasNext()) {
+ entry = entryIter.next();
+ map.put(entry.getKey(), entry.getValue());
+ }
}
return map;
}
@@ -1365,6 +1397,37 @@ public class MapUtil {
}
}
+ /**
+ * 从Map中获取指定键列表对应的值列表
+ * 如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
+ *
+ * @param 键类型
+ * @param 值类型
+ * @param map {@link Map}
+ * @param keys 键列表
+ * @return 值列表
+ * @since 3.0.8
+ */
+ @SuppressWarnings("unchecked")
+ public static ArrayList valuesOfKeys(final Map map, final K... keys) {
+ return valuesOfKeys(map, (Iterator) new ArrayIter<>(keys));
+ }
+
+ /**
+ * 从Map中获取指定键列表对应的值列表
+ * 如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
+ *
+ * @param 键类型
+ * @param 值类型
+ * @param map {@link Map}
+ * @param keys 键列表
+ * @return 值列表
+ * @since 3.0.9
+ */
+ public static ArrayList valuesOfKeys(final Map map, final Iterable keys) {
+ return valuesOfKeys(map, keys.iterator());
+ }
+
/**
* 从Map中获取指定键列表对应的值列表
* 如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
@@ -1415,4 +1478,80 @@ public class MapUtil {
new AbstractMap.SimpleImmutableEntry<>(key, value) :
new AbstractMap.SimpleEntry<>(key, value);
}
+
+ /**
+ * 将列表按照给定的键生成器规则和值生成器规则，加入到给定的Map中
+ *
+ * @param resultMap 结果Map，通过传入map对象决定结果的Map类型，如果为{@code null}，默认使用HashMap
+ * @param iterable 值列表
+ * @param keyMapper Map的键映射
+ * @param 键类型
+ * @param 值类型
+ * @return HashMap
+ * @since 5.3.6
+ */
+ public static Map putAll(final Map resultMap, final Iterable iterable, final Function keyMapper) {
+ return putAll(resultMap, iterable, keyMapper, Function.identity());
+ }
+
+ /**
+ * 将列表按照给定的键生成器规则和值生成器规则，加入到给定的Map中
+ *
+ * @param resultMap 结果Map，通过传入map对象决定结果的Map类型
+ * @param iterable 值列表
+ * @param keyMapper Map的键映射
+ * @param valueMapper Map的值映射
+ * @param 列表值类型
+ * @param 键类型
+ * @param 值类型
+ * @return HashMap
+ * @since 5.3.6
+ */
+ public static Map putAll(final Map resultMap, final Iterable iterable, final Function keyMapper, final Function valueMapper) {
+ return putAll(resultMap, IterUtil.getIter(iterable), keyMapper, valueMapper);
+ }
+
+ /**
+ * 将列表按照给定的键生成器规则和值生成器规则，加入到给定的Map中
+ *
+ * @param resultMap 结果Map，通过传入map对象决定结果的Map类型，如果为{@code null}，默认使用HashMap
+ * @param iterator 值列表
+ * @param keyMapper Map的键映射
+ * @param 键类型
+ * @param 值类型
+ * @return HashMap
+ * @since 5.3.6
+ */
+ public static Map putAll(final Map resultMap, final Iterator iterator, final Function keyMapper) {
+ return putAll(resultMap, iterator, keyMapper, Function.identity());
+ }
+
+ /**
+ * 将列表按照给定的键生成器规则和值生成器规则，加入到给定的Map中
+ *
+ * @param resultMap 结果Map，通过传入map对象决定结果的Map类型，如果为{@code null}，默认使用HashMap
+ * @param iterator 值列表
+ * @param keyMapper Map的键映射
+ * @param valueMapper Map的值映射
+ * @param 列表值类型
+ * @param 键类型
+ * @param 值类型
+ * @return HashMap
+ * @since 5.3.6
+ */
+ public static Map putAll(Map resultMap, final Iterator iterator, final Function keyMapper, final Function valueMapper) {
+ if (null == resultMap) {
+ resultMap = MapUtil.newHashMap();
+ }
+ if (ObjUtil.isNull(iterator)) {
+ return resultMap;
+ }
+
+ T value;
+ while (iterator.hasNext()) {
+ value = iterator.next();
+ resultMap.put(keyMapper.apply(value), valueMapper.apply(value));
+ }
+ return resultMap;
+ }
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/collection/CollUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/collection/CollUtilTest.java
index 1d831cab4..964a79dc8 100755
--- a/hutool-core/src/test/java/cn/hutool/core/collection/CollUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/collection/CollUtilTest.java
@@ -96,23 +96,6 @@ public class CollUtilTest {
Assert.assertNotNull(set);
}
- @Test
- public void valuesOfKeysTest() {
- final Dict v1 = Dict.create().set("id", 12).set("name", "张三").set("age", 23);
- final Dict v2 = Dict.create().set("age", 13).set("id", 15).set("name", "李四");
-
- final String[] keys = v1.keySet().toArray(new String[0]);
- final ArrayList