createCollection();
+
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/map/multi/CollectionValueMap.java b/hutool-core/src/main/java/cn/hutool/core/map/multi/CollectionValueMap.java
index 3f9dd8bcf..e798c7602 100644
--- a/hutool-core/src/main/java/cn/hutool/core/map/multi/CollectionValueMap.java
+++ b/hutool-core/src/main/java/cn/hutool/core/map/multi/CollectionValueMap.java
@@ -6,97 +6,67 @@ import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
+import java.util.function.Supplier;
/**
- * 值作为集合的Map实现，通过调用putValue可以在相同key时加入多个值，多个值用集合表示
- * 此类可以通过传入函数自定义集合类型的创建规则
+ * {@link MultiValueMap}的通用实现，可视为值为{@link Collection}集合的{@link Map}集合。
+ * 构建时指定一个工厂方法用于生成原始的{@link Map}集合，然后再指定一个工厂方法用于生成自定义类型的值集合。
+ * 当调用{@link MultiValueMap}中格式为“putXXX”的方法时，将会为key创建值集合，并将key相同的值追加到集合中
*
* @param 键类型
* @param 值类型
* @author looly
* @since 4.3.3
*/
-public class CollectionValueMap extends AbsCollValueMap> {
+public class CollectionValueMap extends AbsCollValueMap {
+
private static final long serialVersionUID = 9012989578038102983L;
- private final Func0> collectionCreateFunc;
+ private final Func0> collFactory;
// ------------------------------------------------------------------------- Constructor start
/**
- * 构造
+ * 创建一个多值映射集合，基于{@code mapFactory}与{@code collFactory}实现
+ *
+ * @param mapFactory 生成集合的工厂方法
+ * @param collFactory 生成值集合的工厂方法
+ */
+ public CollectionValueMap(Supplier>> mapFactory, Func0> collFactory) {
+ super(mapFactory);
+ this.collFactory = collFactory;
+ }
+
+ /**
+ * 创建一个多值映射集合，默认基于{@link HashMap}与{@code collFactory}生成的集合实现
+ *
+ * @param collFactory 生成值集合的工厂方法
+ */
+ public CollectionValueMap(Func0> collFactory) {
+ this.collFactory = collFactory;
+ }
+
+ /**
+ * 创建一个多值映射集合，默认基于{@link HashMap}与{@link ArrayList}实现
*/
public CollectionValueMap() {
- this(DEFAULT_INITIAL_CAPACITY);
+ this.collFactory = ArrayList::new;
}
/**
- * 构造
+ * 创建一个多值映射集合，默认基于{@link HashMap}与{@link ArrayList}实现
*
- * @param initialCapacity 初始大小
+ * @param map 提供数据的原始集合
*/
- public CollectionValueMap(final int initialCapacity) {
- this(initialCapacity, DEFAULT_LOAD_FACTOR);
+ public CollectionValueMap(Map> map) {
+ super(map);
+ this.collFactory = ArrayList::new;
}
- /**
- * 构造
- *
- * @param m Map
- */
- public CollectionValueMap(final Map> m) {
- this(DEFAULT_LOAD_FACTOR, m);
- }
-
- /**
- * 构造
- *
- * @param loadFactor 加载因子
- * @param m Map
- */
- public CollectionValueMap(final float loadFactor, final Map> m) {
- this(loadFactor, m, ArrayList::new);
- }
-
- /**
- * 构造
- *
- * @param initialCapacity 初始大小
- * @param loadFactor 加载因子
- */
- public CollectionValueMap(final int initialCapacity, final float loadFactor) {
- this(initialCapacity, loadFactor, ArrayList::new);
- }
-
- /**
- * 构造
- *
- * @param loadFactor 加载因子
- * @param m Map
- * @param collectionCreateFunc Map中值的集合创建函数
- * @since 5.7.4
- */
- public CollectionValueMap(final float loadFactor, final Map> m, final Func0> collectionCreateFunc) {
- this(m.size(), loadFactor, collectionCreateFunc);
- this.putAll(m);
- }
-
- /**
- * 构造
- *
- * @param initialCapacity 初始大小
- * @param loadFactor 加载因子
- * @param collectionCreateFunc Map中值的集合创建函数
- * @since 5.7.4
- */
- public CollectionValueMap(final int initialCapacity, final float loadFactor, final Func0> collectionCreateFunc) {
- super(new HashMap<>(initialCapacity, loadFactor));
- this.collectionCreateFunc = collectionCreateFunc;
- }
// ------------------------------------------------------------------------- Constructor end
@Override
protected Collection createCollection() {
- return collectionCreateFunc.callWithRuntimeException();
+ return collFactory.callWithRuntimeException();
}
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/map/multi/ListValueMap.java b/hutool-core/src/main/java/cn/hutool/core/map/multi/ListValueMap.java
index ab3b29c33..90f79cc01 100644
--- a/hutool-core/src/main/java/cn/hutool/core/map/multi/ListValueMap.java
+++ b/hutool-core/src/main/java/cn/hutool/core/map/multi/ListValueMap.java
@@ -1,10 +1,7 @@
package cn.hutool.core.map.multi;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
+import java.util.function.Supplier;
/**
* 值作为集合List的Map实现，通过调用putValue可以在相同key时加入多个值，多个值用集合表示
@@ -15,55 +12,35 @@ import java.util.Map;
* @param 值类型
* @since 4.3.3
*/
-public class ListValueMap extends AbsCollValueMap> {
+public class ListValueMap extends AbsCollValueMap {
private static final long serialVersionUID = 6044017508487827899L;
// ------------------------------------------------------------------------- Constructor start
+
/**
- * 构造
+ * 基于{@code mapFactory}创建一个值为{@link List}的多值映射集合
+ *
+ * @param mapFactory 创建集合的工厂反方
+ */
+ public ListValueMap(Supplier>> mapFactory) {
+ super(mapFactory);
+ }
+
+ /**
+ * 基于{@link HashMap}创建一个值为{@link List}的多值映射集合
+ *
+ * @param map 提供数据的原始集合
+ */
+ public ListValueMap(Map> map) {
+ super(map);
+ }
+
+ /**
+ * 基于{@link HashMap}创建一个值为{@link List}的多值映射集合
*/
public ListValueMap() {
- this(DEFAULT_INITIAL_CAPACITY);
}
- /**
- * 构造
- *
- * @param initialCapacity 初始大小
- */
- public ListValueMap(final int initialCapacity) {
- this(initialCapacity, DEFAULT_LOAD_FACTOR);
- }
-
- /**
- * 构造
- *
- * @param m Map
- */
- public ListValueMap(final Map> m) {
- this(DEFAULT_LOAD_FACTOR, m);
- }
-
- /**
- * 构造
- *
- * @param loadFactor 加载因子
- * @param m Map
- */
- public ListValueMap(final float loadFactor, final Map> m) {
- this(m.size(), loadFactor);
- this.putAllValues(m);
- }
-
- /**
- * 构造
- *
- * @param initialCapacity 初始大小
- * @param loadFactor 加载因子
- */
- public ListValueMap(final int initialCapacity, final float loadFactor) {
- super(new HashMap<>(initialCapacity, loadFactor));
- }
// ------------------------------------------------------------------------- Constructor end
@Override
diff --git a/hutool-core/src/main/java/cn/hutool/core/map/multi/MultiValueMap.java b/hutool-core/src/main/java/cn/hutool/core/map/multi/MultiValueMap.java
new file mode 100644
index 000000000..e7af04b7e
--- /dev/null
+++ b/hutool-core/src/main/java/cn/hutool/core/map/multi/MultiValueMap.java
@@ -0,0 +1,266 @@
+package cn.hutool.core.map.multi;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.ArrayUtil;
+
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.Collectors;
+
+/**
+ * 一个键对应多个值的集合{@link Map}实现，提供针对键对应的值集合中的元素而非值集合本身的一些快捷操作，
+ * 本身可作为一个值为{@link Collection}类型的{@link Map}使用。
+ *
+ *
值集合类型
+ * 值集合的类型由接口的实现类自行维护，当通过{@link MultiValueMap}定义的方法进行增删改操作时，
+ * 实现类应保证通过通过实例方法获得的集合类型都一致。但是若用户直接通过{@link Map}定义的方法进行增删改操作时，
+ * 实例无法保证通过实例方法获得的集合类型都一致。
+ * 因此，若无必要则更推荐通过{@link MultiValueMap}定义的方法进行操作。
+ *
+ *
对值集合的修改
+ * 当通过实例方法获得值集合时，若该集合允许修改，则对值集合的修改将会影响到其所属的{@link MultiValueMap}实例，反之亦然。
+ * 因此当同时遍历当前实例或者值集合时，若存在写操作，则需要注意可能引发的{@link ConcurrentModificationException}。
+ *
+ * @author huangchengxing
+ * @since 6.0.0
+ * @see AbsCollValueMap
+ * @see CollectionValueMap
+ * @see ListValueMap
+ * @see SetValueMap
+ */
+public interface MultiValueMap extends Map> {
+
+ // =================== override ===================
+
+ /**
+ * 更新键对应的值集合
+ * 注意：该操作将移除键对应的旧值集合，若仅需向值集合追加应值，则应使用{@link #putAllValues(Object, Collection)}
+ *
+ * @param key 键
+ * @param value 键对应的新值集合
+ * @return 旧值集合
+ */
+ @SuppressWarnings("AbstractMethodOverridesAbstractMethod")
+ @Override
+ Collection put(K key, Collection value);
+
+ /**
+ * 更新全部键的值集合
+ * 注意：该操作将移除键对应的旧值集合，若仅需向值集合追加应值，则应使用{@link #putAllValues(Object, Collection)}
+ *
+ * @param map 需要更新的键值对集合
+ */
+ @SuppressWarnings("AbstractMethodOverridesAbstractMethod")
+ @Override
+ void putAll(Map> map);
+
+ // =================== write operate ===================
+
+ /**
+ * 将集合中的全部键值对追加到当前实例中，效果等同于：
+ * {@code
+ * for (Entry> entry : m.entrySet()) {
+ * K key = entry.getKey();
+ * Collection coll = entry.getValues();
+ * for (V val : coll) {
+ * map.putValue(key, val)
+ * }
+ * }
+ * }
+ *
+ * @param m 待添加的集合
+ */
+ default void putAllValues(final Map> m) {
+ if (CollUtil.isNotEmpty(m)) {
+ m.forEach(this::putAllValues);
+ }
+ }
+
+ /**
+ * 将集合中的全部元素对追加到指定键对应的值集合中，效果等同于：
+ * {@code
+ * for (V val : coll) {
+ * map.putValue(key, val)
+ * }
+ * }
+ *
+ * @param key 键
+ * @param coll 待添加的值集合
+ * @return 是否成功添加
+ */
+ boolean putAllValues(K key, final Collection coll);
+
+ /**
+ * 将数组中的全部元素追加到指定的值集合中，效果等同于：
+ * {@code
+ * for (V val : values) {
+ * map.putValue(key, val)
+ * }
+ * }
+ *
+ * @param key 键
+ * @param values 待添加的值
+ * @return boolean
+ */
+ @SuppressWarnings("unchecked")
+ default boolean putValues(final K key, final V... values) {
+ return ArrayUtil.isNotEmpty(values) && putAllValues(key, Arrays.asList(values));
+ }
+
+ /**
+ * 向指定键对应的值集合追加值，效果等同于：
+ * {@code
+ * Collection coll = map.get(key);
+ * if(null == coll) {
+ * coll.add(value);
+ * map.put(coll);
+ * } else {
+ * coll.add(value);
+ * }
+ * }
+ *
+ * @param key 键
+ * @param value 值
+ * @return 是否成功添加
+ */
+ boolean putValue(final K key, final V value);
+
+ /**
+ * 将值从指定键下的值集合中删除
+ *
+ * @param key 键
+ * @param value 值
+ * @return 是否成功删除
+ */
+ boolean removeValue(final K key, final V value);
+
+ /**
+ * 将一批值从指定键下的值集合中删除
+ *
+ * @param key 键
+ * @param values 值数组
+ * @return 是否成功删除
+ */
+ @SuppressWarnings("unchecked")
+ default boolean removeValues(final K key, final V... values) {
+ return ArrayUtil.isNotEmpty(values) && removeAllValues(key, Arrays.asList(values));
+ }
+
+ /**
+ * 将一批值从指定键下的值集合中删除
+ *
+ * @param key 键
+ * @param values 值集合
+ * @return 是否成功删除
+ */
+ boolean removeAllValues(final K key, final Collection values);
+
+ /**
+ * 根据条件过滤所有值集合中的值，并以新值生成新的值集合，新集合中的值集合类型与当前实例的默认值集合类型保持一致
+ *
+ * @param filter 判断方法
+ * @return 当前实例
+ */
+ default MultiValueMap filterAllValues(Predicate filter) {
+ return filterAllValues((k, v) -> filter.test(v));
+ }
+
+ /**
+ * 根据条件过滤所有值集合中的值，并以新值生成新的值集合，新集合中的值集合类型与当前实例的默认值集合类型保持一致
+ *
+ * @param filter 判断方法
+ * @return 当前实例
+ */
+ MultiValueMap filterAllValues(BiPredicate filter);
+
+ /**
+ * 根据条件替换所有值集合中的值，并以新值生成新的值集合，新集合中的值集合类型与当前实例的默认值集合类型保持一致
+ *
+ * @param operate 替换方法
+ * @return 当前实例
+ */
+ default MultiValueMap replaceAllValues(UnaryOperator operate) {
+ return replaceAllValues((k, v) -> operate.apply(v));
+ }
+
+ /**
+ * 根据条件替换所有值集合中的值，并以新值生成新的值集合，新集合中的值集合类型与当前实例的默认值集合类型保持一致
+ *
+ * @param operate 替换方法
+ * @return 当前实例
+ */
+ MultiValueMap replaceAllValues(BiFunction operate);
+
+ // =================== read operate ===================
+
+ /**
+ * 获取指定序号的值，若值不存在，返回{@code null}
+ *
+ * @param key 键
+ * @param index 第几个值的索引，越界返回null
+ * @return 值或null
+ */
+ default V getValue(K key, int index) {
+ final Collection collection = get(key);
+ return CollUtil.get(collection, index);
+ }
+
+ /**
+ * 获取键对应的值，若值不存在，则返回{@link Collections#emptyList()}。效果等同于：
+ * {@code
+ * map.getOrDefault(key, Collections.emptyList())
+ * }
+ *
+ * @param key 键
+ * @return 值集合
+ */
+ default Collection getValues(final K key) {
+ return getOrDefault(key, Collections.emptyList());
+ }
+
+ /**
+ * 获取键对应值的数量，若键对应的值不存在，则返回{@code 0}
+ *
+ * @param key 键
+ * @return 值的数量
+ */
+ default int size(final K key) {
+ return getValues(key).size();
+ }
+
+ /**
+ * 遍历所有键值对，效果等同于：
+ * {@code
+ * for (Entry> entry : entrySet()) {
+ * K key = entry.getKey();
+ * Collection coll = entry.getValues();
+ * for (V val : coll) {
+ * consumer.accept(key, val);
+ * }
+ * }
+ * }
+ *
+ * @param consumer 操作
+ */
+ default void allForEach(BiConsumer consumer) {
+ forEach((k, coll) -> coll.forEach(v -> consumer.accept(k, v)));
+ }
+
+ /**
+ * 获取所有的值，效果等同于：
+ * {@code
+ * List results = new ArrayList<>();
+ * for (Collection coll : values()) {
+ * results.addAll(coll);
+ * }
+ * }
+ *
+ * @return 值
+ */
+ default Collection allValues() {
+ return values().stream()
+ .flatMap(Collection::stream)
+ .collect(Collectors.toList());
+ }
+
+}
diff --git a/hutool-core/src/main/java/cn/hutool/core/map/multi/SetValueMap.java b/hutool-core/src/main/java/cn/hutool/core/map/multi/SetValueMap.java
index 05a4fdcac..7b76611c7 100644
--- a/hutool-core/src/main/java/cn/hutool/core/map/multi/SetValueMap.java
+++ b/hutool-core/src/main/java/cn/hutool/core/map/multi/SetValueMap.java
@@ -1,10 +1,7 @@
package cn.hutool.core.map.multi;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.LinkedHashSet;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
+import java.util.function.Supplier;
/**
* 值作为集合Set（LinkedHashSet）的Map实现，通过调用putValue可以在相同key时加入多个值，多个值用集合表示
@@ -15,59 +12,40 @@ import java.util.Set;
* @param 值类型
* @since 4.3.3
*/
-public class SetValueMap extends AbsCollValueMap> {
+public class SetValueMap extends AbsCollValueMap {
private static final long serialVersionUID = 6044017508487827899L;
// ------------------------------------------------------------------------- Constructor start
+
/**
- * 构造
+ * 基于{@code mapFactory}创建一个值为{@link Set}的多值映射集合
+ *
+ * @param mapFactory 创建集合的工厂反方
+ */
+ public SetValueMap(Supplier>> mapFactory) {
+ super(mapFactory);
+ }
+
+ /**
+ * 基于{@link HashMap}创建一个值为{@link Set}的多值映射集合
+ *
+ * @param map 提供数据的原始集合
+ */
+ public SetValueMap(Map> map) {
+ super(map);
+ }
+
+ /**
+ * 基于{@link HashMap}创建一个值为{@link Set}的多值映射集合
*/
public SetValueMap() {
- this(DEFAULT_INITIAL_CAPACITY);
}
- /**
- * 构造
- *
- * @param initialCapacity 初始大小
- */
- public SetValueMap(final int initialCapacity) {
- this(initialCapacity, DEFAULT_LOAD_FACTOR);
- }
-
- /**
- * 构造
- *
- * @param m Map
- */
- public SetValueMap(final Map> m) {
- this(DEFAULT_LOAD_FACTOR, m);
- }
-
- /**
- * 构造
- *
- * @param loadFactor 加载因子
- * @param m Map
- */
- public SetValueMap(final float loadFactor, final Map> m) {
- this(m.size(), loadFactor);
- this.putAllValues(m);
- }
-
- /**
- * 构造
- *
- * @param initialCapacity 初始大小
- * @param loadFactor 加载因子
- */
- public SetValueMap(final int initialCapacity, final float loadFactor) {
- super(new HashMap<>(initialCapacity, loadFactor));
- }
// ------------------------------------------------------------------------- Constructor end
@Override
protected Set createCollection() {
return new LinkedHashSet<>(DEFAULT_COLLECTION_INITIAL_CAPACITY);
}
+
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/map/multi/package-info.java b/hutool-core/src/main/java/cn/hutool/core/map/multi/package-info.java
index 2bf5b685f..25b130d0d 100644
--- a/hutool-core/src/main/java/cn/hutool/core/map/multi/package-info.java
+++ b/hutool-core/src/main/java/cn/hutool/core/map/multi/package-info.java
@@ -1,5 +1,24 @@
/**
- * 多参数类型的Map实现，包括集合类型值的Map和Table
+ * 多参数类型的Map实现，包括集合类型值的MultiValueMap和Table
+ *
+ * - MultiValueMap：一个键对应多个值的集合的实现，类似于树的结构。
+ * - Table：使用两个键映射到一个值，类似于表格结构。
+ *
+ *
+ *
+ * MultiValueMap
+ * |
+ * AbsCollValueMap
+ * ||
+ * [CollectionValueMap, SetValueMap, ListValueMap]
+ *
+ *
+ * Table
+ * |
+ * AbsTable
+ * ||
+ * [RowKeyTable]
+ *
*
* @author looly
*
diff --git a/hutool-core/src/main/java/cn/hutool/core/net/multipart/MultipartFormData.java b/hutool-core/src/main/java/cn/hutool/core/net/multipart/MultipartFormData.java
index 34ff7521d..dfb173352 100644
--- a/hutool-core/src/main/java/cn/hutool/core/net/multipart/MultipartFormData.java
+++ b/hutool-core/src/main/java/cn/hutool/core/net/multipart/MultipartFormData.java
@@ -3,11 +3,12 @@ package cn.hutool.core.net.multipart;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.map.multi.ListValueMap;
+import cn.hutool.core.map.multi.MultiValueMap;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
-import java.util.List;
+import java.util.Collection;
import java.util.Map;
import java.util.Set;
@@ -20,9 +21,9 @@ import java.util.Set;
public class MultipartFormData {
/** 请求参数 */
- private final ListValueMap requestParameters = new ListValueMap<>();
+ private final MultiValueMap requestParameters = new ListValueMap<>();
/** 请求文件 */
- private final ListValueMap requestFiles = new ListValueMap<>();
+ private final MultiValueMap requestFiles = new ListValueMap<>();
/** 上传选项 */
private final UploadSetting setting;
@@ -101,9 +102,9 @@ public class MultipartFormData {
* @return null未找到，否则返回值
*/
public String getParam(final String paramName) {
- final List values = getListParam(paramName);
+ final Collection values = getListParam(paramName);
if (CollUtil.isNotEmpty(values)) {
- return values.get(0);
+ return CollUtil.get(values, 0);
}
return null;
}
@@ -122,7 +123,7 @@ public class MultipartFormData {
* @return 数组表单值
*/
public String[] getArrayParam(final String paramName) {
- final List listParam = getListParam(paramName);
+ final Collection listParam = getListParam(paramName);
if(null != listParam){
return listParam.toArray(new String[0]);
}
@@ -136,7 +137,7 @@ public class MultipartFormData {
* @return 数组表单值
* @since 5.3.0
*/
- public List getListParam(final String paramName) {
+ public Collection getListParam(final String paramName) {
return requestParameters.get(paramName);
}
@@ -154,7 +155,7 @@ public class MultipartFormData {
*
* @return 所有属性的集合
*/
- public ListValueMap getParamListMap() {
+ public MultiValueMap getParamListMap() {
return this.requestParameters;
}
@@ -181,7 +182,7 @@ public class MultipartFormData {
* @return 上传的文件列表
*/
public UploadFile[] getFiles(final String paramName) {
- final List fileList = getFileList(paramName);
+ final Collection fileList = getFileList(paramName);
if(null != fileList){
return fileList.toArray(new UploadFile[0]);
}
@@ -196,7 +197,7 @@ public class MultipartFormData {
* @return 上传的文件列表
* @since 5.3.0
*/
- public List getFileList(final String paramName) {
+ public Collection getFileList(final String paramName) {
return requestFiles.get(paramName);
}
@@ -223,7 +224,7 @@ public class MultipartFormData {
*
* @return 文件映射
*/
- public ListValueMap getFileListValueMap() {
+ public MultiValueMap getFileListValueMap() {
return this.requestFiles;
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/util/ObjUtil.java b/hutool-core/src/main/java/cn/hutool/core/util/ObjUtil.java
index c193bd571..3d88ceb10 100644
--- a/hutool-core/src/main/java/cn/hutool/core/util/ObjUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/util/ObjUtil.java
@@ -301,6 +301,7 @@ public class ObjUtil {
/**
* 如果给定对象为{@code null} 返回默认值, 如果不为null 返回自定义handle处理后的返回值
*
+ * @param 返回值类型
* @param 被检查对象类型
* @param source Object 类型对象
* @param handler 非空时自定义的处理方法
@@ -308,13 +309,29 @@ public class ObjUtil {
* @return 处理后的返回值
* @since 6.0.0
*/
- public static T defaultIfNull(final Object source, final Function handler, final Supplier defaultSupplier) {
+ public static R defaultIfNull(final T source, final Function handler, final Supplier defaultSupplier) {
if (isNotNull(source)) {
return handler.apply(source);
}
return defaultSupplier.get();
}
+ /**
+ * 如果给定对象为{@code null}返回默认值, 如果不为null返回自定义handle处理后的返回值
+ *
+ * @param 返回值类型
+ * @param 被检查对象类型
+ * @param source Object 类型对象
+ * @param handler 非空时自定义的处理方法
+ * @param defaultValue 默认为空的返回值
+ * @return 处理后的返回值
+ * @since 6.0.0
+ */
+ public static R defaultIfNull(
+ final T source, final Function handler, final R defaultValue) {
+ return isNull(source) ? defaultValue : handler.apply(source);
+ }
+
/**
* 克隆对象
* 如果对象实现Cloneable接口，调用其clone方法
diff --git a/hutool-core/src/test/java/cn/hutool/core/annotation/AnnotationForTest.java b/hutool-core/src/test/java/cn/hutool/core/annotation/AnnotationForTest.java
deleted file mode 100755
index f109e836d..000000000
--- a/hutool-core/src/test/java/cn/hutool/core/annotation/AnnotationForTest.java
+++ /dev/null
@@ -1,29 +0,0 @@
-package cn.hutool.core.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * 用于单元测试的注解类
- * 注解类相关说明见：https://www.cnblogs.com/xdp-gacl/p/3622275.html
- *
- * @author looly
- */
-// Retention注解决定MyAnnotation注解的生命周期
-@Retention(RetentionPolicy.RUNTIME)
-// Target注解决定MyAnnotation注解可以加在哪些成分上，如加在类身上，或者属性身上，或者方法身上等成分
-@Target({ ElementType.METHOD, ElementType.TYPE })
-public @interface AnnotationForTest {
-
- /**
- * 注解的默认属性值
- *
- * @return 属性值
- */
- String value() default "";
-
- @Alias("value")
- String retry() default "";
-}
diff --git a/hutool-core/src/test/java/cn/hutool/core/annotation/AnnotationUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/annotation/AnnotationUtilTest.java
index 3032ed5ca..5d3612bc8 100755
--- a/hutool-core/src/test/java/cn/hutool/core/annotation/AnnotationUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/annotation/AnnotationUtilTest.java
@@ -1,49 +1,136 @@
package cn.hutool.core.annotation;
+import cn.hutool.core.util.ObjUtil;
import org.junit.Assert;
import org.junit.Test;
-import java.lang.annotation.Annotation;
+import java.lang.annotation.*;
+import java.util.Map;
+/**
+ * test for {@link AnnotationUtil}
+ */
public class AnnotationUtilTest {
@Test
- public void getCombinationAnnotationsTest(){
- final Annotation[] annotations = AnnotationUtil.getAnnotations(ClassWithAnnotation.class, true);
- Assert.assertNotNull(annotations);
+ public void testToCombination() {
+ final CombinationAnnotationElement element = AnnotationUtil.toCombination(ClassForTest.class);
+ Assert.assertEquals(2, element.getAnnotations().length);
+ }
+
+ @Test
+ public void testGetAnnotations() {
+ Annotation[] annotations = AnnotationUtil.getAnnotations(ClassForTest.class, true);
Assert.assertEquals(2, annotations.length);
- }
-
- @Test
- public void getCombinationAnnotationsWithClassTest(){
- final AnnotationForTest[] annotations = AnnotationUtil.getCombinationAnnotations(ClassWithAnnotation.class, AnnotationForTest.class);
- Assert.assertNotNull(annotations);
+ annotations = AnnotationUtil.getAnnotations(ClassForTest.class, false);
Assert.assertEquals(1, annotations.length);
- Assert.assertEquals("测试", annotations[0].value());
}
@Test
- public void getAnnotationValueTest() {
- final Object value = AnnotationUtil.getAnnotationValue(ClassWithAnnotation.class, AnnotationForTest.class);
- Assert.assertEquals("测试", value);
-
+ public void testGetCombinationAnnotations() {
+ final MetaAnnotationForTest[] annotations = AnnotationUtil.getCombinationAnnotations(ClassForTest.class, MetaAnnotationForTest.class);
+ Assert.assertEquals(1, annotations.length);
}
@Test
- public void getAnnotationSyncAlias() {
- // 直接获取
- Assert.assertEquals("", ClassWithAnnotation.class.getAnnotation(AnnotationForTest.class).retry());
+ public void testAnnotations() {
+ MetaAnnotationForTest[] annotations1 = AnnotationUtil.getAnnotations(ClassForTest.class, false, MetaAnnotationForTest.class);
+ Assert.assertEquals(0, annotations1.length);
+ annotations1 = AnnotationUtil.getAnnotations(ClassForTest.class, true, MetaAnnotationForTest.class);
+ Assert.assertEquals(1, annotations1.length);
- // 加别名适配
- final AnnotationForTest annotation = AnnotationUtil.getAnnotationAlias(ClassWithAnnotation.class, AnnotationForTest.class);
- Assert.assertEquals("测试", annotation.retry());
+ Annotation[] annotations2 = AnnotationUtil.getAnnotations(
+ ClassForTest.class, false, t -> ObjUtil.equals(t.annotationType(), MetaAnnotationForTest.class)
+ );
+ Assert.assertEquals(0, annotations2.length);
+ annotations2 = AnnotationUtil.getAnnotations(
+ ClassForTest.class, true, t -> ObjUtil.equals(t.annotationType(), MetaAnnotationForTest.class)
+ );
+ Assert.assertEquals(1, annotations2.length);
}
- @AnnotationForTest("测试")
- @RepeatAnnotationForTest
- static class ClassWithAnnotation{
- public void test(){
-
- }
+ @Test
+ public void testGetAnnotation() {
+ final MetaAnnotationForTest annotation = AnnotationUtil.getAnnotation(ClassForTest.class, MetaAnnotationForTest.class);
+ Assert.assertNotNull(annotation);
}
+
+ @Test
+ public void testHasAnnotation() {
+ Assert.assertTrue(AnnotationUtil.hasAnnotation(ClassForTest.class, MetaAnnotationForTest.class));
+ }
+
+ @Test
+ public void testGetAnnotationValue() {
+ final AnnotationForTest annotation = ClassForTest.class.getAnnotation(AnnotationForTest.class);
+ Assert.assertEquals(annotation.value(), AnnotationUtil.getAnnotationValue(ClassForTest.class, AnnotationForTest.class));
+ Assert.assertEquals(annotation.value(), AnnotationUtil.getAnnotationValue(ClassForTest.class, AnnotationForTest.class, "value"));
+ Assert.assertNull(AnnotationUtil.getAnnotationValue(ClassForTest.class, AnnotationForTest.class, "property"));
+ }
+
+ @Test
+ public void testGetAnnotationValueMap() {
+ final AnnotationForTest annotation = ClassForTest.class.getAnnotation(AnnotationForTest.class);
+ final Map valueMap = AnnotationUtil.getAnnotationValueMap(ClassForTest.class, AnnotationForTest.class);
+ Assert.assertNotNull(valueMap);
+ Assert.assertEquals(1, valueMap.size());
+ Assert.assertEquals(annotation.value(), valueMap.get("value"));
+ }
+
+ @Test
+ public void testGetRetentionPolicy() {
+ final RetentionPolicy policy = AnnotationForTest.class.getAnnotation(Retention.class).value();
+ Assert.assertEquals(policy, AnnotationUtil.getRetentionPolicy(AnnotationForTest.class));
+ }
+
+ @Test
+ public void testGetTargetType() {
+ final ElementType[] types = AnnotationForTest.class.getAnnotation(Target.class).value();
+ Assert.assertArrayEquals(types, AnnotationUtil.getTargetType(AnnotationForTest.class));
+ }
+
+ @Test
+ public void testIsDocumented() {
+ Assert.assertFalse(AnnotationUtil.isDocumented(AnnotationForTest.class));
+ }
+
+ @Test
+ public void testIsInherited() {
+ Assert.assertFalse(AnnotationUtil.isInherited(AnnotationForTest.class));
+ }
+
+ @Test
+ public void testSetValue() {
+ final AnnotationForTest annotation = ClassForTest.class.getAnnotation(AnnotationForTest.class);
+ final String newValue = "is a new value";
+ Assert.assertNotEquals(newValue, annotation.value());
+ AnnotationUtil.setValue(annotation, "value", newValue);
+ Assert.assertEquals(newValue, annotation.value());
+ }
+
+ @Test
+ public void testGetAnnotationAlias() {
+ final MetaAnnotationForTest annotation = AnnotationUtil.getAnnotationAlias(AnnotationForTest.class, MetaAnnotationForTest.class);
+ Assert.assertEquals(annotation.value(), annotation.alias());
+ Assert.assertEquals(MetaAnnotationForTest.class, annotation.annotationType());
+ }
+
+ @Target(ElementType.TYPE_USE)
+ @Retention(RetentionPolicy.RUNTIME)
+ private @interface MetaAnnotationForTest{
+ @Alias(value = "alias")
+ String value() default "";
+ String alias() default "";
+ }
+
+ @MetaAnnotationForTest("foo")
+ @Target(ElementType.TYPE_USE)
+ @Retention(RetentionPolicy.RUNTIME)
+ private @interface AnnotationForTest{
+ String value() default "";
+ }
+
+ @AnnotationForTest("foo")
+ private static class ClassForTest{}
+
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/annotation/CombinationAnnotationElementTest.java b/hutool-core/src/test/java/cn/hutool/core/annotation/CombinationAnnotationElementTest.java
new file mode 100644
index 000000000..cb81ef2cb
--- /dev/null
+++ b/hutool-core/src/test/java/cn/hutool/core/annotation/CombinationAnnotationElementTest.java
@@ -0,0 +1,60 @@
+package cn.hutool.core.annotation;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.lang.annotation.*;
+
+/**
+ * test for {@link CombinationAnnotationElement}
+ */
+public class CombinationAnnotationElementTest {
+
+ @Test
+ public void testOf() {
+ CombinationAnnotationElement element = CombinationAnnotationElement.of(ClassForTest.class, a -> true);
+ Assert.assertNotNull(element);
+ }
+
+ @Test
+ public void testIsAnnotationPresent() {
+ CombinationAnnotationElement element = CombinationAnnotationElement.of(ClassForTest.class, a -> true);
+ Assert.assertTrue(element.isAnnotationPresent(MetaAnnotationForTest.class));
+ }
+
+ @Test
+ public void testGetAnnotation() {
+ AnnotationForTest annotation1 = ClassForTest.class.getAnnotation(AnnotationForTest.class);
+ MetaAnnotationForTest annotation2 = AnnotationForTest.class.getAnnotation(MetaAnnotationForTest.class);
+ CombinationAnnotationElement element = CombinationAnnotationElement.of(ClassForTest.class, a -> true);
+ Assert.assertEquals(annotation1, element.getAnnotation(AnnotationForTest.class));
+ Assert.assertEquals(annotation2, element.getAnnotation(MetaAnnotationForTest.class));
+ }
+
+ @Test
+ public void testGetAnnotations() {
+ CombinationAnnotationElement element = CombinationAnnotationElement.of(ClassForTest.class, a -> true);
+ Annotation[] annotations = element.getAnnotations();
+ Assert.assertEquals(2, annotations.length);
+ }
+
+ @Test
+ public void testGetDeclaredAnnotations() {
+ CombinationAnnotationElement element = CombinationAnnotationElement.of(ClassForTest.class, a -> true);
+ Annotation[] annotations = element.getDeclaredAnnotations();
+ Assert.assertEquals(2, annotations.length);
+ }
+
+ @Target(ElementType.TYPE_USE)
+ @Retention(RetentionPolicy.RUNTIME)
+ private @interface MetaAnnotationForTest{ }
+
+ @MetaAnnotationForTest
+ @Target(ElementType.TYPE_USE)
+ @Retention(RetentionPolicy.RUNTIME)
+ private @interface AnnotationForTest{ }
+
+ @AnnotationForTest
+ private static class ClassForTest{}
+
+}
diff --git a/hutool-core/src/test/java/cn/hutool/core/annotation/RepeatAnnotationForTest.java b/hutool-core/src/test/java/cn/hutool/core/annotation/RepeatAnnotationForTest.java
deleted file mode 100755
index cc71c68da..000000000
--- a/hutool-core/src/test/java/cn/hutool/core/annotation/RepeatAnnotationForTest.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package cn.hutool.core.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * @author hongda.li 2022-04-26 17:09
- */
-@AnnotationForTest("repeat-annotation")
-@Retention(RetentionPolicy.RUNTIME)
-// Target注解决定MyAnnotation注解可以加在哪些成分上，如加在类身上，或者属性身上，或者方法身上等成分
-@Target({ ElementType.METHOD, ElementType.TYPE })
-public @interface RepeatAnnotationForTest {
-}
diff --git a/hutool-core/src/test/java/cn/hutool/core/date/WeekTest.java b/hutool-core/src/test/java/cn/hutool/core/date/WeekTest.java
index 26f9f95c7..90d158bf8 100644
--- a/hutool-core/src/test/java/cn/hutool/core/date/WeekTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/date/WeekTest.java
@@ -4,6 +4,7 @@ import org.junit.Assert;
import org.junit.Test;
import java.time.DayOfWeek;
+import java.util.Calendar;
public class WeekTest {
@@ -46,6 +47,9 @@ public class WeekTest {
Assert.assertEquals(Week.THURSDAY, Week.of(DayOfWeek.THURSDAY));
Assert.assertEquals(Week.FRIDAY, Week.of(DayOfWeek.FRIDAY));
Assert.assertEquals(Week.SATURDAY, Week.of(DayOfWeek.SATURDAY));
+ Assert.assertEquals(Week.SATURDAY, Week.of(Calendar.SATURDAY));
+ Assert.assertNull(Week.of(10));
+ Assert.assertNull(Week.of(-1));
}
@Test
@@ -58,4 +62,17 @@ public class WeekTest {
Assert.assertEquals(DayOfWeek.SATURDAY, Week.SATURDAY.toJdkDayOfWeek());
Assert.assertEquals(DayOfWeek.SUNDAY, Week.SUNDAY.toJdkDayOfWeek());
}
+
+ @Test
+ public void toChineseTest(){
+ Assert.assertEquals("周一",Week.MONDAY.toChinese("周"));
+ Assert.assertEquals("星期一",Week.MONDAY.toChinese("星期"));
+ Assert.assertEquals("星期二",Week.TUESDAY.toChinese("星期"));
+ Assert.assertEquals("星期三",Week.WEDNESDAY.toChinese("星期"));
+ Assert.assertEquals("星期四",Week.THURSDAY.toChinese("星期"));
+ Assert.assertEquals("星期五",Week.FRIDAY.toChinese("星期"));
+ Assert.assertEquals("星期六",Week.SATURDAY.toChinese("星期"));
+ Assert.assertEquals("星期日",Week.SUNDAY.toChinese("星期"));
+ Assert.assertEquals("星期一",Week.MONDAY.toChinese());
+ }
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/date/ZodiacTest.java b/hutool-core/src/test/java/cn/hutool/core/date/ZodiacTest.java
index dac1329c3..bbe1eac5c 100644
--- a/hutool-core/src/test/java/cn/hutool/core/date/ZodiacTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/date/ZodiacTest.java
@@ -3,6 +3,9 @@ package cn.hutool.core.date;
import org.junit.Assert;
import org.junit.Test;
+import java.util.Calendar;
+import java.util.Date;
+
public class ZodiacTest {
@Test
@@ -10,6 +13,11 @@ public class ZodiacTest {
Assert.assertEquals("摩羯座", Zodiac.getZodiac(Month.JANUARY, 19));
Assert.assertEquals("水瓶座", Zodiac.getZodiac(Month.JANUARY, 20));
Assert.assertEquals("巨蟹座", Zodiac.getZodiac(6, 17));
+ Calendar calendar = Calendar.getInstance();
+ calendar.set(2022, Calendar.JULY, 17);
+ Assert.assertEquals("巨蟹座", Zodiac.getZodiac(calendar.getTime()));
+ Assert.assertEquals("巨蟹座", Zodiac.getZodiac(calendar));
+ Assert.assertNull(Zodiac.getZodiac((Calendar) null));
}
@Test
@@ -17,5 +25,11 @@ public class ZodiacTest {
Assert.assertEquals("狗", Zodiac.getChineseZodiac(1994));
Assert.assertEquals("狗", Zodiac.getChineseZodiac(2018));
Assert.assertEquals("猪", Zodiac.getChineseZodiac(2019));
+ Calendar calendar = Calendar.getInstance();
+ calendar.set(2022, Calendar.JULY, 17);
+ Assert.assertEquals("虎", Zodiac.getChineseZodiac(calendar.getTime()));
+ Assert.assertEquals("虎", Zodiac.getChineseZodiac(calendar));
+ Assert.assertNull(Zodiac.getChineseZodiac(1899));
+ Assert.assertNull(Zodiac.getChineseZodiac((Calendar) null));
}
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/date/ZoneUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/date/ZoneUtilTest.java
new file mode 100644
index 000000000..c9a3f14ea
--- /dev/null
+++ b/hutool-core/src/test/java/cn/hutool/core/date/ZoneUtilTest.java
@@ -0,0 +1,16 @@
+package cn.hutool.core.date;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.time.ZoneId;
+import java.util.TimeZone;
+
+public class ZoneUtilTest {
+
+ @Test
+ public void test() {
+ Assert.assertEquals(ZoneId.systemDefault(), ZoneUtil.toZoneId(null));
+ Assert.assertEquals(TimeZone.getDefault(), ZoneUtil.toTimeZone(null));
+ }
+}
diff --git a/hutool-core/src/test/java/cn/hutool/core/map/CollectionValueMapTest.java b/hutool-core/src/test/java/cn/hutool/core/map/CollectionValueMapTest.java
new file mode 100644
index 000000000..e624bcc6b
--- /dev/null
+++ b/hutool-core/src/test/java/cn/hutool/core/map/CollectionValueMapTest.java
@@ -0,0 +1,160 @@
+package cn.hutool.core.map;
+
+import cn.hutool.core.map.multi.CollectionValueMap;
+import cn.hutool.core.map.multi.MultiValueMap;
+import cn.hutool.core.text.StrUtil;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.*;
+
+public class CollectionValueMapTest {
+
+ @Test
+ public void putTest() {
+ MultiValueMap map = new CollectionValueMap<>();
+ Assert.assertNull(map.put(1, Arrays.asList("a", "b")));
+ Collection collection = map.put(1, Arrays.asList("c", "d"));
+ Assert.assertEquals(Arrays.asList("a", "b"), collection);
+ }
+
+ @Test
+ public void putAllTest() {
+ MultiValueMap map = new CollectionValueMap<>();
+ Map> source = new HashMap<>();
+ source.put(1, Arrays.asList("a", "b", "c"));
+ map.putAll(source);
+ Assert.assertEquals(1, map.size());
+ Assert.assertEquals(Arrays.asList("a", "b", "c"), map.get(1));
+ }
+
+ @Test
+ public void putValueTest() {
+ MultiValueMap map = new CollectionValueMap<>();
+ Assert.assertTrue(map.putValue(1, "a"));
+ Assert.assertTrue(map.putValue(1, "b"));
+ Assert.assertTrue(map.putValue(1, "c"));
+ Assert.assertEquals(1, map.size());
+ Assert.assertEquals(Arrays.asList("a", "b", "c"), map.get(1));
+ }
+
+ @Test
+ public void putAllValueTest() {
+ MultiValueMap map = new CollectionValueMap<>();
+ Assert.assertTrue(map.putAllValues(1, Arrays.asList("a", "b", "c")));
+ Assert.assertEquals(1, map.size());
+ Assert.assertEquals(Arrays.asList("a", "b", "c"), map.get(1));
+
+ Map> source = new HashMap<>();
+ Assert.assertTrue(map.putValue(1, "e"));
+ Assert.assertTrue(map.putValue(1, "f"));
+ map.putAllValues(source);
+ Assert.assertEquals(Arrays.asList("a", "b", "c", "e", "f"), map.get(1));
+ }
+
+ @Test
+ public void putValuesTest() {
+ MultiValueMap map = new CollectionValueMap<>();
+ Assert.assertTrue(map.putValues(1, "a", "b", "c"));
+ Assert.assertEquals(Arrays.asList("a", "b", "c"), map.get(1));
+ }
+
+ @Test
+ public void testFilterAllValues() {
+ MultiValueMap map = new CollectionValueMap<>();
+ Assert.assertTrue(map.putValues(1, "a", "b", "c"));
+ Assert.assertTrue(map.putValues(2, "a", "b", "c"));
+
+ Assert.assertEquals(map, map.filterAllValues((k, v) -> StrUtil.equals(v, "a")));
+ Assert.assertEquals(Collections.singletonList("a"), map.getValues(1));
+ Assert.assertEquals(Collections.singletonList("a"), map.getValues(2));
+
+ Assert.assertEquals(map, map.filterAllValues(v -> !StrUtil.equals(v, "a")));
+ Assert.assertEquals(Collections.emptyList(), map.getValues(1));
+ Assert.assertEquals(Collections.emptyList(), map.getValues(2));
+ }
+
+ @Test
+ public void testReplaceAllValues() {
+ MultiValueMap map = new CollectionValueMap<>();
+ Assert.assertTrue(map.putValues(1, "a", "b", "c"));
+ Assert.assertTrue(map.putValues(2, "a", "b", "c"));
+
+ Assert.assertEquals(map, map.replaceAllValues((k, v) -> v + "2"));
+ Assert.assertEquals(Arrays.asList("a2", "b2", "c2"), map.getValues(1));
+ Assert.assertEquals(Arrays.asList("a2", "b2", "c2"), map.getValues(2));
+
+ Assert.assertEquals(map, map.replaceAllValues(v -> v + "3"));
+ Assert.assertEquals(Arrays.asList("a23", "b23", "c23"), map.getValues(1));
+ Assert.assertEquals(Arrays.asList("a23", "b23", "c23"), map.getValues(2));
+ }
+
+ @Test
+ public void removeValueTest() {
+ MultiValueMap map = new CollectionValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ Assert.assertFalse(map.removeValue(1, "d"));
+ Assert.assertTrue(map.removeValue(1, "c"));
+ Assert.assertEquals(Arrays.asList("a", "b"), map.get(1));
+ }
+
+ @Test
+ public void removeAllValuesTest() {
+ MultiValueMap map = new CollectionValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ Assert.assertFalse(map.removeAllValues(1, Arrays.asList("e", "f")));
+ Assert.assertTrue(map.removeAllValues(1, Arrays.asList("b", "c")));
+ Assert.assertEquals(Collections.singletonList("a"), map.get(1));
+ }
+
+ @Test
+ public void removeValuesTest() {
+ MultiValueMap map = new CollectionValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ Assert.assertFalse(map.removeValues(1, "e", "f"));
+ Assert.assertTrue(map.removeValues(1, "b", "c"));
+ Assert.assertEquals(Collections.singletonList("a"), map.get(1));
+ }
+
+ @Test
+ public void getValuesTest() {
+ MultiValueMap map = new CollectionValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ Assert.assertEquals(Collections.emptyList(), map.getValues(2));
+ Assert.assertEquals(Arrays.asList("a", "b", "c"), map.getValues(1));
+ }
+
+ @Test
+ public void sizeTest() {
+ MultiValueMap map = new CollectionValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ Assert.assertEquals(0, map.size(2));
+ Assert.assertEquals(3, map.size(1));
+ }
+
+ @Test
+ public void allForEachTest() {
+ MultiValueMap map = new CollectionValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ List keys = new ArrayList<>();
+ List values = new ArrayList<>();
+ map.allForEach((k, v) -> {
+ keys.add(k);
+ values.add(v);
+ });
+ Assert.assertEquals(Arrays.asList(1, 1, 1), keys);
+ Assert.assertEquals(Arrays.asList("a", "b", "c"), values);
+ }
+
+ @Test
+ public void allValuesTest() {
+ MultiValueMap map = new CollectionValueMap<>(new LinkedHashMap<>());
+ map.putAllValues(1, Arrays.asList("a", "b", "c"));
+ map.putAllValues(2, Arrays.asList("d", "e"));
+ Assert.assertEquals(
+ Arrays.asList("a", "b", "c", "d", "e"),
+ map.allValues()
+ );
+ }
+
+}
diff --git a/hutool-core/src/test/java/cn/hutool/core/map/ListValueMapTest.java b/hutool-core/src/test/java/cn/hutool/core/map/ListValueMapTest.java
new file mode 100644
index 000000000..b607127c5
--- /dev/null
+++ b/hutool-core/src/test/java/cn/hutool/core/map/ListValueMapTest.java
@@ -0,0 +1,160 @@
+package cn.hutool.core.map;
+
+import cn.hutool.core.map.multi.ListValueMap;
+import cn.hutool.core.map.multi.MultiValueMap;
+import cn.hutool.core.text.StrUtil;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.*;
+
+public class ListValueMapTest {
+
+ @Test
+ public void putTest() {
+ MultiValueMap map = new ListValueMap<>();
+ Assert.assertNull(map.put(1, Arrays.asList("a", "b")));
+ Collection collection = map.put(1, Arrays.asList("c", "d"));
+ Assert.assertEquals(Arrays.asList("a", "b"), collection);
+ }
+
+ @Test
+ public void putAllTest() {
+ MultiValueMap map = new ListValueMap<>();
+ Map> source = new HashMap<>();
+ source.put(1, Arrays.asList("a", "b", "c"));
+ map.putAll(source);
+ Assert.assertEquals(1, map.size());
+ Assert.assertEquals(Arrays.asList("a", "b", "c"), map.get(1));
+ }
+
+ @Test
+ public void putValueTest() {
+ MultiValueMap map = new ListValueMap<>();
+ Assert.assertTrue(map.putValue(1, "a"));
+ Assert.assertTrue(map.putValue(1, "b"));
+ Assert.assertTrue(map.putValue(1, "c"));
+ Assert.assertEquals(1, map.size());
+ Assert.assertEquals(Arrays.asList("a", "b", "c"), map.get(1));
+ }
+
+ @Test
+ public void putAllValueTest() {
+ MultiValueMap map = new ListValueMap<>();
+ Assert.assertTrue(map.putAllValues(1, Arrays.asList("a", "b", "c")));
+ Assert.assertEquals(1, map.size());
+ Assert.assertEquals(Arrays.asList("a", "b", "c"), map.get(1));
+
+ Map> source = new HashMap<>();
+ Assert.assertTrue(map.putValue(1, "e"));
+ Assert.assertTrue(map.putValue(1, "f"));
+ map.putAllValues(source);
+ Assert.assertEquals(Arrays.asList("a", "b", "c", "e", "f"), map.get(1));
+ }
+
+ @Test
+ public void putValuesTest() {
+ MultiValueMap map = new ListValueMap<>();
+ Assert.assertTrue(map.putValues(1, "a", "b", "c"));
+ Assert.assertEquals(Arrays.asList("a", "b", "c"), map.get(1));
+ }
+
+ @Test
+ public void removeValueTest() {
+ MultiValueMap map = new ListValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ Assert.assertFalse(map.removeValue(1, "d"));
+ Assert.assertTrue(map.removeValue(1, "c"));
+ Assert.assertEquals(Arrays.asList("a", "b"), map.get(1));
+ }
+
+ @Test
+ public void removeAllValuesTest() {
+ MultiValueMap map = new ListValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ Assert.assertFalse(map.removeAllValues(1, Arrays.asList("e", "f")));
+ Assert.assertTrue(map.removeAllValues(1, Arrays.asList("b", "c")));
+ Assert.assertEquals(Collections.singletonList("a"), map.get(1));
+ }
+
+ @Test
+ public void removeValuesTest() {
+ MultiValueMap map = new ListValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ Assert.assertFalse(map.removeValues(1, "e", "f"));
+ Assert.assertTrue(map.removeValues(1, "b", "c"));
+ Assert.assertEquals(Collections.singletonList("a"), map.get(1));
+ }
+
+ @Test
+ public void testFilterAllValues() {
+ MultiValueMap map = new ListValueMap<>();
+ Assert.assertTrue(map.putValues(1, "a", "b", "c"));
+ Assert.assertTrue(map.putValues(2, "a", "b", "c"));
+
+ Assert.assertEquals(map, map.filterAllValues((k, v) -> StrUtil.equals(v, "a")));
+ Assert.assertEquals(Collections.singletonList("a"), map.getValues(1));
+ Assert.assertEquals(Collections.singletonList("a"), map.getValues(2));
+
+ Assert.assertEquals(map, map.filterAllValues(v -> !StrUtil.equals(v, "a")));
+ Assert.assertEquals(Collections.emptyList(), map.getValues(1));
+ Assert.assertEquals(Collections.emptyList(), map.getValues(2));
+ }
+
+ @Test
+ public void testReplaceAllValues() {
+ MultiValueMap map = new ListValueMap<>();
+ Assert.assertTrue(map.putValues(1, "a", "b", "c"));
+ Assert.assertTrue(map.putValues(2, "a", "b", "c"));
+
+ Assert.assertEquals(map, map.replaceAllValues((k, v) -> v + "2"));
+ Assert.assertEquals(Arrays.asList("a2", "b2", "c2"), map.getValues(1));
+ Assert.assertEquals(Arrays.asList("a2", "b2", "c2"), map.getValues(2));
+
+ Assert.assertEquals(map, map.replaceAllValues(v -> v + "3"));
+ Assert.assertEquals(Arrays.asList("a23", "b23", "c23"), map.getValues(1));
+ Assert.assertEquals(Arrays.asList("a23", "b23", "c23"), map.getValues(2));
+ }
+
+ @Test
+ public void getValuesTest() {
+ MultiValueMap map = new ListValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ Assert.assertEquals(Collections.emptyList(), map.getValues(2));
+ Assert.assertEquals(Arrays.asList("a", "b", "c"), map.getValues(1));
+ }
+
+ @Test
+ public void sizeTest() {
+ MultiValueMap map = new ListValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ Assert.assertEquals(0, map.size(2));
+ Assert.assertEquals(3, map.size(1));
+ }
+
+ @Test
+ public void allForEachTest() {
+ MultiValueMap map = new ListValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ List keys = new ArrayList<>();
+ List values = new ArrayList<>();
+ map.allForEach((k, v) -> {
+ keys.add(k);
+ values.add(v);
+ });
+ Assert.assertEquals(Arrays.asList(1, 1, 1), keys);
+ Assert.assertEquals(Arrays.asList("a", "b", "c"), values);
+ }
+
+ @Test
+ public void allValuesTest() {
+ MultiValueMap map = new ListValueMap<>();
+ map.putAllValues(1, Arrays.asList("a", "b", "c"));
+ map.putAllValues(2, Arrays.asList("d", "e"));
+ Assert.assertEquals(
+ Arrays.asList("a", "b", "c", "d", "e"),
+ map.allValues()
+ );
+ }
+
+}
diff --git a/hutool-core/src/test/java/cn/hutool/core/map/SetValueMapTest.java b/hutool-core/src/test/java/cn/hutool/core/map/SetValueMapTest.java
new file mode 100644
index 000000000..e41e5f872
--- /dev/null
+++ b/hutool-core/src/test/java/cn/hutool/core/map/SetValueMapTest.java
@@ -0,0 +1,162 @@
+package cn.hutool.core.map;
+
+import cn.hutool.core.map.multi.MultiValueMap;
+import cn.hutool.core.map.multi.SetValueMap;
+import cn.hutool.core.text.StrUtil;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.*;
+
+public class SetValueMapTest {
+
+ @Test
+ public void putTest() {
+ MultiValueMap map = new SetValueMap<>();
+ Assert.assertNull(map.put(1, Arrays.asList("a", "b")));
+ Collection collection = map.put(1, Arrays.asList("c", "d"));
+ Assert.assertEquals(Arrays.asList("a", "b"), collection);
+ }
+
+ @Test
+ public void putAllTest() {
+ MultiValueMap map = new SetValueMap<>();
+ Map> source = new HashMap<>();
+ source.put(1, Arrays.asList("a", "b", "c"));
+ map.putAll(source);
+ Assert.assertEquals(1, map.size());
+ Assert.assertEquals(Arrays.asList("a", "b", "c"), map.get(1));
+ }
+
+ @Test
+ public void putValueTest() {
+ MultiValueMap map = new SetValueMap<>();
+ Assert.assertTrue(map.putValue(1, "a"));
+ Assert.assertTrue(map.putValue(1, "b"));
+ Assert.assertTrue(map.putValue(1, "c"));
+ Assert.assertEquals(1, map.size());
+ Assert.assertEquals(new HashSet<>(Arrays.asList("a", "b", "c")), map.get(1));
+ }
+
+ @Test
+ public void putAllValueTest() {
+ MultiValueMap map = new SetValueMap<>();
+ Assert.assertTrue(map.putAllValues(1, Arrays.asList("a", "b", "c")));
+ Assert.assertEquals(1, map.size());
+ Assert.assertEquals(new HashSet<>(Arrays.asList("a", "b", "c")), map.get(1));
+
+ Map> source = new HashMap<>();
+ Assert.assertTrue(map.putValue(1, "e"));
+ Assert.assertFalse(map.putValue(1, "e"));
+ Assert.assertTrue(map.putValue(1, "f"));
+ Assert.assertFalse(map.putValue(1, "f"));
+ map.putAllValues(source);
+ Assert.assertEquals(new HashSet<>(Arrays.asList("a", "b", "c", "e", "f")), map.get(1));
+ }
+
+ @Test
+ public void putValuesTest() {
+ MultiValueMap map = new SetValueMap<>();
+ Assert.assertTrue(map.putValues(1, "a", "b", "c"));
+ Assert.assertEquals(new HashSet<>(Arrays.asList("a", "b", "c")), map.get(1));
+ }
+
+ @Test
+ public void removeValueTest() {
+ MultiValueMap map = new SetValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ Assert.assertFalse(map.removeValue(1, "d"));
+ Assert.assertTrue(map.removeValue(1, "c"));
+ Assert.assertEquals(new HashSet<>(Arrays.asList("a", "b")), map.get(1));
+ }
+
+ @Test
+ public void removeAllValuesTest() {
+ MultiValueMap map = new SetValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ Assert.assertFalse(map.removeAllValues(1, Arrays.asList("e", "f")));
+ Assert.assertTrue(map.removeAllValues(1, Arrays.asList("b", "c")));
+ Assert.assertEquals(Collections.singleton("a"), map.get(1));
+ }
+
+ @Test
+ public void removeValuesTest() {
+ MultiValueMap map = new SetValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ Assert.assertFalse(map.removeValues(1, "e", "f"));
+ Assert.assertTrue(map.removeValues(1, "b", "c"));
+ Assert.assertEquals(Collections.singleton("a"), map.get(1));
+ }
+
+ @Test
+ public void testFilterAllValues() {
+ MultiValueMap map = new SetValueMap<>();
+ Assert.assertTrue(map.putValues(1, "a", "b", "c"));
+ Assert.assertTrue(map.putValues(2, "a", "b", "c"));
+
+ Assert.assertEquals(map, map.filterAllValues((k, v) -> StrUtil.equals(v, "a")));
+ Assert.assertEquals(Collections.singleton("a"), map.getValues(1));
+ Assert.assertEquals(Collections.singleton("a"), map.getValues(2));
+
+ Assert.assertEquals(map, map.filterAllValues(v -> !StrUtil.equals(v, "a")));
+ Assert.assertEquals(Collections.emptySet(), map.getValues(1));
+ Assert.assertEquals(Collections.emptySet(), map.getValues(2));
+ }
+
+ @Test
+ public void testReplaceAllValues() {
+ MultiValueMap map = new SetValueMap<>();
+ Assert.assertTrue(map.putValues(1, "a", "b", "c"));
+ Assert.assertTrue(map.putValues(2, "a", "b", "c"));
+
+ Assert.assertEquals(map, map.replaceAllValues((k, v) -> v + "2"));
+ Assert.assertEquals(new HashSet<>(Arrays.asList("a2", "b2", "c2")), map.getValues(1));
+ Assert.assertEquals(new HashSet<>(Arrays.asList("a2", "b2", "c2")), map.getValues(2));
+
+ Assert.assertEquals(map, map.replaceAllValues(v -> v + "3"));
+ Assert.assertEquals(new HashSet<>(Arrays.asList("a23", "b23", "c23")), map.getValues(1));
+ Assert.assertEquals(new HashSet<>(Arrays.asList("a23", "b23", "c23")), map.getValues(2));
+ }
+
+ @Test
+ public void getValuesTest() {
+ MultiValueMap map = new SetValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ Assert.assertEquals(Collections.emptyList(), map.getValues(2));
+ Assert.assertEquals(new HashSet<>(Arrays.asList("a", "b", "c")), map.getValues(1));
+ }
+
+ @Test
+ public void sizeTest() {
+ MultiValueMap map = new SetValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ Assert.assertEquals(0, map.size(2));
+ Assert.assertEquals(3, map.size(1));
+ }
+
+ @Test
+ public void allForEachTest() {
+ MultiValueMap map = new SetValueMap<>();
+ map.putValues(1, "a", "b", "c");
+ List keys = new ArrayList<>();
+ List values = new ArrayList<>();
+ map.allForEach((k, v) -> {
+ keys.add(k);
+ values.add(v);
+ });
+ Assert.assertEquals(Arrays.asList(1, 1, 1), keys);
+ Assert.assertEquals(Arrays.asList("a", "b", "c"), values);
+ }
+
+ @Test
+ public void allValuesTest() {
+ MultiValueMap map = new SetValueMap<>();
+ map.putAllValues(1, Arrays.asList("a", "b", "c"));
+ map.putAllValues(2, Arrays.asList("d", "e"));
+ Assert.assertEquals(
+ Arrays.asList("a", "b", "c", "d", "e"),
+ map.allValues()
+ );
+ }
+
+}
diff --git a/hutool-core/src/test/java/cn/hutool/core/util/ObjUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/util/ObjUtilTest.java
index a2b34c992..dd920ee8b 100644
--- a/hutool-core/src/test/java/cn/hutool/core/util/ObjUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/util/ObjUtilTest.java
@@ -1,18 +1,16 @@
package cn.hutool.core.util;
import cn.hutool.core.collection.ListUtil;
-import cn.hutool.core.date.DatePattern;
-import cn.hutool.core.date.DateUtil;
import cn.hutool.core.exceptions.CloneRuntimeException;
import org.junit.Assert;
import org.junit.Test;
import java.math.BigDecimal;
-import java.time.Instant;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
+import java.util.function.Function;
public class ObjUtilTest {
@@ -84,7 +82,7 @@ public class ObjUtilTest {
public Obj clone() {
try {
return (Obj) super.clone();
- } catch (CloneNotSupportedException e) {
+ } catch (final CloneNotSupportedException e) {
throw new CloneRuntimeException(e);
}
}
@@ -99,15 +97,20 @@ public class ObjUtilTest {
@Test
public void defaultIfNullTest() {
- final String dateStr = "2020-10-23 15:12:30";
- final Instant result1 = ObjUtil.defaultIfNull(dateStr,
- (v) -> DateUtil.parse(v.toString(), DatePattern.NORM_DATETIME_PATTERN).toInstant(), Instant::now);
- Assert.assertNotNull(result1);
+ final Object val1 = new Object();
+ final Object val2 = new Object();
- final String nullValue = null;
- final Instant result2 = ObjUtil.defaultIfNull(nullValue,
- (v) -> DateUtil.parse(v.toString(), DatePattern.NORM_DATETIME_PATTERN).toInstant(), Instant::now);
- Assert.assertNotNull(result2);
+ Assert.assertSame(val1, ObjUtil.defaultIfNull(val1, () -> val2));
+ Assert.assertSame(val2, ObjUtil.defaultIfNull(null, () -> val2));
+
+ Assert.assertSame(val1, ObjUtil.defaultIfNull(val1, val2));
+ Assert.assertSame(val2, ObjUtil.defaultIfNull(null, val2));
+
+ Assert.assertSame(val1, ObjUtil.defaultIfNull(val1, Function.identity(), () -> val2));
+ Assert.assertSame(val2, ObjUtil.defaultIfNull(null, Function.identity(), () -> val2));
+
+ Assert.assertSame(val1, ObjUtil.defaultIfNull(val1, Function.identity(), val2));
+ Assert.assertSame(val2, ObjUtil.defaultIfNull(null, Function.identity(), val2));
}
@Test
@@ -119,7 +122,7 @@ public class ObjUtilTest {
@Test
public void cloneIfPossibleTest() {
- String a = "a";
+ final String a = "a";
final String a2 = ObjUtil.cloneIfPossible(a);
Assert.assertNotSame(a, a2);
}
diff --git a/hutool-http/src/main/java/cn/hutool/http/server/HttpServerRequest.java b/hutool-http/src/main/java/cn/hutool/http/server/HttpServerRequest.java
index c39cb67eb..155d2c301 100644
--- a/hutool-http/src/main/java/cn/hutool/http/server/HttpServerRequest.java
+++ b/hutool-http/src/main/java/cn/hutool/http/server/HttpServerRequest.java
@@ -25,7 +25,6 @@ import java.net.HttpCookie;
import java.net.URI;
import java.nio.charset.Charset;
import java.util.Collection;
-import java.util.List;
import java.util.Map;
/**
@@ -303,7 +302,7 @@ public class HttpServerRequest extends HttpServerBase {
* @since 5.5.8
*/
public String getParam(final String name){
- return getParams().get(name, 0);
+ return getParams().getValue(name, 0);
}
/**
@@ -313,7 +312,7 @@ public class HttpServerRequest extends HttpServerBase {
* @return 参数值
* @since 5.5.8
*/
- public List getParams(final String name){
+ public Collection getParams(final String name){
return getParams().get(name);
}
diff --git a/hutool-json/src/main/java/cn/hutool/json/JSON.java b/hutool-json/src/main/java/cn/hutool/json/JSON.java
index 79e510951..f4561b9d3 100755
--- a/hutool-json/src/main/java/cn/hutool/json/JSON.java
+++ b/hutool-json/src/main/java/cn/hutool/json/JSON.java
@@ -1,12 +1,14 @@
package cn.hutool.json;
import cn.hutool.core.bean.BeanPath;
+import cn.hutool.core.lang.mutable.MutableEntry;
import cn.hutool.json.convert.JSONConverterOld;
import java.io.Serializable;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.Type;
+import java.util.function.Predicate;
/**
* JSON接口
@@ -23,6 +25,13 @@ public interface JSON extends Cloneable, Serializable {
*/
JSONConfig getConfig();
+ /**
+ * JSON大小，对于JSONObject，是键值对的多少，JSONArray则是元素的个数
+ *
+ * @return 大小
+ */
+ int size();
+
/**
* 通过表达式获取JSON中嵌套的对象
*
@@ -44,7 +53,7 @@ public interface JSON extends Cloneable, Serializable {
* @see BeanPath#get(Object)
* @since 4.0.6
*/
- default Object getByPath(final String expression){
+ default Object getByPath(final String expression) {
return BeanPath.of(expression).get(this);
}
@@ -69,7 +78,7 @@ public interface JSON extends Cloneable, Serializable {
* @param expression 表达式
* @param value 值
*/
- default void putByPath(final String expression, final Object value){
+ default void putByPath(final String expression, final Object value) {
BeanPath.of(expression).set(this, value);
}
@@ -121,7 +130,7 @@ public interface JSON extends Cloneable, Serializable {
default String toJSONString(final int indentFactor) throws JSONException {
final StringWriter sw = new StringWriter();
synchronized (sw.getBuffer()) {
- return this.write(sw, indentFactor, 0).toString();
+ return this.write(sw, indentFactor, 0, null).toString();
}
}
@@ -134,7 +143,7 @@ public interface JSON extends Cloneable, Serializable {
* @throws JSONException JSON相关异常
*/
default Writer write(final Writer writer) throws JSONException {
- return this.write(writer, 0, 0);
+ return this.write(writer, 0, 0, null);
}
/**
@@ -144,10 +153,11 @@ public interface JSON extends Cloneable, Serializable {
* @param writer writer
* @param indentFactor 缩进因子，定义每一级别增加的缩进量
* @param indent 本级别缩进量
+ * @param predicate 过滤器，可以修改值，key（index）无法修改，{@link Predicate#test(Object)}为{@code true}保留
* @return Writer
* @throws JSONException JSON相关异常
*/
- Writer write(Writer writer, int indentFactor, int indent) throws JSONException;
+ Writer write(Writer writer, int indentFactor, int indent, final Predicate> predicate) throws JSONException;
/**
* 转为实体类对象，转换异常将被抛出
@@ -163,8 +173,8 @@ public interface JSON extends Cloneable, Serializable {
/**
* 转为实体类对象
*
- * @param Bean类型
- * @param type {@link Type}
+ * @param Bean类型
+ * @param type {@link Type}
* @return 实体类对象
* @since 4.3.2
*/
diff --git a/hutool-json/src/main/java/cn/hutool/json/JSONArray.java b/hutool-json/src/main/java/cn/hutool/json/JSONArray.java
index 29fcd1cb3..8fbd73162 100755
--- a/hutool-json/src/main/java/cn/hutool/json/JSONArray.java
+++ b/hutool-json/src/main/java/cn/hutool/json/JSONArray.java
@@ -533,7 +533,7 @@ public class JSONArray implements JSON, JSONGetter, List