zhouxy108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-07-21 15:09:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

add BoundedCollection

Browse Source
This commit is contained in:
Looly
2024-06-21 20:02:28 +08:00
parent 185b9f2a67
commit 8cdf9ecfd9
13 changed files with 677 additions and 311 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -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")));
Assertions.assertFalse(CollUtil.contains(list, s -> s.startsWith("d")));
assertTrue(CollUtil.contains(list, s -> s.startsWith("a")));
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"));
Assertions.assertTrue(disjunction.contains("x2"));
Assertions.assertTrue(disjunction.contains("x"));
assertTrue(disjunction.contains("b"));
assertTrue(disjunction.contains("x2"));
assertTrue(disjunction.contains("x"));
final Collection<String> disjunction2 = CollUtil.disjunction(list2, list1);
Assertions.assertTrue(disjunction2.contains("b"));
Assertions.assertTrue(disjunction2.contains("x2"));
Assertions.assertTrue(disjunction2.contains("x"));
assertTrue(disjunction2.contains("b"));
assertTrue(disjunction2.contains("x2"));
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"));
Assertions.assertTrue(disjunction.contains("2"));
Assertions.assertTrue(disjunction.contains("3"));
Assertions.assertTrue(disjunction.contains("a"));
Assertions.assertTrue(disjunction.contains("b"));
Assertions.assertTrue(disjunction.contains("c"));
assertTrue(disjunction.contains("1"));
assertTrue(disjunction.contains("2"));
assertTrue(disjunction.contains("3"));
assertTrue(disjunction.contains("a"));
assertTrue(disjunction.contains("b"));
assertTrue(disjunction.contains("c"));
final Collection<String> disjunction2 = CollUtil.disjunction(list2, list1);
Assertions.assertTrue(disjunction2.contains("1"));
Assertions.assertTrue(disjunction2.contains("2"));
Assertions.assertTrue(disjunction2.contains("3"));
Assertions.assertTrue(disjunction2.contains("a"));
Assertions.assertTrue(disjunction2.contains("b"));
Assertions.assertTrue(disjunction2.contains("c"));
assertTrue(disjunction2.contains("1"));
assertTrue(disjunction2.contains("2"));
assertTrue(disjunction2.contains("3"));
assertTrue(disjunction2.contains("a"));
assertTrue(disjunction2.contains("b"));
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));
Assertions.assertFalse(CollUtil.addIfAbsent(ListUtil.of(), null));
Assertions.assertFalse(CollUtil.addIfAbsent(null, "123"));
Assertions.assertFalse(CollUtil.addIfAbsent(ListUtil.of("123"), "123"));
Assertions.assertFalse(CollUtil.addIfAbsent(ListUtil.of(new Animal("jack", 20)),
assertFalse(CollUtil.addIfAbsent(null, null));
assertFalse(CollUtil.addIfAbsent(ListUtil.of(), null));
assertFalse(CollUtil.addIfAbsent(null, "123"));
assertFalse(CollUtil.addIfAbsent(ListUtil.of("123"), "123"));
assertFalse(CollUtil.addIfAbsent(ListUtil.of(new Animal("jack", 20)),
new Animal("jack", 20)));
// 正常情况
Assertions.assertTrue(CollUtil.addIfAbsent(ListUtil.of("456"), "123"));
Assertions.assertTrue(CollUtil.addIfAbsent(ListUtil.of(new Animal("jack", 20)),
assertTrue(CollUtil.addIfAbsent(ListUtil.of("456"), "123"));
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));
Assertions.assertTrue(CollUtil.isEqualList(ListUtil.of(), ListUtil.of()));
Assertions.assertTrue(CollUtil.isEqualList(list, list));
Assertions.assertTrue(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3, 4)));
assertTrue(CollUtil.isEqualList(null, null));
assertTrue(CollUtil.isEqualList(ListUtil.of(), ListUtil.of()));
assertTrue(CollUtil.isEqualList(list, list));
assertTrue(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3, 4)));
Assertions.assertFalse(CollUtil.isEqualList(null, ListUtil.of()));
Assertions.assertFalse(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3, 3)));
Assertions.assertFalse(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3)));
Assertions.assertFalse(CollUtil.isEqualList(list, ListUtil.of(4, 3, 2, 1)));
assertFalse(CollUtil.isEqualList(null, ListUtil.of()));
assertFalse(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3, 3)));
assertFalse(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3)));
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));
Assertions.assertFalse(CollUtil.anyMatch(list, i -> i > 6));
Assertions.assertFalse(CollUtil.allMatch(list, i -> i == 1));
Assertions.assertTrue(CollUtil.allMatch(list, i -> i <= 6));
assertTrue(CollUtil.anyMatch(list, i -> i == 1));
assertFalse(CollUtil.anyMatch(list, i -> i > 6));
assertFalse(CollUtil.allMatch(list, i -> i == 1));
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));
}
}

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

@@ -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()));
Assertions.assertFalse(IterUtil.isEmpty(Arrays.asList(1, 2).iterator()));
assertTrue(IterUtil.isEmpty(Collections.emptyIterator()));
assertFalse(IterUtil.isEmpty(Arrays.asList(1, 2).iterator()));
Assertions.assertTrue(IterUtil.isEmpty(Collections.emptyList()));
Assertions.assertFalse(IterUtil.isEmpty(Arrays.asList(1, 2)));
assertTrue(IterUtil.isEmpty(Collections.emptyList()));
assertFalse(IterUtil.isEmpty(Arrays.asList(1, 2)));
}
@Test
public void testIsNotEmpty() {
Assertions.assertFalse(IterUtil.isNotEmpty(Collections.emptyIterator()));
Assertions.assertTrue(IterUtil.isNotEmpty(Arrays.asList(1, 2).iterator()));
assertFalse(IterUtil.isNotEmpty(Collections.emptyIterator()));
assertTrue(IterUtil.isNotEmpty(Arrays.asList(1, 2).iterator()));
Assertions.assertFalse(IterUtil.isNotEmpty(Collections.emptyList()));
Assertions.assertTrue(IterUtil.isNotEmpty(Arrays.asList(1, 2)));
assertFalse(IterUtil.isNotEmpty(Collections.emptyList()));
assertTrue(IterUtil.isNotEmpty(Arrays.asList(1, 2)));
}
@Test
public void testHasNull() {
Assertions.assertFalse(IterUtil.hasNull(Arrays.asList(1, 3, 2).iterator()));
Assertions.assertTrue(IterUtil.hasNull(Arrays.asList(1, null, 2).iterator()));
Assertions.assertFalse(IterUtil.hasNull(Collections.emptyIterator()));
Assertions.assertTrue(IterUtil.hasNull(null));
assertFalse(IterUtil.hasNull(Arrays.asList(1, 3, 2).iterator()));
assertTrue(IterUtil.hasNull(Arrays.asList(1, null, 2).iterator()));
assertFalse(IterUtil.hasNull(Collections.emptyIterator()));
assertTrue(IterUtil.hasNull(null));
}
@Test
public void testIsAllNull() {
Assertions.assertTrue(IterUtil.isAllNull(Arrays.asList(null, null)));
Assertions.assertFalse(IterUtil.isAllNull(Arrays.asList(1, null)));
Assertions.assertTrue(IterUtil.isAllNull((Iterable<?>)null));
Assertions.assertTrue(IterUtil.isAllNull(Arrays.asList(null, null).iterator()));
Assertions.assertFalse(IterUtil.isAllNull(Arrays.asList(1, null).iterator()));
Assertions.assertTrue(IterUtil.isAllNull((Iterator<?>)null));
assertTrue(IterUtil.isAllNull(Arrays.asList(null, null)));
assertFalse(IterUtil.isAllNull(Arrays.asList(1, null)));
assertTrue(IterUtil.isAllNull((Iterable<?>)null));
assertTrue(IterUtil.isAllNull(Arrays.asList(null, null).iterator()));
assertFalse(IterUtil.isAllNull(Arrays.asList(1, null).iterator()));
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));
Assertions.assertEquals((Integer)1, countMap.get(o2));
assertEquals((Integer)3, countMap.get(o1));
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));
Assertions.assertEquals(bean2, map.get(2));
assertEquals(bean1, map.get(1));
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));
Assertions.assertEquals("B", map.get(2));
assertEquals("A", map.get(1));
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"));
Assertions.assertEquals(
assertEquals(Arrays.asList(1, 2), IterUtil.fieldValueList(Arrays.asList(bean1, bean2), "id"));
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(), ""));
Assertions.assertEquals("-1--2--3-", IterUtil.join(stringList.iterator(), "", "-", "-"));
Assertions.assertEquals("123", IterUtil.join(stringList.iterator(), "", Function.identity()));
assertEquals("123", IterUtil.join(stringList.iterator(), ""));
assertEquals("-1--2--3-", IterUtil.join(stringList.iterator(), "", "-", "-"));
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()));
Assertions.assertEquals(keys, new ArrayList<>(map.values()));
assertEquals(keys, new ArrayList<>(map.keySet()));
assertEquals(keys, new ArrayList<>(map.values()));
map = IterUtil.toMap(keys.iterator(), keys.iterator());
Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
Assertions.assertEquals(keys, new ArrayList<>(map.values()));
assertEquals(keys, new ArrayList<>(map.keySet()));
assertEquals(keys, new ArrayList<>(map.values()));
map = IterUtil.toMap(keys.iterator(), keys.iterator(), true);
Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
Assertions.assertEquals(keys, new ArrayList<>(map.values()));
assertEquals(keys, new ArrayList<>(map.keySet()));
assertEquals(keys, new ArrayList<>(map.values()));
map = IterUtil.toMap(keys, keys, true);
Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
Assertions.assertEquals(keys, new ArrayList<>(map.values()));
assertEquals(keys, new ArrayList<>(map.keySet()));
assertEquals(keys, new ArrayList<>(map.values()));
map = IterUtil.toMap(keys, Function.identity());
Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
Assertions.assertEquals(keys, new ArrayList<>(map.values()));
assertEquals(keys, new ArrayList<>(map.keySet()));
assertEquals(keys, new ArrayList<>(map.values()));
map = IterUtil.toMap(keys, Function.identity(), Function.identity());
Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
Assertions.assertEquals(keys, new ArrayList<>(map.values()));
assertEquals(keys, new ArrayList<>(map.keySet()));
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));
Assertions.assertEquals(Arrays.asList(1, 3), map.get(false));
assertEquals(Arrays.asList(2, 4), map.get(true));
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));
Assertions.assertEquals(Arrays.asList(1, 3), map.get(false));
assertEquals(Arrays.asList(2, 4), map.get(true));
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));
Assertions.assertEquals(Arrays.asList(1, 3), rawMap.get(false));
assertEquals(Arrays.asList(2, 4), rawMap.get(true));
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());
Assertions.assertEquals((Integer)2, iter2.next());
Assertions.assertEquals((Integer)3, iter2.next());
assertEquals((Integer)1, iter2.next());
assertEquals((Integer)2, 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));
Assertions.assertEquals(0, IterUtil.size(Collections.emptyIterator()));
Assertions.assertEquals(3, IterUtil.size(Arrays.asList(1, 2, 3).iterator()));
assertEquals(0, IterUtil.size((Iterator<?>)null));
assertEquals(0, IterUtil.size(Collections.emptyIterator()));
assertEquals(3, IterUtil.size(Arrays.asList(1, 2, 3).iterator()));
Assertions.assertEquals(0, IterUtil.size((Iterable<?>)null));
Assertions.assertEquals(0, IterUtil.size(Collections.emptyList()));
Assertions.assertEquals(3, IterUtil.size(Arrays.asList(1, 2, 3)));
assertEquals(0, IterUtil.size((Iterable<?>)null));
assertEquals(0, IterUtil.size(Collections.emptyList()));
assertEquals(3, IterUtil.size(Arrays.asList(1, 2, 3)));
}
@Test
public void testIsEqualList() {
Assertions.assertFalse(IterUtil.isEqualList(null, Collections.emptyList()));
Assertions.assertFalse(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Collections.emptyList()));
Assertions.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)));
Assertions.assertTrue(IterUtil.isEqualList(null, null));
Assertions.assertTrue(IterUtil.isEqualList(Collections.emptyList(), Collections.emptyList()));
assertFalse(IterUtil.isEqualList(null, Collections.emptyList()));
assertFalse(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Collections.emptyList()));
assertFalse(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Arrays.asList(1, 2)));
assertTrue(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Arrays.asList(1, 2, 3)));
assertTrue(IterUtil.isEqualList(null, null));
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()));
Assertions.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()));
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());
Assertions.assertEquals("奔驰", carNameMap.get("345").getCarName());
Assertions.assertEquals("路虎", carNameMap.get("567").getCarName());
assertEquals("大众", carNameMap.get("123").getCarName());
assertEquals("奔驰", carNameMap.get("345").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());
Assertions.assertEquals("3", obj.get(0));
assertEquals(1, obj.size());
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());
Assertions.assertFalse(filtered.hasNext());
assertEquals("3", filtered.next());
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());
Assertions.assertEquals("3", filtered.get(0));
assertEquals(1, filtered.size());
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");
}
}