Merge branch 'v6-dev' into refactor-stream

# Conflicts:
#	hutool-core/src/main/java/cn/hutool/core/stream/EasyStream.java
#	hutool-core/src/main/java/cn/hutool/core/stream/WrappedStream.java

hutool-core/src/test/java/cn/hutool/core/collection/iter/ArrayIterTest.java

@@ -0,0 +1,50 @@
+package cn.hutool.core.collection.iter;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * test for {@link ArrayIter}
+ */
+public class ArrayIterTest {
+
+	@Test
+	public void testHasNext() {
+		Integer[] arr = new Integer[]{ 1, 2, 3 };
+		ArrayIter<Integer> iter = new ArrayIter<>(arr);
+		Assert.assertTrue(iter.hasNext());
+	}
+
+	@Test
+	public void testNext() {
+		Integer[] arr = new Integer[]{ 1, 2, 3 };
+		ArrayIter<Integer> iter = new ArrayIter<>(arr);
+		Assert.assertEquals((Integer)1, iter.next());
+		Assert.assertEquals((Integer)2, iter.next());
+		Assert.assertEquals((Integer)3, iter.next());
+	}
+
+	@Test
+	public void testRemove() {
+		Integer[] arr = new Integer[]{ 1, 2, 3 };
+		ArrayIter<Integer> iter = new ArrayIter<>(arr);
+		Assert.assertThrows(UnsupportedOperationException.class, iter::remove);
+	}
+
+	@Test
+	public void testGetArray() {
+		Integer[] arr = new Integer[]{ 1, 2, 3 };
+		ArrayIter<Integer> iter = new ArrayIter<>(arr);
+		Assert.assertEquals(arr, iter.getArray());
+	}
+
+	@Test
+	public void testReset() {
+		Integer[] arr = new Integer[]{ 1, 2, 3 };
+		ArrayIter<Integer> iter = new ArrayIter<>(arr);
+		Assert.assertEquals((Integer)1, iter.next());
+		iter.reset();
+		Assert.assertEquals((Integer)1, iter.next());
+	}
+
+}

hutool-core/src/test/java/cn/hutool/core/collection/iter/CopiedIterTest.java

@@ -0,0 +1,47 @@
+package cn.hutool.core.collection.iter;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * test for {@link CopiedIter}
+ */
+public class CopiedIterTest {
+
+	@Test
+	public void copyOf() {
+		List<Integer> list = Arrays.asList(1, 2, 3);
+		Iterator<Integer> iter = list.iterator();
+		Assert.assertEquals((Integer)1, iter.next());
+
+		Assert.assertEquals((Integer)2, CopiedIter.copyOf(iter).next());
+	}
+
+	@Test
+	public void hasNext() {
+		Assert.assertTrue(CopiedIter.copyOf(Arrays.asList(1, 2, 3).iterator()).hasNext());
+		Assert.assertFalse(CopiedIter.copyOf(Collections.emptyIterator()).hasNext());
+	}
+
+	@Test
+	public void next() {
+		List<Integer> list = Arrays.asList(1, 2, 3);
+		Iterator<Integer> iter = CopiedIter.copyOf(list.iterator());
+		Assert.assertEquals((Integer)1, iter.next());
+		Assert.assertEquals((Integer)2, iter.next());
+		Assert.assertEquals((Integer)3, iter.next());
+	}
+
+	@Test
+	public void remove() {
+		List<Integer> list = Arrays.asList(1, 2, 3);
+		Iterator<Integer> iter = CopiedIter.copyOf(list.iterator());
+		Assert.assertThrows(UnsupportedOperationException.class, iter::remove);
+	}
+
+}

hutool-core/src/test/java/cn/hutool/core/collection/iter/EnumerationIterTest.java

@@ -0,0 +1,46 @@
+package cn.hutool.core.collection.iter;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Enumeration;
+
+/**
+ * @author huangchengxing
+ */
+public class EnumerationIterTest {
+
+	@Test
+	public void testHasNext() {
+		Enumeration<Integer> enumeration = new IteratorEnumeration<>(Arrays.asList(1, 2, 3).iterator());
+		EnumerationIter<Integer> iter = new EnumerationIter<>(enumeration);
+		Assert.assertTrue(iter.hasNext());
+		Assert.assertFalse(new EnumerationIter<>(new IteratorEnumeration<>(Collections.emptyIterator())).hasNext());
+	}
+
+	@Test
+	public void testNext() {
+		Enumeration<Integer> enumeration = new IteratorEnumeration<>(Arrays.asList(1, 2, 3).iterator());
+		EnumerationIter<Integer> iter = new EnumerationIter<>(enumeration);
+		Assert.assertEquals((Integer)1, iter.next());
+		Assert.assertEquals((Integer)2, iter.next());
+		Assert.assertEquals((Integer)3, iter.next());
+	}
+
+	@Test
+	public void testRemove() {
+		Enumeration<Integer> enumeration = new IteratorEnumeration<>(Arrays.asList(1, 2, 3).iterator());
+		EnumerationIter<Integer> iter = new EnumerationIter<>(enumeration);
+		Assert.assertThrows(UnsupportedOperationException.class, iter::remove);
+	}
+
+	@Test
+	public void testIterator() {
+		Enumeration<Integer> enumeration = new IteratorEnumeration<>(Arrays.asList(1, 2, 3).iterator());
+		EnumerationIter<Integer> iter = new EnumerationIter<>(enumeration);
+		Assert.assertSame(iter, iter.iterator());
+	}
+
+}

hutool-core/src/test/java/cn/hutool/core/collection/iter/FilterIterTest.java

@@ -4,7 +4,10 @@ import cn.hutool.core.collection.ListUtil;
 import org.junit.Assert;
 import org.junit.Test;
 
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.Iterator;
+import java.util.function.Predicate;
 
 public class FilterIterTest {
 
@@ -20,4 +23,40 @@ public class FilterIterTest {
 		}
 		Assert.assertEquals(2, count);
 	}
+
+    @Test
+    public void hasNext() {
+		Iterator<Integer> iter = new FilterIter<>(Arrays.asList(1, 2, 3).iterator(), i -> true);
+		Assert.assertTrue(iter.hasNext());
+		iter = new FilterIter<>(Collections.emptyIterator(), i -> true);
+		Assert.assertFalse(iter.hasNext());
+    }
+
+    @Test
+    public void next() {
+		// 只保留奇数
+		Iterator<Integer> iter = new FilterIter<>(Arrays.asList(1, 2, 3).iterator(), i -> (i & 1) == 1);
+		Assert.assertEquals((Integer)1, iter.next());
+		Assert.assertEquals((Integer)3, iter.next());
+    }
+
+    @Test
+    public void remove() {
+		Iterator<Integer> iter = new FilterIter<>(Collections.emptyIterator(), i -> true);
+		Assert.assertThrows(IllegalStateException.class, iter::remove);
+    }
+
+    @Test
+    public void getIterator() {
+		FilterIter<Integer> iter = new FilterIter<>(Collections.emptyIterator(), i -> true);
+		Assert.assertSame(Collections.emptyIterator(), iter.getIterator());
+    }
+
+    @Test
+    public void getFilter() {
+		Predicate<Integer> predicate = i -> true;
+		FilterIter<Integer> iter = new FilterIter<>(Collections.emptyIterator(), predicate);
+		Assert.assertSame(predicate, iter.getFilter());
+    }
+
 }

hutool-core/src/test/java/cn/hutool/core/collection/iter/IterChainTest.java

@@ -0,0 +1,69 @@
+package cn.hutool.core.collection.iter;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+
+/**
+ * test for {@link IterChain}
+ */
+public class IterChainTest {
+
+	@Test
+	public void testAddChain() {
+		Iterator<Integer> iter1 = Arrays.asList(1, 2).iterator();
+		Iterator<Integer> iter2 = Arrays.asList(3, 4).iterator();
+		IterChain<Integer> iterChain = new IterChain<>();
+		Assert.assertSame(iterChain, iterChain.addChain(iter1));
+		Assert.assertSame(iterChain, iterChain.addChain(iter2));
+		Assert.assertEquals(2, iterChain.allIterators.size());
+
+		iterChain = new IterChain<>(iter1, iter2);
+		Assert.assertEquals(2, iterChain.allIterators.size());
+	}
+
+	@Test
+	public void testHasNext() {
+		IterChain<Integer> iterChain = new IterChain<>();
+		Assert.assertFalse(iterChain.hasNext());
+		Assert.assertFalse(iterChain.addChain(Collections.emptyIterator()).hasNext());
+		Assert.assertTrue(iterChain.addChain(Arrays.asList(3, 4).iterator()).hasNext());
+	}
+
+	@Test
+	public void testNext() {
+		Iterator<Integer> iter1 = Arrays.asList(1, 2).iterator();
+		Iterator<Integer> iter2 = Arrays.asList(3, 4).iterator();
+		IterChain<Integer> iterChain = new IterChain<>();
+		Assert.assertSame(iterChain, iterChain.addChain(iter1));
+		Assert.assertSame(iterChain, iterChain.addChain(iter2));
+		Assert.assertEquals((Integer)1, iterChain.next());
+		Assert.assertEquals((Integer)2, iterChain.next());
+		Assert.assertEquals((Integer)3, iterChain.next());
+		Assert.assertEquals((Integer)4, iterChain.next());
+	}
+
+	@Test
+	public void testRemove() {
+		IterChain<Integer> iterChain = new IterChain<>();
+		iterChain.addChain(Arrays.asList(1, 2).iterator());
+		Assert.assertThrows(IllegalStateException.class, iterChain::remove);
+	}
+
+	@Test
+	public void testIterator() {
+		Iterator<Integer> iter1 = Arrays.asList(1, 2).iterator();
+		Iterator<Integer> iter2 = Arrays.asList(3, 4).iterator();
+		IterChain<Integer> iterChain = new IterChain<>();
+		Assert.assertSame(iterChain, iterChain.addChain(iter1));
+		Assert.assertSame(iterChain, iterChain.addChain(iter2));
+
+		Iterator<Iterator<Integer>> iterators = iterChain.iterator();
+		Assert.assertSame(iter1, iterators.next());
+		Assert.assertSame(iter2, iterators.next());
+	}
+
+}

hutool-core/src/test/java/cn/hutool/core/collection/iter/IterUtilTest.java

@@ -0,0 +1,306 @@
+package cn.hutool.core.collection.iter;
+
+import lombok.RequiredArgsConstructor;
+import org.junit.Assert;
+import org.junit.Test;
+import org.w3c.dom.NodeList;
+
+import java.util.*;
+import java.util.function.Function;
+
+/**
+ * test for {@link IterUtil}
+ */
+public class IterUtilTest {
+
+	@Test
+	public void testGetIter() {
+		Assert.assertNull(IterUtil.getIter(null));
+		Assert.assertEquals(Collections.emptyIterator(), IterUtil.getIter(Collections.emptyList()));
+
+		Assert.assertNull(IterUtil.getIter((Object)null));
+		Assert.assertNotNull(IterUtil.getIter(Collections.emptyIterator()));
+		Assert.assertNotNull(IterUtil.getIter((Object)Collections.emptyList()));
+		Assert.assertNotNull(IterUtil.getIter(new Integer[0]));
+		Assert.assertNotNull(IterUtil.getIter(Collections.emptyMap()));
+		Assert.assertNull(IterUtil.getIter((NodeList)null));
+	}
+
+	@Test
+	public void testIsEmpty() {
+		Assert.assertTrue(IterUtil.isEmpty(Collections.emptyIterator()));
+		Assert.assertFalse(IterUtil.isEmpty(Arrays.asList(1, 2).iterator()));
+
+		Assert.assertTrue(IterUtil.isEmpty(Collections.emptyList()));
+		Assert.assertFalse(IterUtil.isEmpty(Arrays.asList(1, 2)));
+	}
+
+	@Test
+	public void testIsNotEmpty() {
+		Assert.assertFalse(IterUtil.isNotEmpty(Collections.emptyIterator()));
+		Assert.assertTrue(IterUtil.isNotEmpty(Arrays.asList(1, 2).iterator()));
+
+		Assert.assertFalse(IterUtil.isNotEmpty(Collections.emptyList()));
+		Assert.assertTrue(IterUtil.isNotEmpty(Arrays.asList(1, 2)));
+	}
+
+	@Test
+	public void testHasNull() {
+		Assert.assertFalse(IterUtil.hasNull(Arrays.asList(1, 3, 2).iterator()));
+		Assert.assertTrue(IterUtil.hasNull(Arrays.asList(1, null, 2).iterator()));
+		Assert.assertFalse(IterUtil.hasNull(Collections.emptyIterator()));
+		Assert.assertTrue(IterUtil.hasNull(null));
+	}
+
+	@Test
+	public void testIsAllNull() {
+		Assert.assertTrue(IterUtil.isAllNull(Arrays.asList(null, null)));
+		Assert.assertFalse(IterUtil.isAllNull(Arrays.asList(1, null)));
+		Assert.assertTrue(IterUtil.isAllNull((Iterable<?>)null));
+		Assert.assertTrue(IterUtil.isAllNull(Arrays.asList(null, null).iterator()));
+		Assert.assertFalse(IterUtil.isAllNull(Arrays.asList(1, null).iterator()));
+		Assert.assertTrue(IterUtil.isAllNull((Iterator<?>)null));
+	}
+
+	@Test
+	public void testCountMap() {
+		Object o1 = new Object();
+		Object o2 = new Object();
+		Map<Object, Integer> countMap = IterUtil.countMap(Arrays.asList(o1, o2, o1, o1).iterator());
+		Assert.assertEquals((Integer)3, countMap.get(o1));
+		Assert.assertEquals((Integer)1, countMap.get(o2));
+	}
+
+	@Test
+	public void testFieldValueMap() {
+		Bean bean1 = new Bean(1, "A");
+		Bean bean2 = new Bean(2, "B");
+		Map<Integer, Bean> map = IterUtil.fieldValueMap(Arrays.asList(bean1, bean2).iterator(), "id");
+		Assert.assertEquals(bean1, map.get(1));
+		Assert.assertEquals(bean2, map.get(2));
+	}
+
+	@Test
+	public void testFieldValueAsMap() {
+		Bean bean1 = new Bean(1, "A");
+		Bean bean2 = new Bean(2, "B");
+		Map<Integer, String> map = IterUtil.fieldValueAsMap(
+			Arrays.asList(bean1, bean2).iterator(), "id", "name"
+		);
+		Assert.assertEquals("A", map.get(1));
+		Assert.assertEquals("B", map.get(2));
+	}
+
+	@Test
+	public void testFieldValueList() {
+		Bean bean1 = new Bean(1, "A");
+		Bean bean2 = new Bean(2, "B");
+		Assert.assertEquals(Arrays.asList(1, 2), IterUtil.fieldValueList(Arrays.asList(bean1, bean2), "id"));
+		Assert.assertEquals(
+			Arrays.asList(1, 2),
+			IterUtil.fieldValueList(Arrays.asList(bean1, bean2).iterator(), "id")
+		);
+	}
+
+	@Test
+	public void testJoin() {
+		List<String> stringList = Arrays.asList("1", "2", "3");
+		Assert.assertEquals("123", IterUtil.join(stringList.iterator(), ""));
+		Assert.assertEquals("-1--2--3-", IterUtil.join(stringList.iterator(), "", "-", "-"));
+		Assert.assertEquals("123", IterUtil.join(stringList.iterator(), "", Function.identity()));
+	}
+
+	@Test
+	public void testToMap() {
+		List<Integer> keys = Arrays.asList(1, 2, 3);
+
+		Map<Integer, Integer> map = IterUtil.toMap(keys, keys);
+		Assert.assertEquals(keys, new ArrayList<>(map.keySet()));
+		Assert.assertEquals(keys, new ArrayList<>(map.values()));
+
+		map = IterUtil.toMap(keys.iterator(), keys.iterator());
+		Assert.assertEquals(keys, new ArrayList<>(map.keySet()));
+		Assert.assertEquals(keys, new ArrayList<>(map.values()));
+
+		map = IterUtil.toMap(keys.iterator(), keys.iterator(), true);
+		Assert.assertEquals(keys, new ArrayList<>(map.keySet()));
+		Assert.assertEquals(keys, new ArrayList<>(map.values()));
+
+		map = IterUtil.toMap(keys, keys, true);
+		Assert.assertEquals(keys, new ArrayList<>(map.keySet()));
+		Assert.assertEquals(keys, new ArrayList<>(map.values()));
+
+		map = IterUtil.toMap(keys, Function.identity());
+		Assert.assertEquals(keys, new ArrayList<>(map.keySet()));
+		Assert.assertEquals(keys, new ArrayList<>(map.values()));
+
+		map = IterUtil.toMap(keys, Function.identity(), Function.identity());
+		Assert.assertEquals(keys, new ArrayList<>(map.keySet()));
+		Assert.assertEquals(keys, new ArrayList<>(map.values()));
+	}
+
+	@Test
+	public void testToListMap() {
+		List<Integer> keys = Arrays.asList(1, 2, 3, 4);
+
+		Map<Boolean, List<Integer>> map = IterUtil.toListMap(keys, i -> (i & 1) == 0, Function.identity());
+		Assert.assertEquals(Arrays.asList(2, 4), map.get(true));
+		Assert.assertEquals(Arrays.asList(1, 3), map.get(false));
+
+		map = IterUtil.toListMap(keys, i -> (i & 1) == 0);
+		Assert.assertEquals(Arrays.asList(2, 4), map.get(true));
+		Assert.assertEquals(Arrays.asList(1, 3), map.get(false));
+
+		map = new LinkedHashMap<>();
+		Map<Boolean, List<Integer>> rawMap = IterUtil.toListMap(map, keys, i -> (i & 1) == 0, Function.identity());
+		Assert.assertSame(rawMap, map);
+		Assert.assertEquals(Arrays.asList(2, 4), rawMap.get(true));
+		Assert.assertEquals(Arrays.asList(1, 3), rawMap.get(false));
+	}
+
+	@Test
+	public void testAsIterable() {
+		Iterator<Integer> iter = Arrays.asList(1, 2, 3).iterator();
+		Assert.assertEquals(iter, IterUtil.asIterable(iter).iterator());
+		Assert.assertNull(IterUtil.asIterable(null).iterator());
+
+		Enumeration<Integer> enumeration = new IteratorEnumeration<>(iter);
+		Iterator<Integer> iter2 = IterUtil.asIterator(enumeration);
+		Assert.assertEquals((Integer)1, iter2.next());
+		Assert.assertEquals((Integer)2, iter2.next());
+		Assert.assertEquals((Integer)3, iter2.next());
+	}
+
+	@Test
+	public void testGet() {
+		Iterator<Integer> iter = Arrays.asList(1, 2, 3, 4).iterator();
+		Assert.assertEquals((Integer)3, IterUtil.get(iter, 2));
+		Assert.assertThrows(IllegalArgumentException.class, () -> IterUtil.get(iter, -1));
+	}
+
+	@Test
+	public void testGetFirst() {
+		Iterator<Integer> iter = Arrays.asList(1, 2, 3, 4).iterator();
+		Assert.assertEquals((Integer)1, IterUtil.getFirst(iter));
+		Assert.assertNull(IterUtil.getFirst(null));
+		Assert.assertNull(IterUtil.getFirst(Collections.emptyIterator()));
+
+		Assert.assertEquals((Integer)2, IterUtil.getFirst(iter, t -> (t & 1) == 0));
+		Assert.assertNull(IterUtil.getFirst((Iterator<Integer>)null, t -> (t & 1) == 0));
+		Assert.assertNull(IterUtil.getFirst(Collections.emptyIterator(), Objects::nonNull));
+	}
+
+	@Test
+	public void testGetFirstNoneNull() {
+		Iterator<Integer> iter = Arrays.asList(null, 2, null, 4).iterator();
+		Assert.assertEquals((Integer)2, IterUtil.getFirstNoneNull(iter));
+		Assert.assertNull(IterUtil.getFirstNoneNull(null));
+		Assert.assertNull(IterUtil.getFirstNoneNull(Collections.emptyIterator()));
+	}
+
+	@Test
+	public void testGetElementType() {
+		List<Object> list = Arrays.asList(null, "str", null);
+		Assert.assertEquals(String.class, IterUtil.getElementType(list));
+		Assert.assertNull(IterUtil.getElementType((Iterable<?>)null));
+		Assert.assertNull(IterUtil.getElementType(Collections.emptyList()));
+
+		Assert.assertEquals(String.class, IterUtil.getElementType(list.iterator()));
+		Assert.assertNull(IterUtil.getElementType((Iterator<?>)null));
+		Assert.assertNull(IterUtil.getElementType(Collections.emptyIterator()));
+	}
+
+	@Test
+	public void testEdit() {
+		Assert.assertEquals(
+			Collections.singletonList("str"),
+			IterUtil.edit(Arrays.asList(null, "str", null).iterator(), t -> t)
+		);
+		Assert.assertEquals(
+			Collections.singletonList("str"),
+			IterUtil.edit(Arrays.asList(null, "str", null).iterator(), null)
+		);
+		Assert.assertEquals(Collections.emptyList(), IterUtil.edit(null, t -> t));
+	}
+
+	@Test
+	public void testRemove() {
+		List<Integer> list = new ArrayList<>(Arrays.asList(1, null, null, 3));
+		IterUtil.remove(list.iterator(), Objects::isNull);
+		Assert.assertEquals(Arrays.asList(1, 3), list);
+	}
+
+	@Test
+	public void testFilterToList() {
+		List<Integer> list1 = new ArrayList<>(Arrays.asList(1, null, null, 3));
+		List<Integer> list2 = IterUtil.filterToList(list1.iterator(), Objects::nonNull);
+		Assert.assertSame(list1, list1);
+		Assert.assertEquals(Arrays.asList(1, 3), list2);
+	}
+
+	@Test
+	public void testFiltered() {
+		Assert.assertNotNull(IterUtil.filtered(Collections.emptyIterator(), t -> true));
+	}
+
+	@Test
+	public void testEmpty() {
+		Assert.assertSame(Collections.emptyIterator(), IterUtil.empty());
+	}
+
+	@Test
+	public void testTrans() {
+		Assert.assertNotNull(IterUtil.trans(Collections.emptyIterator(), t -> true));
+	}
+
+	@Test
+	public void testSize() {
+		Assert.assertEquals(0, IterUtil.size((Iterator<?>)null));
+		Assert.assertEquals(0, IterUtil.size(Collections.emptyIterator()));
+		Assert.assertEquals(3, IterUtil.size(Arrays.asList(1, 2, 3).iterator()));
+
+		Assert.assertEquals(0, IterUtil.size((Iterable<?>)null));
+		Assert.assertEquals(0, IterUtil.size(Collections.emptyList()));
+		Assert.assertEquals(3, IterUtil.size(Arrays.asList(1, 2, 3)));
+	}
+
+	@Test
+	public void testIsEqualList() {
+		Assert.assertFalse(IterUtil.isEqualList(null, Collections.emptyList()));
+		Assert.assertFalse(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Collections.emptyList()));
+		Assert.assertFalse(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Arrays.asList(1, 2)));
+		Assert.assertTrue(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Arrays.asList(1, 2, 3)));
+		Assert.assertTrue(IterUtil.isEqualList(null, null));
+		Assert.assertTrue(IterUtil.isEqualList(Collections.emptyList(), Collections.emptyList()));
+	}
+
+	@Test
+	public void testClear() {
+		List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
+		IterUtil.clear(list.iterator());
+		Assert.assertTrue(list.isEmpty());
+		Assert.assertThrows(UnsupportedOperationException.class, () -> IterUtil.clear(Arrays.asList(1, 2).iterator()));
+	}
+
+	@Test
+	public void testToStr() {
+		List<Integer> list = Arrays.asList(1, 2, 3);
+		Assert.assertEquals("[1, 2, 3]", IterUtil.toStr(list.iterator()));
+		Assert.assertEquals("[1, 2, 3]", IterUtil.toStr(list.iterator(), Objects::toString));
+		Assert.assertEquals("{1:2:3}", IterUtil.toStr(list.iterator(), Objects::toString, ":", "{", "}"));
+	}
+
+	@Test
+	public void testForEach() {
+		List<Integer> list = new ArrayList<>();
+		IterUtil.forEach(Arrays.asList(1, 2, 3, 4).iterator(), list::add);
+		Assert.assertEquals(Arrays.asList(1, 2, 3, 4), list);
+	}
+
+	@RequiredArgsConstructor
+	private static class Bean {
+		private final Integer id;
+		private final String name;
+	}
+
+}

hutool-core/src/test/java/cn/hutool/core/collection/iter/IteratorEnumerationTest.java

@@ -0,0 +1,32 @@
+package cn.hutool.core.collection.iter;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * test for {@link IteratorEnumeration}
+ */
+public class IteratorEnumerationTest {
+
+	@Test
+	public void testHasMoreElements() {
+		List<Integer> list = Arrays.asList(1, 2, 3);
+		IteratorEnumeration<Integer> enumeration = new IteratorEnumeration<>(list.iterator());
+		Assert.assertTrue(enumeration.hasMoreElements());
+		Assert.assertFalse(new IteratorEnumeration<>(Collections.emptyIterator()).hasMoreElements());
+	}
+
+	@Test
+	public void testNextElement() {
+		List<Integer> list = Arrays.asList(1, 2, 3);
+		IteratorEnumeration<Integer> enumeration = new IteratorEnumeration<>(list.iterator());
+		Assert.assertEquals((Integer)1, enumeration.nextElement());
+		Assert.assertEquals((Integer)2, enumeration.nextElement());
+		Assert.assertEquals((Integer)3, enumeration.nextElement());
+	}
+
+}

hutool-core/src/test/java/cn/hutool/core/collection/iter/LineIterTest.java

@@ -0,0 +1,68 @@
+package cn.hutool.core.collection.iter;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.*;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.NoSuchElementException;
+
+/**
+ * test for {@link LineIter}
+ */
+public class LineIterTest {
+
+	@Test
+	public void testHasNext() {
+		LineIter iter = getItrFromClasspathFile();
+		Assert.assertTrue(iter.hasNext());
+	}
+
+	@Test
+	public void testNext() {
+		LineIter iter = getItrFromClasspathFile();
+		Assert.assertEquals("is first line", iter.next());
+		Assert.assertEquals("is second line", iter.next());
+		Assert.assertEquals("is third line", iter.next());
+	}
+
+	@Test
+	public void testRemove() {
+		LineIter iter = getItrFromClasspathFile();
+		iter.next();
+		Assert.assertThrows(UnsupportedOperationException.class, iter::remove);
+	}
+
+	@Test
+	public void testFinish() {
+		LineIter iter = getItrFromClasspathFile();
+		iter.finish();
+		Assert.assertThrows(NoSuchElementException.class, iter::next);
+	}
+
+	@Test
+	public void testClose() throws IOException {
+		URL url = LineIterTest.class.getClassLoader().getResource("text.txt");
+		Assert.assertNotNull(url);
+		FileInputStream inputStream = new FileInputStream(url.getFile());
+		LineIter iter = new LineIter(inputStream, StandardCharsets.UTF_8);
+		iter.close();
+		Assert.assertThrows(NoSuchElementException.class, iter::next);
+		Assert.assertThrows(IOException.class, inputStream::read);
+	}
+
+	private static LineIter getItrFromClasspathFile() {
+		URL url = LineIterTest.class.getClassLoader().getResource("text.txt");
+		Assert.assertNotNull(url);
+		FileInputStream inputStream = null;
+		try {
+			inputStream = new FileInputStream(url.getFile());
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
+		return new LineIter(bufferedReader);
+	}
+
+}

hutool-core/src/test/java/cn/hutool/core/collection/iter/PartitionIterTest.java

@@ -0,0 +1,31 @@
+package cn.hutool.core.collection.iter;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+
+/**
+ * test for {@link PartitionIter}
+ */
+public class PartitionIterTest {
+
+	@Test
+	public void testHasNext() {
+		Iterator<Integer> iter = Arrays.asList(1, 2, 3, 4).iterator();
+		PartitionIter<Integer> partitionIter = new PartitionIter<>(iter, 2);
+		Assert.assertTrue(partitionIter.hasNext());
+		Assert.assertFalse(new PartitionIter<>(Collections.emptyIterator(), 1).hasNext());
+	}
+
+	@Test
+	public void testNext() {
+		Iterator<Integer> iter = Arrays.asList(1, 2, 3, 4).iterator();
+		PartitionIter<Integer> partitionIter = new PartitionIter<>(iter, 2);
+		Assert.assertEquals(Arrays.asList(1, 2), partitionIter.next());
+		Assert.assertEquals(Arrays.asList(3, 4), partitionIter.next());
+	}
+
+}

hutool-core/src/test/java/cn/hutool/core/collection/iter/TransIterTest.java

@@ -0,0 +1,44 @@
+package cn.hutool.core.collection.iter;
+
+import cn.hutool.core.collection.ListUtil;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Function;
+
+/**
+ * @author huangchengxing
+ */
+public class TransIterTest {
+
+	@Test
+	public void testHasNext() {
+		TransIter<Integer, String> iter = new TransIter<>(Arrays.asList(1, 2, 3).iterator(), String::valueOf);
+		Assert.assertTrue(iter.hasNext());
+		Assert.assertFalse(new TransIter<>(Collections.emptyIterator(), Function.identity()).hasNext());
+	}
+
+	@Test
+	public void testNext() {
+		TransIter<Integer, String> iter = new TransIter<>(Arrays.asList(1, 2, 3).iterator(), String::valueOf);
+		Assert.assertEquals("1", iter.next());
+		Assert.assertEquals("2", iter.next());
+		Assert.assertEquals("3", iter.next());
+	}
+
+	@Test
+	public void testRemove() {
+		List<Integer> list = ListUtil.of(1, 2, 3);
+		TransIter<Integer, String> iter = new TransIter<>(list.iterator(), String::valueOf);
+		iter.next();
+		iter.remove();
+		iter.next();
+		iter.remove();
+		iter.next();
+		iter.remove();
+		Assert.assertTrue(list.isEmpty());
+	}
+}

hutool-core/src/test/java/cn/hutool/core/date/TimeUtilTest.java

@@ -10,7 +10,6 @@ import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
 import java.time.temporal.ChronoUnit;
-import java.time.temporal.TemporalAccessor;
 import java.util.Objects;
 
 public class TimeUtilTest {
@@ -234,7 +233,49 @@ public class TimeUtilTest {
 	@Test
 	public void ofTest2(){
 		final Instant instant = Objects.requireNonNull(DateUtil.parse("2022-02-22")).toInstant();
-		final LocalDateTime of = TimeUtil.of((TemporalAccessor) instant);
+		final LocalDateTime of = TimeUtil.of(instant);
 		Console.log(of);
 	}
+
+	@SuppressWarnings("ConstantConditions")
+	@Test
+	public void isInTest() {
+		// 时间范围 8点-9点
+		final LocalDateTime begin = LocalDateTime.parse("2019-02-02T08:00:00");
+		final LocalDateTime end = LocalDateTime.parse("2019-02-02T09:00:00");
+
+		// 不在时间范围内 用例
+		Assert.assertFalse(TimeUtil.isIn(LocalDateTime.parse("2019-02-02T06:00:00"), begin, end));
+		Assert.assertFalse(TimeUtil.isIn(LocalDateTime.parse("2019-02-02T13:00:00"), begin, end));
+		Assert.assertFalse(TimeUtil.isIn(LocalDateTime.parse("2019-02-01T08:00:00"), begin, end));
+		Assert.assertFalse(TimeUtil.isIn(LocalDateTime.parse("2019-02-03T09:00:00"), begin, end));
+
+		// 在时间范围内 用例
+		Assert.assertTrue(TimeUtil.isIn(LocalDateTime.parse("2019-02-02T08:00:00"), begin, end));
+		Assert.assertTrue(TimeUtil.isIn(LocalDateTime.parse("2019-02-02T08:00:01"), begin, end));
+		Assert.assertTrue(TimeUtil.isIn(LocalDateTime.parse("2019-02-02T08:11:00"), begin, end));
+		Assert.assertTrue(TimeUtil.isIn(LocalDateTime.parse("2019-02-02T08:22:00"), begin, end));
+		Assert.assertTrue(TimeUtil.isIn(LocalDateTime.parse("2019-02-02T08:59:59"), begin, end));
+		Assert.assertTrue(TimeUtil.isIn(LocalDateTime.parse("2019-02-02T09:00:00"), begin, end));
+
+		// 测试边界条件
+		Assert.assertTrue(TimeUtil.isIn(begin, begin, end, true, false));
+		Assert.assertFalse(TimeUtil.isIn(begin, begin, end, false, false));
+		Assert.assertTrue(TimeUtil.isIn(end, begin, end, false, true));
+		Assert.assertFalse(TimeUtil.isIn(end, begin, end, false, false));
+
+		// begin、end互换
+		Assert.assertTrue(TimeUtil.isIn(begin, end, begin, true, true));
+
+		// 比较当前时间范围
+		final LocalDateTime now = LocalDateTime.now();
+		Assert.assertTrue(TimeUtil.isIn(now, now.minusHours(1L), now.plusHours(1L)));
+		Assert.assertFalse(TimeUtil.isIn(now, now.minusHours(1L), now.minusHours(2L)));
+		Assert.assertFalse(TimeUtil.isIn(now, now.plusHours(1L), now.plusHours(2L)));
+
+		// 异常入参
+		Assert.assertThrows(IllegalArgumentException.class, () -> TimeUtil.isIn(null, begin, end, false, false));
+		Assert.assertThrows(IllegalArgumentException.class, () -> TimeUtil.isIn(begin, null, end, false, false));
+		Assert.assertThrows(IllegalArgumentException.class, () -> TimeUtil.isIn(begin, begin, null, false, false));
+	}
 }

hutool-core/src/test/java/cn/hutool/core/stream/CollectorUtilTest.java

@@ -47,14 +47,14 @@ public class CollectorUtilTest {
 
 	@Test
 	public void testToEasyStream() {
-		Stream<Integer> stream =Stream.of(1, 2, 3, 4)
+		final Stream<Integer> stream =Stream.of(1, 2, 3, 4)
 			.collect(CollectorUtil.toEasyStream());
 		Assert.assertEquals(EasyStream.class, stream.getClass());
 	}
 
 	@Test
 	public void testToEntryStream() {
-		Map<String, Integer> map = Stream.of(1, 2, 3, 4, 5)
+		final Map<String, Integer> map = Stream.of(1, 2, 3, 4, 5)
 			// 转为EntryStream
 			.collect(CollectorUtil.toEntryStream(Function.identity(), String::valueOf))
 			// 过滤偶数

hutool-core/src/test/java/cn/hutool/core/stream/EasyStreamTest.java

@@ -218,7 +218,7 @@ public class EasyStreamTest {
 	}
 
 	@Test
-	public void testPeek(){
+	public void testPeek() {
 		EasyStream.of("one", "two", "three", "four")
 				.filter(e -> e.length() == 4)
 				.peek(e -> Assert.assertEquals("four", e))
@@ -228,12 +228,12 @@ public class EasyStreamTest {
 	}
 
 	@Test
-	public void testPeekIdx(){
+	public void testPeekIdx() {
 		EasyStream.of("one", "two", "three", "four")
 				.filter(e -> e.length() == 4)
-				.peekIdx((e,i) -> Assert.assertEquals("four:0", e + ":" + i))
+				.peekIdx((e, i) -> Assert.assertEquals("four:0", e + ":" + i))
 				.map(String::toUpperCase)
-				.peekIdx((e,i) -> Assert.assertEquals("FOUR:0", e + ":" + i))
+				.peekIdx((e, i) -> Assert.assertEquals("FOUR:0", e + ":" + i))
 				.collect(Collectors.toList());
 	}
 
@@ -431,7 +431,7 @@ public class EasyStreamTest {
 	@Test
 	public void testToTree() {
 		Consumer<Object> test = o -> {
-			List<Student> studentTree = EasyStream
+			final List<Student> studentTree = EasyStream
 					.of(
 							Student.builder().id(1L).name("dromara").build(),
 							Student.builder().id(2L).name("baomidou").build(),
@@ -464,7 +464,7 @@ public class EasyStreamTest {
 			), studentTree);
 		};
 		test = test.andThen(o -> {
-			List<Student> studentTree = EasyStream
+			final List<Student> studentTree = EasyStream
 					.of(
 							Student.builder().id(1L).name("dromara").matchParent(true).build(),
 							Student.builder().id(2L).name("baomidou").matchParent(true).build(),
@@ -501,7 +501,7 @@ public class EasyStreamTest {
 
 	@Test
 	public void testFlatTree() {
-		List<Student> studentTree = asList(
+		final List<Student> studentTree = asList(
 				Student.builder().id(1L).name("dromara")
 						.children(asList(Student.builder().id(3L).name("hutool").parentId(1L)
 										.children(singletonList(Student.builder().id(6L).name("looly").parentId(3L).build()))
@@ -551,9 +551,9 @@ public class EasyStreamTest {
 	@Test
 	public void testTransform() {
 		final boolean result = EasyStream.of(1, 2, 3)
-			.transform(EasyStream::toList)
-			.map(List::isEmpty)
-			.orElse(false);
+				.transform(EasyStream::toList)
+				.map(List::isEmpty)
+				.orElse(false);
 		Assert.assertFalse(result);
 	}
 

hutool-core/src/test/java/cn/hutool/core/util/ObjUtilTest.java

@@ -1,17 +1,23 @@
 package cn.hutool.core.util;
 
 import cn.hutool.core.collection.ListUtil;
-import cn.hutool.core.exceptions.CloneRuntimeException;
+import lombok.EqualsAndHashCode;
+import lombok.RequiredArgsConstructor;
 import org.junit.Assert;
 import org.junit.Test;
 
+import java.io.Serializable;
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
-import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.function.Function;
 
+/**
+ * test for {@link ObjUtil}
+ */
 public class ObjUtilTest {
 
 	@Test
@@ -56,43 +62,49 @@ public class ObjUtilTest {
 
 		final Iterable<Integer> list = ListUtil.of(1, 2, 3);
 		Assert.assertEquals(3, ObjUtil.length(list));
+		Assert.assertEquals(3, ObjUtil.length(Arrays.asList(1, 2, 3).iterator()));
 	}
 
 	@Test
 	public void containsTest(){
-		final int[] array = new int[]{1,2,3,4,5};
-
-		final boolean contains = ObjUtil.contains(array, 1);
-		Assert.assertTrue(contains);
+		Assert.assertTrue(ObjUtil.contains(new int[]{1,2,3,4,5}, 1));
+		Assert.assertFalse(ObjUtil.contains(null, 1));
+		Assert.assertTrue(ObjUtil.contains("123", "3"));
+		Map<Integer, Integer> map = new HashMap<>();
+		map.put(1, 1);
+		map.put(2, 2);
+		Assert.assertTrue(ObjUtil.contains(map, 1));
+		Assert.assertTrue(ObjUtil.contains(Arrays.asList(1, 2, 3).iterator(), 2));
 	}
 
 	@Test
-	public void cloneTest() {
-		final Obj obj = new Obj();
-		final Obj obj2 = ObjUtil.clone(obj);
-		Assert.assertEquals("OK", obj2.doSomeThing());
-	}
-
-	static class Obj implements Cloneable {
-		public String doSomeThing() {
-			return "OK";
-		}
-
-		@Override
-		public Obj clone() {
-			try {
-				return (Obj) super.clone();
-			} catch (final CloneNotSupportedException e) {
-				throw new CloneRuntimeException(e);
-			}
-		}
+	public void isNullTest() {
+		Assert.assertTrue(ObjUtil.isNull(null));
 	}
 
 	@Test
-	public void toStringTest() {
-		final ArrayList<String> strings = ListUtil.of("1", "2");
-		final String result = ObjUtil.toString(strings);
-		Assert.assertEquals("[1, 2]", result);
+	public void isNotNullTest() {
+		Assert.assertFalse(ObjUtil.isNotNull(null));
+	}
+
+	@Test
+	public void isEmptyTest() {
+		Assert.assertTrue(ObjUtil.isEmpty(null));
+		Assert.assertTrue(ObjUtil.isEmpty(new int[0]));
+		Assert.assertTrue(ObjUtil.isEmpty(""));
+		Assert.assertTrue(ObjUtil.isEmpty(Collections.emptyList()));
+		Assert.assertTrue(ObjUtil.isEmpty(Collections.emptyMap()));
+		Assert.assertTrue(ObjUtil.isEmpty(Collections.emptyIterator()));
+	}
+
+	@Test
+	public void isNotEmptyTest() {
+		Assert.assertFalse(ObjUtil.isNotEmpty(null));
+		Assert.assertFalse(ObjUtil.isNotEmpty(new int[0]));
+		Assert.assertFalse(ObjUtil.isNotEmpty(""));
+		Assert.assertFalse(ObjUtil.isNotEmpty(Collections.emptyList()));
+		Assert.assertFalse(ObjUtil.isNotEmpty(Collections.emptyMap()));
+		Assert.assertFalse(ObjUtil.isNotEmpty(Collections.emptyIterator()));
 	}
 
 	@Test
@@ -113,6 +125,48 @@ public class ObjUtilTest {
 		Assert.assertSame(val2, ObjUtil.defaultIfNull(null, Function.identity(), val2));
 	}
 
+	@Test
+	public void cloneTest() {
+		Assert.assertNull(ObjUtil.clone(null));
+
+		final CloneableBean cloneableBean1 = new CloneableBean(1);
+		final CloneableBean cloneableBean2 = ObjUtil.clone(cloneableBean1);
+		Assert.assertEquals(cloneableBean1, cloneableBean2);
+
+		final SerializableBean serializableBean1 = new SerializableBean(2);
+		final SerializableBean serializableBean2 = ObjUtil.clone(serializableBean1);
+		Assert.assertEquals(serializableBean1, serializableBean2);
+
+		final Bean bean1 = new Bean(3);
+		Assert.assertNull(ObjUtil.clone(bean1));
+	}
+
+	@Test
+	public void cloneIfPossibleTest() {
+		Assert.assertNull(ObjUtil.clone(null));
+
+		final CloneableBean cloneableBean1 = new CloneableBean(1);
+		Assert.assertEquals(cloneableBean1, ObjUtil.cloneIfPossible(cloneableBean1));
+
+		final SerializableBean serializableBean1 = new SerializableBean(2);
+		Assert.assertEquals(serializableBean1, ObjUtil.cloneIfPossible(serializableBean1));
+
+		final Bean bean1 = new Bean(3);
+		Assert.assertSame(bean1, ObjUtil.cloneIfPossible(bean1));
+
+		final ExceptionCloneableBean exceptionBean1 = new ExceptionCloneableBean(3);
+		Assert.assertSame(exceptionBean1, ObjUtil.cloneIfPossible(exceptionBean1));
+	}
+
+	@Test
+	public void cloneByStreamTest() {
+		Assert.assertNull(ObjUtil.cloneByStream(null));
+		Assert.assertNull(ObjUtil.cloneByStream(new CloneableBean(1)));
+		final SerializableBean serializableBean1 = new SerializableBean(2);
+		Assert.assertEquals(serializableBean1, ObjUtil.cloneByStream(serializableBean1));
+		Assert.assertNull(ObjUtil.cloneByStream(new Bean(1)));
+	}
+
 	@Test
 	public void isBasicTypeTest(){
 		final int a = 1;
@@ -121,9 +175,72 @@ public class ObjUtilTest {
 	}
 
 	@Test
-	public void cloneIfPossibleTest() {
-		final String a = "a";
-		final String a2 = ObjUtil.cloneIfPossible(a);
-		Assert.assertNotSame(a, a2);
+	public void isValidIfNumberTest() {
+		Assert.assertTrue(ObjUtil.isValidIfNumber(null));
+		Assert.assertFalse(ObjUtil.isValidIfNumber(Double.NEGATIVE_INFINITY));
+		Assert.assertFalse(ObjUtil.isValidIfNumber(Double.NaN));
+		Assert.assertTrue(ObjUtil.isValidIfNumber(Double.MIN_VALUE));
+		Assert.assertFalse(ObjUtil.isValidIfNumber(Float.NEGATIVE_INFINITY));
+		Assert.assertFalse(ObjUtil.isValidIfNumber(Float.NaN));
+		Assert.assertTrue(ObjUtil.isValidIfNumber(Float.MIN_VALUE));
 	}
+
+	@Test
+	public void compareTest() {
+		Assert.assertEquals(0, ObjUtil.compare(1, 1));
+		Assert.assertEquals(1, ObjUtil.compare(1, null));
+		Assert.assertEquals(-1, ObjUtil.compare(null, 1));
+
+		Assert.assertEquals(-1, ObjUtil.compare(1, null, true));
+		Assert.assertEquals(1, ObjUtil.compare(null, 1, true));
+	}
+
+	@Test
+	public void getTypeArgumentTest() {
+		final Bean bean = new Bean(1);
+		Assert.assertEquals(Integer.class, ObjUtil.getTypeArgument(bean));
+		Assert.assertEquals(String.class, ObjUtil.getTypeArgument(bean, 1));
+	}
+
+	@Test
+	public void toStringTest() {
+		Assert.assertEquals("null", ObjUtil.toString(null));
+		Assert.assertEquals(Collections.emptyMap().toString(), ObjUtil.toString(Collections.emptyMap()));
+		Assert.assertEquals("[1, 2]", Arrays.asList("1", "2").toString());
+	}
+
+	@RequiredArgsConstructor
+	@EqualsAndHashCode
+	private static class ExceptionCloneableBean implements Cloneable {
+		private final Integer id;
+		@Override
+		protected Object clone() throws CloneNotSupportedException {
+			throw new RuntimeException("can not clone this object");
+		}
+	}
+
+	@RequiredArgsConstructor
+	@EqualsAndHashCode
+	private static class CloneableBean implements Cloneable {
+		private final Integer id;
+		@Override
+		protected Object clone() throws CloneNotSupportedException {
+			return super.clone();
+		}
+	}
+
+	@RequiredArgsConstructor
+	@EqualsAndHashCode
+	private static class SerializableBean implements Serializable {
+		private final Integer id;
+	}
+
+	@RequiredArgsConstructor
+	@EqualsAndHashCode
+	private static class Bean implements TypeArgument<Integer, String> {
+		private final Integer id;
+	}
+
+	private interface TypeArgument<A, B> {};
+
 }

hutool-core/src/test/java/cn/hutool/core/util/RuntimeUtilTest.java

@@ -43,4 +43,11 @@ public class RuntimeUtilTest {
 		final int pid = RuntimeUtil.getPid();
 		Assert.assertTrue(pid > 0);
 	}
+
+	@Test
+	public void getProcessorCountTest(){
+		int cpu = RuntimeUtil.getProcessorCount();
+		Console.log("cpu个数：{}", cpu);
+		Assert.assertTrue(cpu > 0);
+	}
 }

hutool-core/src/test/resources/text.txt

@@ -0,0 +1,3 @@
+is first line
+is second line
+is third line