add BoundedCollection

hutool-core/src/main/java/org/dromara/hutool/core/collection/BoundedCollection.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2024. looly(loolly@aliyun.com)
+ * Hutool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *          https://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+package org.dromara.hutool.core.collection;
+
+import java.util.Collection;
+
+/**
+ * 有边界限制的集合，边界集合有最大容量限制
+ *
+ * @param <E> 元素类型
+ * @since 6.0.0
+ */
+public interface BoundedCollection<E> extends Collection<E> {
+
+	/**
+	 * 是否已满，如果集合已满，不允许新增元素
+	 *
+	 * @return 是否已满
+	 */
+	boolean isFull();
+
+	/**
+	 * 获取集合最大允许容量
+	 *
+	 * @return 容量
+	 */
+	int maxSize();
+
+}

hutool-core/src/main/java/org/dromara/hutool/core/collection/BoundedList.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2024. looly(loolly@aliyun.com)
+ * Hutool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *          https://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+package org.dromara.hutool.core.collection;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * 指定边界大小的List<br>
+ * 通过指定边界，可以限制List的最大容量
+ *
+ * @param <E> 元素类型
+ * @author Looly
+ * @since 6.0.0
+ */
+public class BoundedList<E> extends ListWrapper<E> implements BoundedCollection<E> {
+
+	private final int maxSize;
+
+	/**
+	 * 构造
+	 *
+	 * @param maxSize 最大容量
+	 */
+	public BoundedList(final int maxSize) {
+		this(new ArrayList<>(maxSize), maxSize);
+	}
+
+	/**
+	 * 构造，限制集合的最大容量为提供的List
+	 *
+	 * @param raw     原始对象
+	 * @param maxSize 最大容量
+	 */
+	public BoundedList(final List<E> raw, final int maxSize) {
+		super(raw);
+		this.maxSize = maxSize;
+	}
+
+	@Override
+	public boolean isFull() {
+		return size() == this.maxSize;
+	}
+
+	@Override
+	public int maxSize() {
+		return this.maxSize;
+	}
+
+	@Override
+	public boolean add(final E e) {
+		checkFull(1);
+		return super.add(e);
+	}
+
+	@Override
+	public void add(final int index, final E element) {
+		checkFull(1);
+		super.add(index, element);
+	}
+
+	@Override
+	public boolean addAll(final Collection<? extends E> c) {
+		checkFull(c.size());
+		return super.addAll(c);
+	}
+
+	@Override
+	public boolean addAll(final int index, final Collection<? extends E> c) {
+		checkFull(c.size());
+		return super.addAll(index, c);
+	}
+
+	private void checkFull(final int addSize) {
+		if (size() + addSize > this.maxSize) {
+			throw new IndexOutOfBoundsException("List is no space to add " + addSize + " elements!");
+		}
+	}
+}

hutool-core/src/main/java/org/dromara/hutool/core/collection/CollUtil.java

@@ -2304,6 +2304,25 @@ public class CollUtil {
 		}
 	}
 
+	/**
+	 * 判断subCollection是否为collection的子集合，不考虑顺序，只考虑元素数量。
+	 * <ul>
+	 *     <li>如果两个集合为同一集合或，则返回true</li>
+	 *     <li>如果两个集合元素都相同，则返回true（无论顺序相同与否）</li>
+	 * </ul>
+	 *
+	 * @param subCollection 第一个Iterable对象，即子集合。
+	 * @param collection 第二个Iterable对象，可以为任何实现了Iterable接口的集合。
+	 * @return 如果subCollection是collection的子集合，则返回true；否则返回false。
+	 * @since 6.0.0
+	 */
+	public static boolean isSub(final Collection<?> subCollection, final Collection<?> collection) {
+		if(size(subCollection) > size(collection)){
+			return false;
+		}
+		return IterUtil.isSub(subCollection, collection);
+	}
+
 	/**
 	 * 判断两个{@link Collection} 是否元素和顺序相同，返回{@code true}的条件是：
 	 * <ul>
@@ -2318,14 +2337,30 @@ public class CollUtil {
 	 * @since 5.6.0
 	 */
 	public static boolean isEqualList(final Collection<?> list1, final Collection<?> list2) {
-		if (list1 == list2) {
+		return equals(list1, list2, false);
-			return true;
+	}
-		}
+
-		if (list1 == null || list2 == null || list1.size() != list2.size()) {
+	/**
+	 * 判断两个{@link Iterable}中的元素是否相同，可选是否判断顺序
+	 * 当满足下列情况时返回{@code true}：
+	 * <ul>
+	 *     <li>两个{@link Iterable}都为{@code null}；</li>
+	 *     <li>两个{@link Iterable}满足{@code coll1 == coll2}；</li>
+	 *     <li>如果忽略顺序，则计算两个集合中元素和数量是否相同</li>
+	 *     <li>如果不忽略顺序，两个{@link Iterable}所有具有相同下标的元素皆满足{@link Objects#equals(Object, Object)}；</li>
+	 * </ul>
+	 *
+	 * @param coll1 集合1
+	 * @param coll2 集合2
+	 * @param ignoreOrder 是否忽略顺序
+	 * @return 是否相同
+	 */
+	public static boolean equals(final Collection<?> coll1, final Collection<?> coll2, final boolean ignoreOrder) {
+		if(size(coll1) != size(coll2)){
 			return false;
 		}
 
-		return IterUtil.isEqualList(list1, list2);
+		return IterUtil.equals(coll1, coll2, ignoreOrder);
 	}
 
 	/**

hutool-core/src/main/java/org/dromara/hutool/core/collection/ListWrapper.java

@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2024. looly(loolly@aliyun.com)
+ * Hutool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *          https://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+package org.dromara.hutool.core.collection;
+
+import org.dromara.hutool.core.lang.wrapper.SimpleWrapper;
+
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
+import java.util.stream.Stream;
+
+/**
+ * 列表包装类<br>
+ * 提供列表包装，用于在执行列表方法前后自定义处理逻辑
+ *
+ * @param <E> 元素类型
+ */
+public class ListWrapper<E> extends SimpleWrapper<List<E>> implements List<E> {
+	/**
+	 * 构造
+	 *
+	 * @param raw 原始对象
+	 */
+	public ListWrapper(final List<E> raw) {
+		super(raw);
+	}
+
+
+	@Override
+	public int size() {
+		return raw.size();
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return raw.isEmpty();
+	}
+
+	@Override
+	public boolean contains(final Object o) {
+		return raw.contains(o);
+	}
+
+	@Override
+	public Iterator<E> iterator() {
+		return raw.iterator();
+	}
+
+	@Override
+	public void forEach(final Consumer<? super E> action) {
+		raw.forEach(action);
+	}
+
+	@Override
+	public Object[] toArray() {
+		return raw.toArray();
+	}
+
+	@Override
+	public <T> T[] toArray(final T[] a) {
+		return raw.toArray(a);
+	}
+
+	@Override
+	public boolean add(final E e) {
+		return raw.add(e);
+	}
+
+	@Override
+	public boolean remove(final Object o) {
+		return raw.remove(o);
+	}
+
+	@SuppressWarnings("SlowListContainsAll")
+	@Override
+	public boolean containsAll(final Collection<?> c) {
+		return raw.containsAll(c);
+	}
+
+	@Override
+	public boolean addAll(final Collection<? extends E> c) {
+		return raw.addAll(c);
+	}
+
+	@Override
+	public boolean addAll(final int index, final Collection<? extends E> c) {
+		return raw.addAll(index, c);
+	}
+
+	@Override
+	public boolean removeAll(final Collection<?> c) {
+		return raw.removeAll(c);
+	}
+
+	@Override
+	public boolean removeIf(final Predicate<? super E> filter) {
+		return raw.removeIf(filter);
+	}
+
+	@Override
+	public boolean retainAll(final Collection<?> c) {
+		return raw.retainAll(c);
+	}
+
+	@Override
+	public void replaceAll(final UnaryOperator<E> operator) {
+		raw.replaceAll(operator);
+	}
+
+	@Override
+	public void sort(final Comparator<? super E> c) {
+		raw.sort(c);
+	}
+
+	@Override
+	public void clear() {
+		raw.clear();
+	}
+
+	@Override
+	public E get(final int index) {
+		return raw.get(index);
+	}
+
+	@Override
+	public E set(final int index, final E element) {
+		return raw.set(index, element);
+	}
+
+	@Override
+	public void add(final int index, final E element) {
+		raw.add(index, element);
+	}
+
+	@Override
+	public E remove(final int index) {
+		return raw.remove(index);
+	}
+
+	@Override
+	public int indexOf(final Object o) {
+		return raw.indexOf(o);
+	}
+
+	@Override
+	public int lastIndexOf(final Object o) {
+		return raw.lastIndexOf(o);
+	}
+
+	@Override
+	public ListIterator<E> listIterator() {
+		return raw.listIterator();
+	}
+
+	@Override
+	public ListIterator<E> listIterator(final int index) {
+		return raw.listIterator(index);
+	}
+
+	@Override
+	public List<E> subList(final int fromIndex, final int toIndex) {
+		return raw.subList(fromIndex, toIndex);
+	}
+
+	@Override
+	public Spliterator<E> spliterator() {
+		return raw.spliterator();
+	}
+
+	@Override
+	public Stream<E> stream() {
+		return raw.stream();
+	}
+
+	@Override
+	public Stream<E> parallelStream() {
+		return raw.parallelStream();
+	}
+}

hutool-core/src/main/java/org/dromara/hutool/core/collection/iter/IterUtil.java

@@ -17,6 +17,7 @@ import org.dromara.hutool.core.collection.CollUtil;
 import org.dromara.hutool.core.collection.ListUtil;
 import org.dromara.hutool.core.lang.Assert;
 import org.dromara.hutool.core.map.MapUtil;
+import org.dromara.hutool.core.math.NumberUtil;
 import org.dromara.hutool.core.reflect.FieldUtil;
 import org.dromara.hutool.core.reflect.method.MethodUtil;
 import org.dromara.hutool.core.text.StrJoiner;
@@ -745,6 +746,44 @@ public class IterUtil {
 		return size;
 	}
 
+	/**
+	 * 判断subIter是否为iter的子集合，不考虑顺序，只考虑元素数量。<br>
+	 * <ul>
+	 *     <li>如果两个集合为同一集合或，则返回true</li>
+	 *     <li>如果两个集合元素都相同，则返回true（无论顺序相同与否）</li>
+	 * </ul>
+	 *
+	 * @param subIter 第一个Iterable对象，即子集合。
+	 * @param iter    第二个Iterable对象，可以为任何实现了Iterable接口的集合。
+	 * @return 如果subIter是iter的子集合，则返回true；否则返回false。
+	 * @since 6.0.0
+	 */
+	public static boolean isSub(final Iterable<?> subIter, final Iterable<?> iter) {
+		// 如果两个Iterable对象引用相同，则肯定是一个的子集合
+		if (subIter == iter) {
+			return true;
+		}
+		// 如果有任何一个Iterable对象为null，则不是子集合关系
+		if (subIter == null || iter == null) {
+			return false;
+		}
+
+		// 使用Map记录每个Iterable中每个元素出现的次数
+		final Map<?, Integer> countMap1 = countMap(subIter.iterator());
+		final Map<?, Integer> countMap2 = countMap(iter.iterator());
+
+		// 遍历第一个Iterable中的每个元素
+		for (final Object obj : subIter) {
+			// 比较第一个Iterable中元素的出现次数和第二个Iterable中元素的出现次数
+			// 如果第一个Iterable中元素的出现次数大于第二个Iterable中元素的出现次数，则不是子集合关系
+			if (NumberUtil.nullToZero(countMap1.get(obj)) > NumberUtil.nullToZero(countMap2.get(obj))) {
+				return false;
+			}
+		}
+		// 如果所有元素的出现次数比较都满足子集合关系，则返回true
+		return true;
+	}
+
 	/**
 	 * <p>判断两个{@link Iterable}中的元素与其顺序是否相同 <br>
 	 * 当满足下列情况时返回{@code true}：
@@ -761,25 +800,66 @@ public class IterUtil {
 	 * @since 5.6.0
 	 */
 	public static boolean isEqualList(final Iterable<?> iterable1, final Iterable<?> iterable2) {
+		return equals(iterable1, iterable2, false);
+	}
+
+	/**
+	 * 判断两个{@link Iterable}中的元素是否相同，可选是否判断顺序
+	 * 当满足下列情况时返回{@code true}：
+	 * <ul>
+	 *     <li>两个{@link Iterable}都为{@code null}；</li>
+	 *     <li>两个{@link Iterable}满足{@code iterable1 == iterable2}；</li>
+	 *     <li>如果忽略顺序，则计算两个集合中元素和数量是否相同</li>
+	 *     <li>如果不忽略顺序，两个{@link Iterable}所有具有相同下标的元素皆满足{@link Objects#equals(Object, Object)}；</li>
+	 * </ul>
+	 *
+	 * @param iterable1 集合1
+	 * @param iterable2 集合2
+	 * @param ignoreOrder 是否忽略顺序
+	 * @return 是否相同
+	 */
+	public static boolean equals(final Iterable<?> iterable1, final Iterable<?> iterable2, final boolean ignoreOrder) {
+		// 如果两个Iterable对象引用相同，则肯定相等
 		if (iterable1 == iterable2) {
 			return true;
 		}
+		// 如果有任何一个Iterable对象为null，则不是子集合关系
 		if (iterable1 == null || iterable2 == null) {
 			return false;
 		}
-		final Iterator<?> iter1 = iterable1.iterator();
+
-		final Iterator<?> iter2 = iterable2.iterator();
+		if(ignoreOrder){
-		Object obj1;
+			final Map<?, Integer> countMap1 = countMap(iterable1.iterator());
-		Object obj2;
+			final Map<?, Integer> countMap2 = countMap(iterable2.iterator());
-		while (iter1.hasNext() && iter2.hasNext()) {
+
-			obj1 = iter1.next();
+			if(countMap1.size() != countMap2.size()){
-			obj2 = iter2.next();
+				// 如果两个Iterable中元素种类不同，则肯定不等
-			if (!Objects.equals(obj1, obj2)) {
 				return false;
 			}
+
+			for (final Object obj : iterable1) {
+				// 比较第一个Iterable中元素的出现次数和第二个Iterable中元素的出现次数
+				if (NumberUtil.nullToZero(countMap1.get(obj)) != NumberUtil.nullToZero(countMap2.get(obj))) {
+					return false;
+				}
+			}
+			// 如果所有元素的出现次数比较都满足子集合关系，则返回true
+			return true;
+		} else{
+			final Iterator<?> iter1 = iterable1.iterator();
+			final Iterator<?> iter2 = iterable2.iterator();
+			Object obj1;
+			Object obj2;
+			while (iter1.hasNext() && iter2.hasNext()) {
+				obj1 = iter1.next();
+				obj2 = iter2.next();
+				if (!Objects.equals(obj1, obj2)) {
+					return false;
+				}
+			}
+			// 当两个Iterable长度不一致时返回false
+			return !(iter1.hasNext() || iter2.hasNext());
 		}
-		// 当两个Iterable长度不一致时返回false
-		return !(iter1.hasNext() || iter2.hasNext());
 	}
 
 	/**

hutool-core/src/main/java/org/dromara/hutool/core/collection/queue/BoundedPriorityQueue.java

@@ -12,11 +12,9 @@
 
 package org.dromara.hutool.core.collection.queue;
 
-import java.util.ArrayList;
+import org.dromara.hutool.core.collection.BoundedCollection;
-import java.util.Arrays;
+
-import java.util.Comparator;
+import java.util.*;
-import java.util.Iterator;
-import java.util.PriorityQueue;
 
 /**
  * 有界优先队列<br>
@@ -25,13 +23,17 @@ import java.util.PriorityQueue;
  *
  * @param <E> 成员类型
  */
-public class BoundedPriorityQueue<E> extends PriorityQueue<E>{
+public class BoundedPriorityQueue<E> extends PriorityQueue<E> implements BoundedCollection<E> {
 	private static final long serialVersionUID = 3794348988671694820L;
 
 	//容量
 	private final int capacity;
 	private final Comparator<? super E> comparator;
 
+	/**
+	 * 构造
+	 * @param capacity 容量
+	 */
 	public BoundedPriorityQueue(final int capacity) {
 		this(capacity, null);
 	}
@@ -57,6 +59,16 @@ public class BoundedPriorityQueue<E> extends PriorityQueue<E>{
 		this.comparator = comparator;
 	}
 
+	@Override
+	public boolean isFull() {
+		return size() == capacity;
+	}
+
+	@Override
+	public int maxSize() {
+		return capacity;
+	}
+
 	/**
 	 * 加入元素，当队列满时，淘汰末尾元素
 	 * @param e 元素
@@ -64,7 +76,7 @@ public class BoundedPriorityQueue<E> extends PriorityQueue<E>{
 	 */
 	@Override
 	public boolean offer(final E e) {
-		if(size() >= capacity) {
+		if(isFull()) {
 			final E head = peek();
 			if (this.comparator().compare(e, head) <= 0){
 				return true;

hutool-core/src/main/java/org/dromara/hutool/core/lang/selector/Selector.java

@@ -13,12 +13,14 @@
 package org.dromara.hutool.core.lang.selector;
 
 /**
- * 选择器接口
+ * 选择器接口<br>
+ * 用于抽象负载均衡策略中的选择方式
  *
  * @param <T> 选择对象类型
  * @author looly
  * @since 6.0.0
  */
+@FunctionalInterface
 public interface Selector<T> {
 
 	/**

hutool-core/src/main/java/org/dromara/hutool/core/lang/selector/package-info.java

@@ -13,6 +13,9 @@
 /**
  * 选择器相关封装，包括：
  * <ul>
+ *     <li>{@link org.dromara.hutool.core.lang.selector.IncrementSelector}</li>
+ *     <li>{@link org.dromara.hutool.core.lang.selector.RandomSelector}</li>
+ *     <li>{@link org.dromara.hutool.core.lang.selector.SmoothWeightSelector}</li>
  *     <li>{@link org.dromara.hutool.core.lang.selector.WeightRandomSelector}</li>
  * </ul>
  *

hutool-core/src/test/java/org/dromara/hutool/core/collection/CollUtilTest.java

@@ -27,6 +27,9 @@ import org.junit.jupiter.api.Test;
 import java.util.*;
 import java.util.function.Function;
 
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 /**
  * 集合工具类单元测试
  *
@@ -50,16 +53,16 @@ public class CollUtilTest {
 	@Test
 	public void hasNullTest() {
 		List<Object> list = null;
-		Assertions.assertTrue(CollUtil.hasNull(list));
+		assertTrue(CollUtil.hasNull(list));
 
 		list = ListUtil.of();
-		Assertions.assertFalse(CollUtil.hasNull(list));
+		assertFalse(CollUtil.hasNull(list));
 
 		list = ListUtil.of("");
-		Assertions.assertFalse(CollUtil.hasNull(list));
+		assertFalse(CollUtil.hasNull(list));
 
 		list = ListUtil.of("", null);
-		Assertions.assertTrue(CollUtil.hasNull(list));
+		assertTrue(CollUtil.hasNull(list));
 	}
 
 	@Test
@@ -80,8 +83,8 @@ public class CollUtilTest {
 	@Test
 	public void testPredicateContains() {
 		final List<String> list = ListUtil.of("bbbbb", "aaaaa", "ccccc");
-		Assertions.assertTrue(CollUtil.contains(list, s -> s.startsWith("a")));
+		assertTrue(CollUtil.contains(list, s -> s.startsWith("a")));
-		Assertions.assertFalse(CollUtil.contains(list, s -> s.startsWith("d")));
+		assertFalse(CollUtil.contains(list, s -> s.startsWith("d")));
 	}
 
 	@Test
@@ -131,7 +134,7 @@ public class CollUtilTest {
 	@SuppressWarnings("ConstantValue")
 	@Test
 	public void isNotEmptyTest() {
-		Assertions.assertFalse(CollUtil.isNotEmpty((Collection<?>) null));
+		assertFalse(CollUtil.isNotEmpty((Collection<?>) null));
 	}
 
 	@Test
@@ -171,7 +174,7 @@ public class CollUtilTest {
 
 		final Collection<String> intersectionDistinct2 = CollUtil.intersectionDistinct(list1, list2, list3);
 		Console.log(intersectionDistinct2);
-		Assertions.assertTrue(intersectionDistinct2.isEmpty());
+		assertTrue(intersectionDistinct2.isEmpty());
 	}
 
 	@Test
@@ -180,14 +183,14 @@ public class CollUtilTest {
 		final List<String> list2 = ListUtil.of("a", "b", "b", "b", "c", "d", "x2");
 
 		final Collection<String> disjunction = CollUtil.disjunction(list1, list2);
-		Assertions.assertTrue(disjunction.contains("b"));
+		assertTrue(disjunction.contains("b"));
-		Assertions.assertTrue(disjunction.contains("x2"));
+		assertTrue(disjunction.contains("x2"));
-		Assertions.assertTrue(disjunction.contains("x"));
+		assertTrue(disjunction.contains("x"));
 
 		final Collection<String> disjunction2 = CollUtil.disjunction(list2, list1);
-		Assertions.assertTrue(disjunction2.contains("b"));
+		assertTrue(disjunction2.contains("b"));
-		Assertions.assertTrue(disjunction2.contains("x2"));
+		assertTrue(disjunction2.contains("x2"));
-		Assertions.assertTrue(disjunction2.contains("x"));
+		assertTrue(disjunction2.contains("x"));
 	}
 
 	@Test
@@ -209,19 +212,19 @@ public class CollUtilTest {
 		final List<String> list2 = ListUtil.of("a", "b", "c");
 
 		final Collection<String> disjunction = CollUtil.disjunction(list1, list2);
-		Assertions.assertTrue(disjunction.contains("1"));
+		assertTrue(disjunction.contains("1"));
-		Assertions.assertTrue(disjunction.contains("2"));
+		assertTrue(disjunction.contains("2"));
-		Assertions.assertTrue(disjunction.contains("3"));
+		assertTrue(disjunction.contains("3"));
-		Assertions.assertTrue(disjunction.contains("a"));
+		assertTrue(disjunction.contains("a"));
-		Assertions.assertTrue(disjunction.contains("b"));
+		assertTrue(disjunction.contains("b"));
-		Assertions.assertTrue(disjunction.contains("c"));
+		assertTrue(disjunction.contains("c"));
 		final Collection<String> disjunction2 = CollUtil.disjunction(list2, list1);
-		Assertions.assertTrue(disjunction2.contains("1"));
+		assertTrue(disjunction2.contains("1"));
-		Assertions.assertTrue(disjunction2.contains("2"));
+		assertTrue(disjunction2.contains("2"));
-		Assertions.assertTrue(disjunction2.contains("3"));
+		assertTrue(disjunction2.contains("3"));
-		Assertions.assertTrue(disjunction2.contains("a"));
+		assertTrue(disjunction2.contains("a"));
-		Assertions.assertTrue(disjunction2.contains("b"));
+		assertTrue(disjunction2.contains("b"));
-		Assertions.assertTrue(disjunction2.contains("c"));
+		assertTrue(disjunction2.contains("c"));
 	}
 
 	@Test
@@ -408,7 +411,7 @@ public class CollUtilTest {
 	public void groupTest() {
 		final List<String> list = ListUtil.of("1", "2", "3", "4", "5", "6");
 		final List<List<String>> group = CollUtil.group(list, null);
-		Assertions.assertFalse(group.isEmpty());
+		assertFalse(group.isEmpty());
 
 		final List<List<String>> group2 = CollUtil.group(list, t -> {
 			// 按照奇数偶数分类
@@ -625,7 +628,7 @@ public class CollUtilTest {
 		// Act
 		final List<Integer> retval = CollUtil.sub(list, start, end, step);
 		// Assert result
-		Assertions.assertTrue(retval.isEmpty());
+		assertTrue(retval.isEmpty());
 	}
 
 	@Test
@@ -684,7 +687,7 @@ public class CollUtilTest {
 		// Act
 		final List<Integer> retval = CollUtil.sub(list, start, end, step);
 		// Assert result
-		Assertions.assertTrue(retval.isEmpty());
+		assertTrue(retval.isEmpty());
 	}
 
 	@Test
@@ -741,7 +744,7 @@ public class CollUtilTest {
 		// Act
 		final List<Integer> retval = CollUtil.sub(list, start, end);
 		// Assert result
-		Assertions.assertTrue(retval.isEmpty());
+		assertTrue(retval.isEmpty());
 	}
 
 	@Test
@@ -757,18 +760,18 @@ public class CollUtilTest {
 		final List<Integer> list1 = ListUtil.of(1, 2, 3, 4, 5);
 		final List<Integer> list2 = ListUtil.of(5, 3, 1, 9, 11);
 
-		Assertions.assertTrue(CollUtil.containsAny(list1, list2));
+		assertTrue(CollUtil.containsAny(list1, list2));
 	}
 
 	@Test
 	public void containsAllTest() {
 		final List<Integer> list1 = ListUtil.of(1, 2, 3, 4, 5);
 		final List<Integer> list2 = ListUtil.of(5, 3, 1);
-		Assertions.assertTrue(CollUtil.containsAll(list1, list2));
+		assertTrue(CollUtil.containsAll(list1, list2));
 
 		final List<Integer> list3 = ListUtil.of(1);
 		final List<Integer> list4 = ListUtil.of();
-		Assertions.assertTrue(CollUtil.containsAll(list3, list4));
+		assertTrue(CollUtil.containsAll(list3, list4));
 	}
 
 	@Test
@@ -1069,18 +1072,18 @@ public class CollUtilTest {
 	@Test
 	public void addIfAbsentTest() {
 		// 为false的情况
-		Assertions.assertFalse(CollUtil.addIfAbsent(null, null));
+		assertFalse(CollUtil.addIfAbsent(null, null));
-		Assertions.assertFalse(CollUtil.addIfAbsent(ListUtil.of(), null));
+		assertFalse(CollUtil.addIfAbsent(ListUtil.of(), null));
-		Assertions.assertFalse(CollUtil.addIfAbsent(null, "123"));
+		assertFalse(CollUtil.addIfAbsent(null, "123"));
-		Assertions.assertFalse(CollUtil.addIfAbsent(ListUtil.of("123"), "123"));
+		assertFalse(CollUtil.addIfAbsent(ListUtil.of("123"), "123"));
-		Assertions.assertFalse(CollUtil.addIfAbsent(ListUtil.of(new Animal("jack", 20)),
+		assertFalse(CollUtil.addIfAbsent(ListUtil.of(new Animal("jack", 20)),
 			new Animal("jack", 20)));
 
 		// 正常情况
-		Assertions.assertTrue(CollUtil.addIfAbsent(ListUtil.of("456"), "123"));
+		assertTrue(CollUtil.addIfAbsent(ListUtil.of("456"), "123"));
-		Assertions.assertTrue(CollUtil.addIfAbsent(ListUtil.of(new Animal("jack", 20)),
+		assertTrue(CollUtil.addIfAbsent(ListUtil.of(new Animal("jack", 20)),
 			new Dog("jack", 20)));
-		Assertions.assertTrue(CollUtil.addIfAbsent(ListUtil.of(new Animal("jack", 20)),
+		assertTrue(CollUtil.addIfAbsent(ListUtil.of(new Animal("jack", 20)),
 			new Animal("tom", 20)));
 	}
 
@@ -1155,24 +1158,24 @@ public class CollUtilTest {
 	@Test
 	public void isEqualListTest() {
 		final List<Integer> list = ListUtil.of(1, 2, 3, 4);
-		Assertions.assertTrue(CollUtil.isEqualList(null, null));
+		assertTrue(CollUtil.isEqualList(null, null));
-		Assertions.assertTrue(CollUtil.isEqualList(ListUtil.of(), ListUtil.of()));
+		assertTrue(CollUtil.isEqualList(ListUtil.of(), ListUtil.of()));
-		Assertions.assertTrue(CollUtil.isEqualList(list, list));
+		assertTrue(CollUtil.isEqualList(list, list));
-		Assertions.assertTrue(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3, 4)));
+		assertTrue(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3, 4)));
 
-		Assertions.assertFalse(CollUtil.isEqualList(null, ListUtil.of()));
+		assertFalse(CollUtil.isEqualList(null, ListUtil.of()));
-		Assertions.assertFalse(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3, 3)));
+		assertFalse(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3, 3)));
-		Assertions.assertFalse(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3)));
+		assertFalse(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3)));
-		Assertions.assertFalse(CollUtil.isEqualList(list, ListUtil.of(4, 3, 2, 1)));
+		assertFalse(CollUtil.isEqualList(list, ListUtil.of(4, 3, 2, 1)));
 	}
 
 	@Test
 	public void testMatch() {
 		final List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
-		Assertions.assertTrue(CollUtil.anyMatch(list, i -> i == 1));
+		assertTrue(CollUtil.anyMatch(list, i -> i == 1));
-		Assertions.assertFalse(CollUtil.anyMatch(list, i -> i > 6));
+		assertFalse(CollUtil.anyMatch(list, i -> i > 6));
-		Assertions.assertFalse(CollUtil.allMatch(list, i -> i == 1));
+		assertFalse(CollUtil.allMatch(list, i -> i == 1));
-		Assertions.assertTrue(CollUtil.allMatch(list, i -> i <= 6));
+		assertTrue(CollUtil.allMatch(list, i -> i <= 6));
 	}
 
 	@Test
@@ -1280,6 +1283,6 @@ public class CollUtilTest {
 		coll2.add("1");
 		coll2.add("1");
 
-		Assertions.assertTrue(CollUtil.containsAll(coll1, coll2));
+		assertTrue(CollUtil.containsAll(coll1, coll2));
 	}
 }

hutool-core/src/test/java/org/dromara/hutool/core/collection/iter/IterUtilTest.java

@@ -25,6 +25,8 @@ import org.w3c.dom.NodeList;
 import java.util.*;
 import java.util.function.Function;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 /**
  * test for {@link IterUtil}
  */
@@ -33,7 +35,7 @@ public class IterUtilTest {
 	@Test
 	public void testGetIter() {
 		Assertions.assertNull(IterUtil.getIter(null));
-		Assertions.assertEquals(Collections.emptyIterator(), IterUtil.getIter(Collections.emptyList()));
+		assertEquals(Collections.emptyIterator(), IterUtil.getIter(Collections.emptyList()));
 
 		Assertions.assertNull(IterUtil.getIter((Object)null));
 		Assertions.assertNotNull(IterUtil.getIter(Collections.emptyIterator()));
@@ -45,38 +47,38 @@ public class IterUtilTest {
 
 	@Test
 	public void testIsEmpty() {
-		Assertions.assertTrue(IterUtil.isEmpty(Collections.emptyIterator()));
+		assertTrue(IterUtil.isEmpty(Collections.emptyIterator()));
-		Assertions.assertFalse(IterUtil.isEmpty(Arrays.asList(1, 2).iterator()));
+		assertFalse(IterUtil.isEmpty(Arrays.asList(1, 2).iterator()));
 
-		Assertions.assertTrue(IterUtil.isEmpty(Collections.emptyList()));
+		assertTrue(IterUtil.isEmpty(Collections.emptyList()));
-		Assertions.assertFalse(IterUtil.isEmpty(Arrays.asList(1, 2)));
+		assertFalse(IterUtil.isEmpty(Arrays.asList(1, 2)));
 	}
 
 	@Test
 	public void testIsNotEmpty() {
-		Assertions.assertFalse(IterUtil.isNotEmpty(Collections.emptyIterator()));
+		assertFalse(IterUtil.isNotEmpty(Collections.emptyIterator()));
-		Assertions.assertTrue(IterUtil.isNotEmpty(Arrays.asList(1, 2).iterator()));
+		assertTrue(IterUtil.isNotEmpty(Arrays.asList(1, 2).iterator()));
 
-		Assertions.assertFalse(IterUtil.isNotEmpty(Collections.emptyList()));
+		assertFalse(IterUtil.isNotEmpty(Collections.emptyList()));
-		Assertions.assertTrue(IterUtil.isNotEmpty(Arrays.asList(1, 2)));
+		assertTrue(IterUtil.isNotEmpty(Arrays.asList(1, 2)));
 	}
 
 	@Test
 	public void testHasNull() {
-		Assertions.assertFalse(IterUtil.hasNull(Arrays.asList(1, 3, 2).iterator()));
+		assertFalse(IterUtil.hasNull(Arrays.asList(1, 3, 2).iterator()));
-		Assertions.assertTrue(IterUtil.hasNull(Arrays.asList(1, null, 2).iterator()));
+		assertTrue(IterUtil.hasNull(Arrays.asList(1, null, 2).iterator()));
-		Assertions.assertFalse(IterUtil.hasNull(Collections.emptyIterator()));
+		assertFalse(IterUtil.hasNull(Collections.emptyIterator()));
-		Assertions.assertTrue(IterUtil.hasNull(null));
+		assertTrue(IterUtil.hasNull(null));
 	}
 
 	@Test
 	public void testIsAllNull() {
-		Assertions.assertTrue(IterUtil.isAllNull(Arrays.asList(null, null)));
+		assertTrue(IterUtil.isAllNull(Arrays.asList(null, null)));
-		Assertions.assertFalse(IterUtil.isAllNull(Arrays.asList(1, null)));
+		assertFalse(IterUtil.isAllNull(Arrays.asList(1, null)));
-		Assertions.assertTrue(IterUtil.isAllNull((Iterable<?>)null));
+		assertTrue(IterUtil.isAllNull((Iterable<?>)null));
-		Assertions.assertTrue(IterUtil.isAllNull(Arrays.asList(null, null).iterator()));
+		assertTrue(IterUtil.isAllNull(Arrays.asList(null, null).iterator()));
-		Assertions.assertFalse(IterUtil.isAllNull(Arrays.asList(1, null).iterator()));
+		assertFalse(IterUtil.isAllNull(Arrays.asList(1, null).iterator()));
-		Assertions.assertTrue(IterUtil.isAllNull((Iterator<?>)null));
+		assertTrue(IterUtil.isAllNull((Iterator<?>)null));
 	}
 
 	@Test
@@ -84,8 +86,8 @@ public class IterUtilTest {
 		final Object o1 = new Object();
 		final Object o2 = new Object();
 		final Map<Object, Integer> countMap = IterUtil.countMap(Arrays.asList(o1, o2, o1, o1).iterator());
-		Assertions.assertEquals((Integer)3, countMap.get(o1));
+		assertEquals((Integer)3, countMap.get(o1));
-		Assertions.assertEquals((Integer)1, countMap.get(o2));
+		assertEquals((Integer)1, countMap.get(o2));
 	}
 
 	@Test
@@ -93,8 +95,8 @@ public class IterUtilTest {
 		final Bean bean1 = new Bean(1, "A");
 		final Bean bean2 = new Bean(2, "B");
 		final Map<Integer, Bean> map = IterUtil.fieldValueMap(Arrays.asList(bean1, bean2).iterator(), "id");
-		Assertions.assertEquals(bean1, map.get(1));
+		assertEquals(bean1, map.get(1));
-		Assertions.assertEquals(bean2, map.get(2));
+		assertEquals(bean2, map.get(2));
 	}
 
 	@Test
@@ -104,16 +106,16 @@ public class IterUtilTest {
 		final Map<Integer, String> map = IterUtil.fieldValueAsMap(
 			Arrays.asList(bean1, bean2).iterator(), "id", "name"
 		);
-		Assertions.assertEquals("A", map.get(1));
+		assertEquals("A", map.get(1));
-		Assertions.assertEquals("B", map.get(2));
+		assertEquals("B", map.get(2));
 	}
 
 	@Test
 	public void testFieldValueList() {
 		final Bean bean1 = new Bean(1, "A");
 		final Bean bean2 = new Bean(2, "B");
-		Assertions.assertEquals(Arrays.asList(1, 2), IterUtil.fieldValueList(Arrays.asList(bean1, bean2), "id"));
+		assertEquals(Arrays.asList(1, 2), IterUtil.fieldValueList(Arrays.asList(bean1, bean2), "id"));
-		Assertions.assertEquals(
+		assertEquals(
 			Arrays.asList(1, 2),
 			IterUtil.fieldValueList(Arrays.asList(bean1, bean2).iterator(), "id")
 		);
@@ -122,9 +124,9 @@ public class IterUtilTest {
 	@Test
 	public void testJoin() {
 		final List<String> stringList = Arrays.asList("1", "2", "3");
-		Assertions.assertEquals("123", IterUtil.join(stringList.iterator(), ""));
+		assertEquals("123", IterUtil.join(stringList.iterator(), ""));
-		Assertions.assertEquals("-1--2--3-", IterUtil.join(stringList.iterator(), "", "-", "-"));
+		assertEquals("-1--2--3-", IterUtil.join(stringList.iterator(), "", "-", "-"));
-		Assertions.assertEquals("123", IterUtil.join(stringList.iterator(), "", Function.identity()));
+		assertEquals("123", IterUtil.join(stringList.iterator(), "", Function.identity()));
 	}
 
 	@Test
@@ -132,28 +134,28 @@ public class IterUtilTest {
 		final List<Integer> keys = Arrays.asList(1, 2, 3);
 
 		Map<Integer, Integer> map = IterUtil.toMap(keys, keys);
-		Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
+		assertEquals(keys, new ArrayList<>(map.keySet()));
-		Assertions.assertEquals(keys, new ArrayList<>(map.values()));
+		assertEquals(keys, new ArrayList<>(map.values()));
 
 		map = IterUtil.toMap(keys.iterator(), keys.iterator());
-		Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
+		assertEquals(keys, new ArrayList<>(map.keySet()));
-		Assertions.assertEquals(keys, new ArrayList<>(map.values()));
+		assertEquals(keys, new ArrayList<>(map.values()));
 
 		map = IterUtil.toMap(keys.iterator(), keys.iterator(), true);
-		Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
+		assertEquals(keys, new ArrayList<>(map.keySet()));
-		Assertions.assertEquals(keys, new ArrayList<>(map.values()));
+		assertEquals(keys, new ArrayList<>(map.values()));
 
 		map = IterUtil.toMap(keys, keys, true);
-		Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
+		assertEquals(keys, new ArrayList<>(map.keySet()));
-		Assertions.assertEquals(keys, new ArrayList<>(map.values()));
+		assertEquals(keys, new ArrayList<>(map.values()));
 
 		map = IterUtil.toMap(keys, Function.identity());
-		Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
+		assertEquals(keys, new ArrayList<>(map.keySet()));
-		Assertions.assertEquals(keys, new ArrayList<>(map.values()));
+		assertEquals(keys, new ArrayList<>(map.values()));
 
 		map = IterUtil.toMap(keys, Function.identity(), Function.identity());
-		Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
+		assertEquals(keys, new ArrayList<>(map.keySet()));
-		Assertions.assertEquals(keys, new ArrayList<>(map.values()));
+		assertEquals(keys, new ArrayList<>(map.values()));
 	}
 
 	@Test
@@ -161,18 +163,18 @@ public class IterUtilTest {
 		final List<Integer> keys = Arrays.asList(1, 2, 3, 4);
 
 		Map<Boolean, List<Integer>> map = IterUtil.toListMap(keys, i -> (i & 1) == 0, Function.identity());
-		Assertions.assertEquals(Arrays.asList(2, 4), map.get(true));
+		assertEquals(Arrays.asList(2, 4), map.get(true));
-		Assertions.assertEquals(Arrays.asList(1, 3), map.get(false));
+		assertEquals(Arrays.asList(1, 3), map.get(false));
 
 		map = IterUtil.toListMap(keys, i -> (i & 1) == 0);
-		Assertions.assertEquals(Arrays.asList(2, 4), map.get(true));
+		assertEquals(Arrays.asList(2, 4), map.get(true));
-		Assertions.assertEquals(Arrays.asList(1, 3), map.get(false));
+		assertEquals(Arrays.asList(1, 3), map.get(false));
 
 		map = new LinkedHashMap<>();
 		final Map<Boolean, List<Integer>> rawMap = IterUtil.toListMap(map, keys, i -> (i & 1) == 0, Function.identity());
 		Assertions.assertSame(rawMap, map);
-		Assertions.assertEquals(Arrays.asList(2, 4), rawMap.get(true));
+		assertEquals(Arrays.asList(2, 4), rawMap.get(true));
-		Assertions.assertEquals(Arrays.asList(1, 3), rawMap.get(false));
+		assertEquals(Arrays.asList(1, 3), rawMap.get(false));
 	}
 
 	@Test
@@ -183,38 +185,38 @@ public class IterUtilTest {
 
 		final Map<String, List<String>> testMap = IterUtil.toListMap(Arrays.asList("and", "brave", "back"),
 			v -> v.substring(0, 1));
-		Assertions.assertEquals(testMap, expectedMap);
+		assertEquals(testMap, expectedMap);
 	}
 
 	@SuppressWarnings("DataFlowIssue")
 	@Test
 	public void testAsIterable() {
 		final Iterator<Integer> iter = Arrays.asList(1, 2, 3).iterator();
-		Assertions.assertEquals(iter, IterUtil.asIterable(iter).iterator());
+		assertEquals(iter, IterUtil.asIterable(iter).iterator());
 		Assertions.assertNull(IterUtil.asIterable(null).iterator());
 
 		final Enumeration<Integer> enumeration = new IteratorEnumeration<>(iter);
 		final Iterator<Integer> iter2 = IterUtil.asIterator(enumeration);
-		Assertions.assertEquals((Integer)1, iter2.next());
+		assertEquals((Integer)1, iter2.next());
-		Assertions.assertEquals((Integer)2, iter2.next());
+		assertEquals((Integer)2, iter2.next());
-		Assertions.assertEquals((Integer)3, iter2.next());
+		assertEquals((Integer)3, iter2.next());
 	}
 
 	@Test
 	public void testGet() {
 		final Iterator<Integer> iter = Arrays.asList(1, 2, 3, 4).iterator();
-		Assertions.assertEquals((Integer)3, IterUtil.get(iter, 2));
+		assertEquals((Integer)3, IterUtil.get(iter, 2));
 		Assertions.assertThrows(IllegalArgumentException.class, () -> IterUtil.get(iter, -1));
 	}
 
 	@Test
 	public void testGetFirst() {
 		final Iterator<Integer> iter = Arrays.asList(1, 2, 3, 4).iterator();
-		Assertions.assertEquals((Integer)1, IterUtil.getFirst(iter));
+		assertEquals((Integer)1, IterUtil.getFirst(iter));
 		Assertions.assertNull(IterUtil.getFirst(null));
 		Assertions.assertNull(IterUtil.getFirst(Collections.emptyIterator()));
 
-		Assertions.assertEquals((Integer)2, IterUtil.getFirst(iter, t -> (t & 1) == 0));
+		assertEquals((Integer)2, IterUtil.getFirst(iter, t -> (t & 1) == 0));
 		Assertions.assertNull(IterUtil.getFirst((Iterator<Integer>)null, t -> (t & 1) == 0));
 		Assertions.assertNull(IterUtil.getFirst(Collections.emptyIterator(), Objects::nonNull));
 	}
@@ -222,7 +224,7 @@ public class IterUtilTest {
 	@Test
 	public void testGetFirstNoneNull() {
 		final Iterator<Integer> iter = Arrays.asList(null, 2, null, 4).iterator();
-		Assertions.assertEquals((Integer)2, IterUtil.getFirstNoneNull(iter));
+		assertEquals((Integer)2, IterUtil.getFirstNoneNull(iter));
 		Assertions.assertNull(IterUtil.getFirstNoneNull(null));
 		Assertions.assertNull(IterUtil.getFirstNoneNull(Collections.emptyIterator()));
 	}
@@ -230,40 +232,40 @@ public class IterUtilTest {
 	@Test
 	public void testGetElementType() {
 		final List<Object> list = Arrays.asList(null, "str", null);
-		Assertions.assertEquals(String.class, IterUtil.getElementType(list));
+		assertEquals(String.class, IterUtil.getElementType(list));
 		Assertions.assertNull(IterUtil.getElementType((Iterable<?>)null));
 		Assertions.assertNull(IterUtil.getElementType(Collections.emptyList()));
 
-		Assertions.assertEquals(String.class, IterUtil.getElementType(list.iterator()));
+		assertEquals(String.class, IterUtil.getElementType(list.iterator()));
 		Assertions.assertNull(IterUtil.getElementType((Iterator<?>)null));
 		Assertions.assertNull(IterUtil.getElementType(Collections.emptyIterator()));
 	}
 
 	@Test
 	public void testEdit() {
-		Assertions.assertEquals(
+		assertEquals(
 			Collections.singletonList("str"),
 			IterUtil.edit(Arrays.asList(null, "str", null).iterator(), t -> t)
 		);
-		Assertions.assertEquals(
+		assertEquals(
 			Collections.singletonList("str"),
 			IterUtil.edit(Arrays.asList(null, "str", null).iterator(), null)
 		);
-		Assertions.assertEquals(Collections.emptyList(), IterUtil.edit(null, t -> t));
+		assertEquals(Collections.emptyList(), IterUtil.edit(null, t -> t));
 	}
 
 	@Test
 	public void testRemove() {
 		final List<Integer> list = new ArrayList<>(Arrays.asList(1, null, null, 3));
 		IterUtil.remove(list.iterator(), Objects::isNull);
-		Assertions.assertEquals(Arrays.asList(1, 3), list);
+		assertEquals(Arrays.asList(1, 3), list);
 	}
 
 	@Test
 	public void testFilterToList() {
 		final List<Integer> list1 = new ArrayList<>(Arrays.asList(1, null, null, 3));
 		final List<Integer> list2 = IterUtil.filterToList(list1.iterator(), Objects::nonNull);
-		Assertions.assertEquals(Arrays.asList(1, 3), list2);
+		assertEquals(Arrays.asList(1, 3), list2);
 	}
 
 	@Test
@@ -283,46 +285,46 @@ public class IterUtilTest {
 
 	@Test
 	public void testSize() {
-		Assertions.assertEquals(0, IterUtil.size((Iterator<?>)null));
+		assertEquals(0, IterUtil.size((Iterator<?>)null));
-		Assertions.assertEquals(0, IterUtil.size(Collections.emptyIterator()));
+		assertEquals(0, IterUtil.size(Collections.emptyIterator()));
-		Assertions.assertEquals(3, IterUtil.size(Arrays.asList(1, 2, 3).iterator()));
+		assertEquals(3, IterUtil.size(Arrays.asList(1, 2, 3).iterator()));
 
-		Assertions.assertEquals(0, IterUtil.size((Iterable<?>)null));
+		assertEquals(0, IterUtil.size((Iterable<?>)null));
-		Assertions.assertEquals(0, IterUtil.size(Collections.emptyList()));
+		assertEquals(0, IterUtil.size(Collections.emptyList()));
-		Assertions.assertEquals(3, IterUtil.size(Arrays.asList(1, 2, 3)));
+		assertEquals(3, IterUtil.size(Arrays.asList(1, 2, 3)));
 	}
 
 	@Test
 	public void testIsEqualList() {
-		Assertions.assertFalse(IterUtil.isEqualList(null, Collections.emptyList()));
+		assertFalse(IterUtil.isEqualList(null, Collections.emptyList()));
-		Assertions.assertFalse(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Collections.emptyList()));
+		assertFalse(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Collections.emptyList()));
-		Assertions.assertFalse(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Arrays.asList(1, 2)));
+		assertFalse(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Arrays.asList(1, 2)));
-		Assertions.assertTrue(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Arrays.asList(1, 2, 3)));
+		assertTrue(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Arrays.asList(1, 2, 3)));
-		Assertions.assertTrue(IterUtil.isEqualList(null, null));
+		assertTrue(IterUtil.isEqualList(null, null));
-		Assertions.assertTrue(IterUtil.isEqualList(Collections.emptyList(), Collections.emptyList()));
+		assertTrue(IterUtil.isEqualList(Collections.emptyList(), Collections.emptyList()));
 	}
 
 	@Test
 	public void testClear() {
 		final List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
 		IterUtil.clear(list.iterator());
-		Assertions.assertTrue(list.isEmpty());
+		assertTrue(list.isEmpty());
 		Assertions.assertThrows(UnsupportedOperationException.class, () -> IterUtil.clear(Arrays.asList(1, 2).iterator()));
 	}
 
 	@Test
 	public void testToStr() {
 		final List<Integer> list = Arrays.asList(1, 2, 3);
-		Assertions.assertEquals("[1, 2, 3]", IterUtil.toStr(list.iterator()));
+		assertEquals("[1, 2, 3]", IterUtil.toStr(list.iterator()));
-		Assertions.assertEquals("[1, 2, 3]", IterUtil.toStr(list.iterator(), Objects::toString));
+		assertEquals("[1, 2, 3]", IterUtil.toStr(list.iterator(), Objects::toString));
-		Assertions.assertEquals("{1:2:3}", IterUtil.toStr(list.iterator(), Objects::toString, ":", "{", "}"));
+		assertEquals("{1:2:3}", IterUtil.toStr(list.iterator(), Objects::toString, ":", "{", "}"));
 	}
 
 	@Test
 	public void testForEach() {
 		final List<Integer> list = new ArrayList<>();
 		IterUtil.forEach(Arrays.asList(1, 2, 3, 4).iterator(), list::add);
-		Assertions.assertEquals(Arrays.asList(1, 2, 3, 4), list);
+		assertEquals(Arrays.asList(1, 2, 3, 4), list);
 	}
 
 	@SuppressWarnings("unused")
@@ -335,7 +337,7 @@ public class IterUtilTest {
 	@Test
 	public void getFirstNonNullTest() {
 		final List<String> strings = ListUtil.of(null, null, "123", "456", null);
-		Assertions.assertEquals("123", CollUtil.getFirstNoneNull(strings));
+		assertEquals("123", CollUtil.getFirstNoneNull(strings));
 	}
 
 	@Test
@@ -346,39 +348,39 @@ public class IterUtilTest {
 			new Car("567", "路虎"));
 		final Map<String, Car> carNameMap = IterUtil.fieldValueMap(carList.iterator(), "carNumber");
 
-		Assertions.assertEquals("大众", carNameMap.get("123").getCarName());
+		assertEquals("大众", carNameMap.get("123").getCarName());
-		Assertions.assertEquals("奔驰", carNameMap.get("345").getCarName());
+		assertEquals("奔驰", carNameMap.get("345").getCarName());
-		Assertions.assertEquals("路虎", carNameMap.get("567").getCarName());
+		assertEquals("路虎", carNameMap.get("567").getCarName());
 	}
 
 	@Test
 	public void joinTest() {
 		final List<String> list = ListUtil.of("1", "2", "3", "4");
 		final String join = IterUtil.join(list.iterator(), ":");
-		Assertions.assertEquals("1:2:3:4", join);
+		assertEquals("1:2:3:4", join);
 
 		final List<Integer> list1 = ListUtil.of(1, 2, 3, 4);
 		final String join1 = IterUtil.join(list1.iterator(), ":");
-		Assertions.assertEquals("1:2:3:4", join1);
+		assertEquals("1:2:3:4", join1);
 
 		// 包装每个节点
 		final List<String> list2 = ListUtil.of("1", "2", "3", "4");
 		final String join2 = IterUtil.join(list2.iterator(), ":", "\"", "\"");
-		Assertions.assertEquals("\"1\":\"2\":\"3\":\"4\"", join2);
+		assertEquals("\"1\":\"2\":\"3\":\"4\"", join2);
 	}
 
 	@Test
 	public void joinWithFuncTest() {
 		final List<String> list = ListUtil.of("1", "2", "3", "4");
 		final String join = IterUtil.join(list.iterator(), ":", String::valueOf);
-		Assertions.assertEquals("1:2:3:4", join);
+		assertEquals("1:2:3:4", join);
 	}
 
 	@Test
 	public void joinWithNullTest() {
 		final List<String> list = ListUtil.of("1", null, "3", "4");
 		final String join = IterUtil.join(list.iterator(), ":", String::valueOf);
-		Assertions.assertEquals("1:null:3:4", join);
+		assertEquals("1:null:3:4", join);
 	}
 
 	@Test
@@ -392,14 +394,14 @@ public class IterUtilTest {
 		expectedMap.put("456", benz);
 
 		final Map<String, Car> testMap = IterUtil.toMap(Arrays.asList(bmw, benz), Car::getCarNumber);
-		Assertions.assertEquals(expectedMap, testMap);
+		assertEquals(expectedMap, testMap);
 	}
 
 	@Test
 	public void getElementTypeTest() {
 		final List<Integer> integers = Arrays.asList(null, 1);
 		final Class<?> elementType = IterUtil.getElementType(integers);
-		Assertions.assertEquals(Integer.class, elementType);
+		assertEquals(Integer.class, elementType);
 	}
 
 	@Data
@@ -416,8 +418,8 @@ public class IterUtilTest {
 
 		IterUtil.remove(obj.iterator(), (e)-> !obj2.contains(e));
 
-		Assertions.assertEquals(1, obj.size());
+		assertEquals(1, obj.size());
-		Assertions.assertEquals("3", obj.get(0));
+		assertEquals("3", obj.get(0));
 	}
 
 	@Test
@@ -427,8 +429,8 @@ public class IterUtilTest {
 
 		final FilterIter<String> filtered = IterUtil.filtered(obj.iterator(), obj2::contains);
 
-		Assertions.assertEquals("3", filtered.next());
+		assertEquals("3", filtered.next());
-		Assertions.assertFalse(filtered.hasNext());
+		assertFalse(filtered.hasNext());
 	}
 
 	@Test
@@ -438,15 +440,49 @@ public class IterUtilTest {
 
 		final List<String> filtered = IterUtil.filterToList(obj.iterator(), obj2::contains);
 
-		Assertions.assertEquals(1, filtered.size());
+		assertEquals(1, filtered.size());
-		Assertions.assertEquals("3", filtered.get(0));
+		assertEquals("3", filtered.get(0));
 	}
 
 	@Test
 	public void getTest() {
 		final HashSet<String> set = SetUtil.ofLinked("A", "B", "C", "D");
 		final String str = IterUtil.get(set.iterator(), 2);
-		Assertions.assertEquals("C", str);
+		assertEquals("C", str);
 	}
 
+	@Test
+	public void testIsSubTrue() {
+		final List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
+		assertTrue(IterUtil.isSub(list, list), "Expected a list to be a subset of itself");
+
+		final List<Integer> subList = Arrays.asList(1, 2, 3);
+		assertTrue(IterUtil.isSub(subList, list), "Expected subList to be a subset of list");
+
+		assertFalse(IterUtil.isSub(list, subList), "Expected subList to not be a subset of list due to extra elements");
+	}
+
+	@Test
+	public void testIsSubFalseDueToMissingElements() {
+		final List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
+		final List<Integer> subList = Arrays.asList(1, 2, 6);
+		assertFalse(IterUtil.isSub(subList, list), "Expected subList to not be a subset of list due to missing elements");
+	}
+
+	@Test
+	public void testIsSubWithEmptySubList() {
+		final List<Integer> list = Arrays.asList(1, 2, 3);
+		final List<Integer> subList = Collections.emptyList();
+		assertTrue(IterUtil.isSub(subList, list), "Expected an empty subList to be considered a subset of list");
+
+		assertFalse(IterUtil.isSub(list, subList), "Expected subList to not be a subset of an empty list");
+	}
+
+	@Test
+	public void testIsSubWithNullIterable() {
+		final List<Integer> list = Arrays.asList(1, 2, 3);
+		assertFalse(IterUtil.isSub(null, list), "Expected null to not be considered a subset of list");
+		assertFalse(IterUtil.isSub(list, null), "Expected list to not be considered a subset of null");
+		assertTrue(IterUtil.isSub(null, null), "Expected null to not be considered a subset of null");
+	}
 }

hutool-poi/src/main/java/org/dromara/hutool/poi/csv/CsvParser.java

@@ -115,7 +115,7 @@ public final class CsvParser extends ComputeIter<CsvRow> implements Closeable, S
 		if (lineNo < config.beginLineNo) {
 			throw new IllegalStateException("No header available - call nextRow() first");
 		}
-		return header.fields;
+		return header.getRaw();
 	}
 
 	@Override

hutool-poi/src/main/java/org/dromara/hutool/poi/csv/CsvRow.java

@@ -14,6 +14,7 @@ package org.dromara.hutool.poi.csv;
 
 import org.dromara.hutool.core.bean.BeanUtil;
 import org.dromara.hutool.core.bean.copier.CopyOptions;
+import org.dromara.hutool.core.collection.ListWrapper;
 import org.dromara.hutool.core.lang.Assert;
 
 import java.util.*;
@@ -23,13 +24,12 @@ import java.util.*;
  *
  * @author Looly
  */
-public final class CsvRow implements List<String> {
+public final class CsvRow extends ListWrapper<String> {
 
 	/** 原始行号 */
 	private final long originalLineNumber;
 
 	final Map<String, Integer> headerMap;
-	final List<String> fields;
 
 	/**
 	 * 构造
@@ -39,10 +39,9 @@ public final class CsvRow implements List<String> {
 	 * @param fields 数据列表
 	 */
 	public CsvRow(final long originalLineNumber, final Map<String, Integer> headerMap, final List<String> fields) {
-		Assert.notNull(fields, "fields must be not null!");
+		super(Assert.notNull(fields, "fields must be not null!"));
 		this.originalLineNumber = originalLineNumber;
 		this.headerMap = headerMap;
-		this.fields = fields;
 	}
 
 	/**
@@ -71,15 +70,6 @@ public final class CsvRow implements List<String> {
 		return null;
 	}
 
-	/**
-	 * 获取本行所有字段值列表
-	 *
-	 * @return 字段值列表
-	 */
-	public List<String> getRawList() {
-		return fields;
-	}
-
 	/**
 	 * 获取标题与字段值对应的Map
 	 *
@@ -117,128 +107,14 @@ public final class CsvRow implements List<String> {
 		return BeanUtil.toBean(getFieldMap(), clazz, CopyOptions.of().setIgnoreError(true));
 	}
 
-	/**
-	 * 获取字段格式
-	 *
-	 * @return 字段格式
-	 */
-	public int getFieldCount() {
-		return fields.size();
-	}
-
-	@Override
-	public int size() {
-		return this.fields.size();
-	}
-
-	@Override
-	public boolean isEmpty() {
-		return this.fields.isEmpty();
-	}
-
-	@Override
-	public boolean contains(final Object o) {
-		return this.fields.contains(o);
-	}
-
-	@Override
-	public Iterator<String> iterator() {
-		return this.fields.iterator();
-	}
-
-	@Override
-	public Object[] toArray() {
-		return this.fields.toArray();
-	}
-
-	@Override
-	public <T> T[] toArray(final T[] a) {
-		return this.fields.toArray(a);
-	}
-
-	@Override
-	public boolean add(final String e) {
-		return this.fields.add(e);
-	}
-
-	@Override
-	public boolean remove(final Object o) {
-		return this.fields.remove(o);
-	}
-
 	@Override
 	public boolean containsAll(final Collection<?> c) {
-		return new HashSet<>(this.fields).containsAll(c);
+		return new HashSet<>(this.raw).containsAll(c);
-	}
-
-	@Override
-	public boolean addAll(final Collection<? extends String> c) {
-		return this.fields.addAll(c);
-	}
-
-	@Override
-	public boolean addAll(final int index, final Collection<? extends String> c) {
-		return this.fields.addAll(index, c);
-	}
-
-	@Override
-	public boolean removeAll(final Collection<?> c) {
-		return this.fields.removeAll(c);
-	}
-
-	@Override
-	public boolean retainAll(final Collection<?> c) {
-		return this.fields.retainAll(c);
-	}
-
-	@Override
-	public void clear() {
-		this.fields.clear();
 	}
 
 	@Override
 	public String get(final int index) {
-		return index >= fields.size() ? null : fields.get(index);
+		return index >= size() ? null : super.get(index);
-	}
-
-	@Override
-	public String set(final int index, final String element) {
-		return this.fields.set(index, element);
-	}
-
-	@Override
-	public void add(final int index, final String element) {
-		this.fields.add(index, element);
-	}
-
-	@Override
-	public String remove(final int index) {
-		return this.fields.remove(index);
-	}
-
-	@Override
-	public int indexOf(final Object o) {
-		return this.fields.indexOf(o);
-	}
-
-	@Override
-	public int lastIndexOf(final Object o) {
-		return this.fields.lastIndexOf(o);
-	}
-
-	@Override
-	public ListIterator<String> listIterator() {
-		return this.fields.listIterator();
-	}
-
-	@Override
-	public ListIterator<String> listIterator(final int index) {
-		return this.fields.listIterator(index);
-	}
-
-	@Override
-	public List<String> subList(final int fromIndex, final int toIndex) {
-		return this.fields.subList(fromIndex, toIndex);
 	}
 
 	@Override
@@ -265,7 +141,7 @@ public final class CsvRow implements List<String> {
 			}
 			sb.append('}');
 		} else {
-			sb.append(fields.toString());
+			sb.append(this.raw.toString());
 		}
 
 		sb.append('}');

hutool-poi/src/test/java/org/dromara/hutool/poi/csv/CsvParserTest.java

@@ -27,7 +27,7 @@ public class CsvParserTest {
 		final CsvParser parser = new CsvParser(reader, null);
 		final CsvRow row = parser.nextRow();
 		//noinspection ConstantConditions
-		Assertions.assertEquals("b\"bba\"", row.getRawList().get(1));
+		Assertions.assertEquals("b\"bba\"", row.getRaw().get(1));
 		IoUtil.closeQuietly(parser);
 	}
 
@@ -37,7 +37,7 @@ public class CsvParserTest {
 		final CsvParser parser = new CsvParser(reader, null);
 		final CsvRow row = parser.nextRow();
 		//noinspection ConstantConditions
-		Assertions.assertEquals("\"bba\"bbb", row.getRawList().get(1));
+		Assertions.assertEquals("\"bba\"bbb", row.getRaw().get(1));
 		IoUtil.closeQuietly(parser);
 	}
 
@@ -47,7 +47,7 @@ public class CsvParserTest {
 		final CsvParser parser = new CsvParser(reader, null);
 		final CsvRow row = parser.nextRow();
 		//noinspection ConstantConditions
-		Assertions.assertEquals("bba", row.getRawList().get(1));
+		Assertions.assertEquals("bba", row.getRaw().get(1));
 		IoUtil.closeQuietly(parser);
 	}
 
@@ -57,7 +57,7 @@ public class CsvParserTest {
 		final CsvParser parser = new CsvParser(reader, null);
 		final CsvRow row = parser.nextRow();
 		//noinspection ConstantConditions
-		Assertions.assertEquals("", row.getRawList().get(1));
+		Assertions.assertEquals("", row.getRaw().get(1));
 		IoUtil.closeQuietly(parser);
 	}