mirror of
https://gitee.com/chinabugotech/hutool.git
synced 2025-04-19 03:01:48 +08:00
fix bug
This commit is contained in:
Looly
parent
779a95c53a
commit
f6dad69c7f
@ -409,11 +409,18 @@ public class CollUtil {
|
||||
}
|
||||
|
||||
Collection<T> result = ObjUtil.clone(coll1);
|
||||
try {
|
||||
if (null == result) {
|
||||
result = CollUtil.create(coll1.getClass());
|
||||
result.addAll(coll1);
|
||||
}
|
||||
result.removeAll(coll2);
|
||||
} catch (UnsupportedOperationException e) {
|
||||
// 针对 coll1 为只读集合的补偿
|
||||
result = CollUtil.create(AbstractCollection.class);
|
||||
result.addAll(coll1);
|
||||
result.removeAll(coll2);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
@ -31,8 +31,7 @@ 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;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
/**
|
||||
* 集合工具类单元测试
|
||||
@ -46,11 +45,11 @@ public class CollUtilTest {
|
||||
public void emptyIfNullTest() {
|
||||
final Set<?> set = null;
|
||||
final Set<?> set1 = CollUtil.emptyIfNull(set);
|
||||
Assertions.assertEquals(SetUtil.empty(), set1);
|
||||
assertEquals(SetUtil.empty(), set1);
|
||||
|
||||
final List<?> list = null;
|
||||
final List<?> list1 = CollUtil.emptyIfNull(list);
|
||||
Assertions.assertEquals(ListUtil.empty(), list1);
|
||||
assertEquals(ListUtil.empty(), list1);
|
||||
}
|
||||
|
||||
@SuppressWarnings("ConstantConditions")
|
||||
@ -72,16 +71,16 @@ public class CollUtilTest {
|
||||
@Test
|
||||
public void defaultIfEmpty() {
|
||||
List<String> strings = CollUtil.defaultIfEmpty(ListUtil.of(), ListUtil.of("1"));
|
||||
Assertions.assertEquals(ListUtil.of("1"), strings);
|
||||
assertEquals(ListUtil.of("1"), strings);
|
||||
|
||||
strings = CollUtil.defaultIfEmpty(null, ListUtil.of("1"));
|
||||
Assertions.assertEquals(ListUtil.of("1"), strings);
|
||||
assertEquals(ListUtil.of("1"), strings);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void defaultIfEmpty2() {
|
||||
final List<String> strings = CollUtil.defaultIfEmpty(ListUtil.of(), Function.identity(), () -> ListUtil.of("1"));
|
||||
Assertions.assertEquals(ListUtil.of("1"), strings);
|
||||
assertEquals(ListUtil.of("1"), strings);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -98,14 +97,14 @@ public class CollUtilTest {
|
||||
final List<Integer> exceptResultList = ListUtil.of(1);
|
||||
|
||||
List<Integer> resultList = CollUtil.removeWithAddIf(list, ele -> 1 == ele);
|
||||
Assertions.assertEquals(list, exceptRemovedList);
|
||||
Assertions.assertEquals(resultList, exceptResultList);
|
||||
assertEquals(list, exceptRemovedList);
|
||||
assertEquals(resultList, exceptResultList);
|
||||
|
||||
list = ListUtil.of(1, 2, 3);
|
||||
resultList = new ArrayList<>();
|
||||
CollUtil.removeWithAddIf(list, resultList, ele -> 1 == ele);
|
||||
Assertions.assertEquals(list, exceptRemovedList);
|
||||
Assertions.assertEquals(resultList, exceptResultList);
|
||||
assertEquals(list, exceptRemovedList);
|
||||
assertEquals(resultList, exceptResultList);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -114,17 +113,17 @@ public class CollUtilTest {
|
||||
List<String> answerList = ListUtil.of("a", "b");
|
||||
CollUtil.padLeft(srcList, 1, "b");
|
||||
CollUtil.padLeft(srcList, 2, "a");
|
||||
Assertions.assertEquals(srcList, answerList);
|
||||
assertEquals(srcList, answerList);
|
||||
|
||||
srcList = ListUtil.of("a", "b");
|
||||
answerList = ListUtil.of("a", "b");
|
||||
CollUtil.padLeft(srcList, 2, "a");
|
||||
Assertions.assertEquals(srcList, answerList);
|
||||
assertEquals(srcList, answerList);
|
||||
|
||||
srcList = ListUtil.of("c");
|
||||
answerList = ListUtil.of("a", "a", "c");
|
||||
CollUtil.padLeft(srcList, 3, "a");
|
||||
Assertions.assertEquals(srcList, answerList);
|
||||
assertEquals(srcList, answerList);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -132,7 +131,7 @@ public class CollUtilTest {
|
||||
final List<String> srcList = ListUtil.of("a");
|
||||
final List<String> answerList = ListUtil.of("a", "b", "b", "b", "b");
|
||||
CollUtil.padRight(srcList, 5, "b");
|
||||
Assertions.assertEquals(srcList, answerList);
|
||||
assertEquals(srcList, answerList);
|
||||
}
|
||||
|
||||
@SuppressWarnings("ConstantValue")
|
||||
@ -154,7 +153,7 @@ public class CollUtilTest {
|
||||
|
||||
final Collection<String> union = CollUtil.union(list1, list2);
|
||||
|
||||
Assertions.assertEquals(3, CollUtil.count(union, "b"::equals));
|
||||
assertEquals(3, CollUtil.count(union, "b"::equals));
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -163,8 +162,8 @@ public class CollUtilTest {
|
||||
final List<String> list2 = ListUtil.of("a", "b", "b", "b", "c", "d");
|
||||
|
||||
final Collection<String> intersection = CollUtil.intersection(list1, list2);
|
||||
Assertions.assertEquals(2, CollUtil.count(intersection, "b"::equals));
|
||||
Assertions.assertEquals(0, CollUtil.count(intersection, "x"::equals));
|
||||
assertEquals(2, CollUtil.count(intersection, "b"::equals));
|
||||
assertEquals(0, CollUtil.count(intersection, "x"::equals));
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -174,7 +173,7 @@ public class CollUtilTest {
|
||||
final List<String> list3 = ListUtil.of();
|
||||
|
||||
final Collection<String> intersectionDistinct = CollUtil.intersectionDistinct(list1, list2);
|
||||
Assertions.assertEquals(SetUtil.ofLinked("a", "b", "c", "d"), intersectionDistinct);
|
||||
assertEquals(SetUtil.ofLinked("a", "b", "c", "d"), intersectionDistinct);
|
||||
|
||||
final Collection<String> intersectionDistinct2 = CollUtil.intersectionDistinct(list1, list2, list3);
|
||||
Console.log(intersectionDistinct2);
|
||||
@ -204,9 +203,9 @@ 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.assertEquals(list2, disjunction);
|
||||
assertEquals(list2, disjunction);
|
||||
final Collection<String> disjunction2 = CollUtil.disjunction(list2, list1);
|
||||
Assertions.assertEquals(list2, disjunction2);
|
||||
assertEquals(list2, disjunction2);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -236,8 +235,8 @@ public class CollUtilTest {
|
||||
final List<String> list1 = ListUtil.of("a", "b", "b", "c", "d", "x");
|
||||
final List<String> list2 = ListUtil.of("a", "b", "b", "b", "c", "d", "x2");
|
||||
final Collection<String> subtract = CollUtil.subtract(list1, list2);
|
||||
Assertions.assertEquals(1, subtract.size());
|
||||
Assertions.assertEquals("x", subtract.iterator().next());
|
||||
assertEquals(1, subtract.size());
|
||||
assertEquals("x", subtract.iterator().next());
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -248,7 +247,7 @@ public class CollUtilTest {
|
||||
map1.put("2", "v2");
|
||||
map2.put("2", "v2");
|
||||
final Collection<String> r2 = CollUtil.subtract(map1.keySet(), map2.keySet());
|
||||
Assertions.assertEquals("[1]", r2.toString());
|
||||
assertEquals("[1]", r2.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -259,7 +258,7 @@ public class CollUtilTest {
|
||||
map1.put("2", "v2");
|
||||
map2.put("2", "v2");
|
||||
final List<String> r2 = CollUtil.subtractToList(map1.keySet(), map2.keySet());
|
||||
Assertions.assertEquals("[1]", r2.toString());
|
||||
assertEquals("[1]", r2.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -275,13 +274,13 @@ public class CollUtilTest {
|
||||
// ----------------------------------------------------------------------------------------
|
||||
final List<HashMap<String, String>> list = ListUtil.of(map1, map2);
|
||||
final Map<String, List<String>> map = CollUtil.toListMap(list);
|
||||
Assertions.assertEquals("值1", map.get("a").get(0));
|
||||
Assertions.assertEquals("值2", map.get("a").get(1));
|
||||
assertEquals("值1", map.get("a").get(0));
|
||||
assertEquals("值2", map.get("a").get(1));
|
||||
|
||||
// ----------------------------------------------------------------------------------------
|
||||
final List<Map<String, String>> listMap = CollUtil.toMapList(map);
|
||||
Assertions.assertEquals("值1", listMap.get(0).get("a"));
|
||||
Assertions.assertEquals("值2", listMap.get(1).get("a"));
|
||||
assertEquals("值1", listMap.get(0).get("a"));
|
||||
assertEquals("值2", listMap.get(1).get("a"));
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -292,24 +291,24 @@ public class CollUtilTest {
|
||||
|
||||
final List<Object> fieldValues = (List<Object>) CollUtil.getFieldValues(list, "name");
|
||||
|
||||
Assertions.assertEquals("张三", fieldValues.get(0));
|
||||
Assertions.assertEquals("李四", fieldValues.get(1));
|
||||
assertEquals("张三", fieldValues.get(0));
|
||||
assertEquals("李四", fieldValues.get(1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void partitionTest() {
|
||||
final List<Integer> list = ListUtil.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||||
final List<List<Integer>> split = CollUtil.partition(list, 3);
|
||||
Assertions.assertEquals(3, split.size());
|
||||
Assertions.assertEquals(3, split.get(0).size());
|
||||
assertEquals(3, split.size());
|
||||
assertEquals(3, split.get(0).size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void partitionTest2() {
|
||||
final ArrayList<Integer> list = ListUtil.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||||
final List<List<Integer>> split = CollUtil.partition(list, Integer.MAX_VALUE);
|
||||
Assertions.assertEquals(1, split.size());
|
||||
Assertions.assertEquals(9, split.get(0).size());
|
||||
assertEquals(1, split.size());
|
||||
assertEquals(9, split.get(0).size());
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -326,7 +325,7 @@ public class CollUtilTest {
|
||||
result[0] = value;
|
||||
}
|
||||
});
|
||||
Assertions.assertEquals("1", result[0]);
|
||||
assertEquals("1", result[0]);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -335,7 +334,7 @@ public class CollUtilTest {
|
||||
|
||||
final Collection<String> filtered = CollUtil.edit(list, t -> t + 1);
|
||||
|
||||
Assertions.assertEquals(ListUtil.of("a1", "b1", "c1"), filtered);
|
||||
assertEquals(ListUtil.of("a1", "b1", "c1"), filtered);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -346,7 +345,7 @@ public class CollUtilTest {
|
||||
|
||||
// 原地过滤
|
||||
Assertions.assertSame(list, filtered);
|
||||
Assertions.assertEquals(ListUtil.of("b", "c"), filtered);
|
||||
assertEquals(ListUtil.of("b", "c"), filtered);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -354,7 +353,7 @@ public class CollUtilTest {
|
||||
final Set<String> set = SetUtil.ofLinked("a", "b", "", " ", "c");
|
||||
final Set<String> filtered = CollUtil.remove(set, StrUtil::isBlank);
|
||||
|
||||
Assertions.assertEquals(SetUtil.ofLinked("a", "b", "c"), filtered);
|
||||
assertEquals(SetUtil.ofLinked("a", "b", "c"), filtered);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -370,12 +369,12 @@ public class CollUtilTest {
|
||||
return false;
|
||||
});
|
||||
|
||||
Assertions.assertEquals(1, removed.size());
|
||||
Assertions.assertEquals("a", removed.get(0));
|
||||
assertEquals(1, removed.size());
|
||||
assertEquals("a", removed.get(0));
|
||||
|
||||
// 原地过滤
|
||||
Assertions.assertSame(list, filtered);
|
||||
Assertions.assertEquals(ListUtil.of("b", "c"), filtered);
|
||||
assertEquals(ListUtil.of("b", "c"), filtered);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -386,7 +385,7 @@ public class CollUtilTest {
|
||||
|
||||
// 原地过滤
|
||||
Assertions.assertSame(list, filtered);
|
||||
Assertions.assertEquals(ListUtil.of("a", "b", "c", "", " "), filtered);
|
||||
assertEquals(ListUtil.of("a", "b", "c", "", " "), filtered);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -397,7 +396,7 @@ public class CollUtilTest {
|
||||
|
||||
// 原地过滤
|
||||
Assertions.assertSame(list, filtered);
|
||||
Assertions.assertEquals(ListUtil.of("a", "b", "c", " "), filtered);
|
||||
assertEquals(ListUtil.of("a", "b", "c", " "), filtered);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -408,7 +407,7 @@ public class CollUtilTest {
|
||||
|
||||
// 原地过滤
|
||||
Assertions.assertSame(list, filtered);
|
||||
Assertions.assertEquals(ListUtil.of("a", "b", "c"), filtered);
|
||||
assertEquals(ListUtil.of("a", "b", "c"), filtered);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -421,38 +420,38 @@ public class CollUtilTest {
|
||||
// 按照奇数偶数分类
|
||||
return Integer.parseInt(t) % 2;
|
||||
});
|
||||
Assertions.assertEquals(ListUtil.of("2", "4", "6"), group2.get(0));
|
||||
Assertions.assertEquals(ListUtil.of("1", "3", "5"), group2.get(1));
|
||||
assertEquals(ListUtil.of("2", "4", "6"), group2.get(0));
|
||||
assertEquals(ListUtil.of("1", "3", "5"), group2.get(1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void groupByFieldTest() {
|
||||
final List<TestBean> list = ListUtil.of(new TestBean("张三", 12), new TestBean("李四", 13), new TestBean("王五", 12));
|
||||
final List<List<TestBean>> groupByField = CollUtil.groupByField(list, "age");
|
||||
Assertions.assertEquals("张三", groupByField.get(0).get(0).getName());
|
||||
Assertions.assertEquals("王五", groupByField.get(0).get(1).getName());
|
||||
assertEquals("张三", groupByField.get(0).get(0).getName());
|
||||
assertEquals("王五", groupByField.get(0).get(1).getName());
|
||||
|
||||
Assertions.assertEquals("李四", groupByField.get(1).get(0).getName());
|
||||
assertEquals("李四", groupByField.get(1).get(0).getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void groupByFuncTest() {
|
||||
final List<TestBean> list = ListUtil.of(new TestBean("张三", 12), new TestBean("李四", 13), new TestBean("王五", 12));
|
||||
final List<List<TestBean>> groupByField = CollUtil.groupByFunc(list, TestBean::getAge);
|
||||
Assertions.assertEquals("张三", groupByField.get(0).get(0).getName());
|
||||
Assertions.assertEquals("王五", groupByField.get(0).get(1).getName());
|
||||
assertEquals("张三", groupByField.get(0).get(0).getName());
|
||||
assertEquals("王五", groupByField.get(0).get(1).getName());
|
||||
|
||||
Assertions.assertEquals("李四", groupByField.get(1).get(0).getName());
|
||||
assertEquals("李四", groupByField.get(1).get(0).getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void groupByFunc2Test() {
|
||||
final List<TestBean> list = ListUtil.of(new TestBean("张三", 12), new TestBean("李四", 13), new TestBean("王五", 12));
|
||||
final List<List<TestBean>> groupByField = CollUtil.groupByFunc(list, a -> a.getAge() > 12);
|
||||
Assertions.assertEquals("张三", groupByField.get(0).get(0).getName());
|
||||
Assertions.assertEquals("王五", groupByField.get(0).get(1).getName());
|
||||
assertEquals("张三", groupByField.get(0).get(0).getName());
|
||||
assertEquals("王五", groupByField.get(0).get(1).getName());
|
||||
|
||||
Assertions.assertEquals("李四", groupByField.get(1).get(0).getName());
|
||||
assertEquals("李四", groupByField.get(1).get(0).getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -464,9 +463,9 @@ public class CollUtilTest {
|
||||
);
|
||||
|
||||
CollUtil.sortByProperty(list, "createTime");
|
||||
Assertions.assertEquals("李四", list.get(0).getName());
|
||||
Assertions.assertEquals("王五", list.get(1).getName());
|
||||
Assertions.assertEquals("张三", list.get(2).getName());
|
||||
assertEquals("李四", list.get(0).getName());
|
||||
assertEquals("王五", list.get(1).getName());
|
||||
assertEquals("张三", list.get(2).getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -478,9 +477,9 @@ public class CollUtilTest {
|
||||
);
|
||||
|
||||
CollUtil.sortByProperty(list, "age");
|
||||
Assertions.assertEquals("李四", list.get(0).getName());
|
||||
Assertions.assertEquals("张三", list.get(1).getName());
|
||||
Assertions.assertEquals("王五", list.get(2).getName());
|
||||
assertEquals("李四", list.get(0).getName());
|
||||
assertEquals("张三", list.get(1).getName());
|
||||
assertEquals("王五", list.get(2).getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -491,9 +490,9 @@ public class CollUtilTest {
|
||||
);
|
||||
|
||||
final Map<String, TestBean> map = CollUtil.fieldValueMap(list, "name");
|
||||
Assertions.assertEquals("李四", map.get("李四").getName());
|
||||
Assertions.assertEquals("王五", map.get("王五").getName());
|
||||
Assertions.assertEquals("张三", map.get("张三").getName());
|
||||
assertEquals("李四", map.get("李四").getName());
|
||||
assertEquals("王五", map.get("王五").getName());
|
||||
assertEquals("张三", map.get("张三").getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -504,21 +503,21 @@ public class CollUtilTest {
|
||||
);
|
||||
|
||||
final Map<String, Integer> map = CollUtil.fieldValueAsMap(list, "name", "age");
|
||||
Assertions.assertEquals(Integer.valueOf(12), map.get("张三"));
|
||||
Assertions.assertEquals(Integer.valueOf(13), map.get("李四"));
|
||||
Assertions.assertEquals(Integer.valueOf(14), map.get("王五"));
|
||||
assertEquals(Integer.valueOf(12), map.get("张三"));
|
||||
assertEquals(Integer.valueOf(13), map.get("李四"));
|
||||
assertEquals(Integer.valueOf(14), map.get("王五"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void emptyTest() {
|
||||
final SortedSet<String> emptySortedSet = CollUtil.empty(SortedSet.class);
|
||||
Assertions.assertEquals(Collections.emptySortedSet(), emptySortedSet);
|
||||
assertEquals(Collections.emptySortedSet(), emptySortedSet);
|
||||
|
||||
final Set<String> emptySet = CollUtil.empty(Set.class);
|
||||
Assertions.assertEquals(Collections.emptySet(), emptySet);
|
||||
assertEquals(Collections.emptySet(), emptySet);
|
||||
|
||||
final List<String> emptyList = CollUtil.empty(List.class);
|
||||
Assertions.assertEquals(Collections.emptyList(), emptyList);
|
||||
assertEquals(Collections.emptyList(), emptyList);
|
||||
}
|
||||
|
||||
@Data
|
||||
@ -547,8 +546,8 @@ public class CollUtilTest {
|
||||
public void listTest2() {
|
||||
final List<String> list1 = ListUtil.of("a", "b", "c");
|
||||
final List<String> list2 = ListUtil.ofLinked("a", "b", "c");
|
||||
Assertions.assertEquals("[a, b, c]", list1.toString());
|
||||
Assertions.assertEquals("[a, b, c]", list2.toString());
|
||||
assertEquals("[a, b, c]", list1.toString());
|
||||
assertEquals("[a, b, c]", list2.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -560,18 +559,18 @@ public class CollUtilTest {
|
||||
|
||||
final List<String> list1 = ListUtil.of(false, set);
|
||||
final List<String> list2 = ListUtil.of(true, set);
|
||||
Assertions.assertEquals("[a, b, c]", list1.toString());
|
||||
Assertions.assertEquals("[a, b, c]", list2.toString());
|
||||
assertEquals("[a, b, c]", list1.toString());
|
||||
assertEquals("[a, b, c]", list2.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getTest() {
|
||||
final HashSet<String> set = SetUtil.ofLinked("A", "B", "C", "D");
|
||||
String str = CollUtil.get(set, 2);
|
||||
Assertions.assertEquals("C", str);
|
||||
assertEquals("C", str);
|
||||
|
||||
str = CollUtil.get(set, -1);
|
||||
Assertions.assertEquals("D", str);
|
||||
assertEquals("D", str);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -587,7 +586,7 @@ public class CollUtilTest {
|
||||
// Assert result
|
||||
final List<Integer> arrayList = new ArrayList<>();
|
||||
arrayList.add(null);
|
||||
Assertions.assertEquals(arrayList, retval);
|
||||
assertEquals(arrayList, retval);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -604,7 +603,7 @@ public class CollUtilTest {
|
||||
// Assert result
|
||||
final List<Integer> arrayList = new ArrayList<>();
|
||||
arrayList.add(null);
|
||||
Assertions.assertEquals(arrayList, retval);
|
||||
assertEquals(arrayList, retval);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -619,7 +618,7 @@ public class CollUtilTest {
|
||||
|
||||
// Assert result
|
||||
final List<Integer> arrayList = new ArrayList<>();
|
||||
Assertions.assertEquals(arrayList, retval);
|
||||
assertEquals(arrayList, retval);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -647,7 +646,7 @@ public class CollUtilTest {
|
||||
final List<Integer> retval = CollUtil.sub(list, start, end, step);
|
||||
// Assert result
|
||||
final List<Integer> arrayList = new ArrayList<>();
|
||||
Assertions.assertEquals(arrayList, retval);
|
||||
assertEquals(arrayList, retval);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -662,7 +661,7 @@ public class CollUtilTest {
|
||||
final List<Integer> retval = CollUtil.sub(list, start, end, step);
|
||||
// Assert result
|
||||
final List<Integer> arrayList = new ArrayList<>();
|
||||
Assertions.assertEquals(arrayList, retval);
|
||||
assertEquals(arrayList, retval);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -706,7 +705,7 @@ public class CollUtilTest {
|
||||
final List<Integer> retval = CollUtil.sub(list, start, end, step);
|
||||
// Assert result
|
||||
final List<Integer> arrayList = new ArrayList<>();
|
||||
Assertions.assertEquals(arrayList, retval);
|
||||
assertEquals(arrayList, retval);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -721,7 +720,7 @@ public class CollUtilTest {
|
||||
final List<Integer> retval = CollUtil.sub(list, start, end, step);
|
||||
// Assert result
|
||||
final List<Integer> arrayList = new ArrayList<>();
|
||||
Assertions.assertEquals(arrayList, retval);
|
||||
assertEquals(arrayList, retval);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -736,7 +735,7 @@ public class CollUtilTest {
|
||||
final List<Integer> retval = CollUtil.sub(list, start, end, step);
|
||||
// Assert result
|
||||
final List<Integer> arrayList = new ArrayList<>();
|
||||
Assertions.assertEquals(arrayList, retval);
|
||||
assertEquals(arrayList, retval);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -756,7 +755,7 @@ public class CollUtilTest {
|
||||
final List<Integer> list = ListUtil.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||||
final List<Integer> sortPageAll = CollUtil.sortPageAll(1, 5, Comparator.reverseOrder(), list);
|
||||
|
||||
Assertions.assertEquals(ListUtil.of(4, 3, 2, 1), sortPageAll);
|
||||
assertEquals(ListUtil.of(4, 3, 2, 1), sortPageAll);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -793,22 +792,22 @@ public class CollUtilTest {
|
||||
|
||||
final Map<String, Integer> map = CollUtil.zip(keys, values);
|
||||
|
||||
Assertions.assertEquals(4, Objects.requireNonNull(map).size());
|
||||
assertEquals(4, Objects.requireNonNull(map).size());
|
||||
|
||||
Assertions.assertEquals(1, map.get("a").intValue());
|
||||
Assertions.assertEquals(2, map.get("b").intValue());
|
||||
Assertions.assertEquals(3, map.get("c").intValue());
|
||||
Assertions.assertEquals(4, map.get("d").intValue());
|
||||
assertEquals(1, map.get("a").intValue());
|
||||
assertEquals(2, map.get("b").intValue());
|
||||
assertEquals(3, map.get("c").intValue());
|
||||
assertEquals(4, map.get("d").intValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void toMapTest() {
|
||||
final Collection<String> keys = ListUtil.of("a", "b", "c", "d");
|
||||
final Map<String, String> map = IterUtil.toMap(keys, (value) -> "key" + value);
|
||||
Assertions.assertEquals("a", map.get("keya"));
|
||||
Assertions.assertEquals("b", map.get("keyb"));
|
||||
Assertions.assertEquals("c", map.get("keyc"));
|
||||
Assertions.assertEquals("d", map.get("keyd"));
|
||||
assertEquals("a", map.get("keya"));
|
||||
assertEquals("b", map.get("keyb"));
|
||||
assertEquals("c", map.get("keyc"));
|
||||
assertEquals("d", map.get("keyd"));
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -822,9 +821,9 @@ public class CollUtilTest {
|
||||
Map.Entry::getKey,
|
||||
entry -> Long.parseLong(entry.getValue()));
|
||||
|
||||
Assertions.assertEquals(1L, (long) map.get("a"));
|
||||
Assertions.assertEquals(12L, (long) map.get("b"));
|
||||
Assertions.assertEquals(134L, (long) map.get("c"));
|
||||
assertEquals(1L, (long) map.get("a"));
|
||||
assertEquals(12L, (long) map.get("b"));
|
||||
assertEquals(134L, (long) map.get("c"));
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -832,17 +831,17 @@ public class CollUtilTest {
|
||||
final List<String> list = ListUtil.of("a", "b", "c", "c", "a", "b", "d");
|
||||
final Map<String, Integer> countMap = CollUtil.countMap(list);
|
||||
|
||||
Assertions.assertEquals(Integer.valueOf(2), countMap.get("a"));
|
||||
Assertions.assertEquals(Integer.valueOf(2), countMap.get("b"));
|
||||
Assertions.assertEquals(Integer.valueOf(2), countMap.get("c"));
|
||||
Assertions.assertEquals(Integer.valueOf(1), countMap.get("d"));
|
||||
assertEquals(Integer.valueOf(2), countMap.get("a"));
|
||||
assertEquals(Integer.valueOf(2), countMap.get("b"));
|
||||
assertEquals(Integer.valueOf(2), countMap.get("c"));
|
||||
assertEquals(Integer.valueOf(1), countMap.get("d"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void indexOfTest() {
|
||||
final List<String> list = ListUtil.of("a", "b", "c", "c", "a", "b", "d");
|
||||
final int i = CollUtil.indexOf(list, (str) -> str.charAt(0) == 'c');
|
||||
Assertions.assertEquals(2, i);
|
||||
assertEquals(2, i);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -850,13 +849,13 @@ public class CollUtilTest {
|
||||
// List有优化
|
||||
final List<String> list = ListUtil.of("a", "b", "c", "c", "a", "b", "d");
|
||||
final int i = CollUtil.lastIndexOf(list, (str) -> str.charAt(0) == 'a');
|
||||
Assertions.assertEquals(4, i);
|
||||
assertEquals(4, i);
|
||||
|
||||
final Queue<Integer> set = new ArrayDeque<>(Arrays.asList(1, 2, 3, 3, 2, 1));
|
||||
Assertions.assertEquals(5, CollUtil.lastIndexOf(set, num -> num.equals(1)));
|
||||
Assertions.assertEquals(4, CollUtil.lastIndexOf(set, num -> num.equals(2)));
|
||||
Assertions.assertEquals(3, CollUtil.lastIndexOf(set, num -> num.equals(3)));
|
||||
Assertions.assertEquals(-1, CollUtil.lastIndexOf(set, num -> num.equals(4)));
|
||||
assertEquals(5, CollUtil.lastIndexOf(set, num -> num.equals(1)));
|
||||
assertEquals(4, CollUtil.lastIndexOf(set, num -> num.equals(2)));
|
||||
assertEquals(3, CollUtil.lastIndexOf(set, num -> num.equals(3)));
|
||||
assertEquals(-1, CollUtil.lastIndexOf(set, num -> num.equals(4)));
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -864,7 +863,7 @@ public class CollUtilTest {
|
||||
final Set<String> list = SetUtil.ofLinked("a", "b", "c", "c", "a", "b", "d");
|
||||
// 去重后c排第三
|
||||
final int i = CollUtil.lastIndexOf(list, (str) -> str.charAt(0) == 'c');
|
||||
Assertions.assertEquals(2, i);
|
||||
assertEquals(2, i);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -874,7 +873,7 @@ public class CollUtilTest {
|
||||
objects.add(Dict.of().set("name", "姓名：" + i));
|
||||
}
|
||||
|
||||
Assertions.assertEquals(0, ListUtil.page(objects, 3, 5).size());
|
||||
assertEquals(0, ListUtil.page(objects, 3, 5).size());
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -883,15 +882,15 @@ public class CollUtilTest {
|
||||
final List<Long> list2 = Arrays.asList(2L, 3L);
|
||||
|
||||
final List<Long> result = CollUtil.subtractToList(list1, list2);
|
||||
Assertions.assertEquals(1, result.size());
|
||||
Assertions.assertEquals(1L, (long) result.get(0));
|
||||
assertEquals(1, result.size());
|
||||
assertEquals(1L, (long) result.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sortNaturalTest() {
|
||||
final List<String> of = ListUtil.of("a", "c", "b");
|
||||
final List<String> sort = CollUtil.sort(of, CompareUtil.natural());
|
||||
Assertions.assertEquals("a,b,c", CollUtil.join(sort, ","));
|
||||
assertEquals("a,b,c", CollUtil.join(sort, ","));
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -914,9 +913,9 @@ public class CollUtilTest {
|
||||
genderMap.put(5, "小孩");
|
||||
genderMap.put(6, "男");
|
||||
|
||||
Assertions.assertEquals(people.get(1).getGender(), "woman");
|
||||
assertEquals("woman", people.get(1).getGender());
|
||||
CollUtil.setValueByMap(people, genderMap, Person::getId, Person::setGender);
|
||||
Assertions.assertEquals(people.get(1).getGender(), "妇女");
|
||||
assertEquals("妇女", people.get(1).getGender());
|
||||
|
||||
final Map<Integer, Person> personMap = new HashMap<>();
|
||||
personMap.put(1, new Person("AA", 21, "男", 1));
|
||||
@ -932,13 +931,13 @@ public class CollUtilTest {
|
||||
x.setAge(y.getAge());
|
||||
});
|
||||
|
||||
Assertions.assertEquals(people.get(1).getGender(), "小孩");
|
||||
assertEquals("小孩", people.get(1).getGender());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void distinctTest() {
|
||||
final List<Integer> distinct = CollUtil.distinct(ListUtil.view(5, 3, 10, 9, 0, 5, 10, 9));
|
||||
Assertions.assertEquals(ListUtil.view(5, 3, 10, 9, 0), distinct);
|
||||
assertEquals(ListUtil.view(5, 3, 10, 9, 0), distinct);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -954,15 +953,15 @@ public class CollUtilTest {
|
||||
|
||||
// 覆盖模式下ff覆盖了aa，ee覆盖了bb
|
||||
List<Person> distinct = CollUtil.distinct(people, Person::getGender, true);
|
||||
Assertions.assertEquals(2, distinct.size());
|
||||
Assertions.assertEquals("ff", distinct.get(0).getName());
|
||||
Assertions.assertEquals("ee", distinct.get(1).getName());
|
||||
assertEquals(2, distinct.size());
|
||||
assertEquals("ff", distinct.get(0).getName());
|
||||
assertEquals("ee", distinct.get(1).getName());
|
||||
|
||||
// 非覆盖模式下，保留了最早加入的aa和bb
|
||||
distinct = CollUtil.distinct(people, Person::getGender, false);
|
||||
Assertions.assertEquals(2, distinct.size());
|
||||
Assertions.assertEquals("aa", distinct.get(0).getName());
|
||||
Assertions.assertEquals("bb", distinct.get(1).getName());
|
||||
assertEquals(2, distinct.size());
|
||||
assertEquals("aa", distinct.get(0).getName());
|
||||
assertEquals("bb", distinct.get(1).getName());
|
||||
}
|
||||
|
||||
@Data
|
||||
@ -978,7 +977,7 @@ public class CollUtilTest {
|
||||
public void mapTest() {
|
||||
final List<String> list = ListUtil.of("a", "b", "c");
|
||||
final List<Object> extract = CollUtil.map(list, (e) -> e + "_1");
|
||||
Assertions.assertEquals(ListUtil.of("a_1", "b_1", "c_1"), extract);
|
||||
assertEquals(ListUtil.of("a_1", "b_1", "c_1"), extract);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -991,7 +990,7 @@ public class CollUtilTest {
|
||||
);
|
||||
|
||||
final List<Object> extract = CollUtil.map(people, Person::getName);
|
||||
Assertions.assertEquals(ListUtil.of("aa", "bb", "cc", "dd"), extract);
|
||||
assertEquals(ListUtil.of("aa", "bb", "cc", "dd"), extract);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -1011,7 +1010,7 @@ public class CollUtilTest {
|
||||
);
|
||||
|
||||
final Collection<String> trans = CollUtil.trans(people, Person::getName);
|
||||
Assertions.assertEquals("[aa, bb, cc, dd]", trans.toString());
|
||||
assertEquals("[aa, bb, cc, dd]", trans.toString());
|
||||
}
|
||||
|
||||
@SuppressWarnings("ConstantConditions")
|
||||
@ -1043,7 +1042,7 @@ public class CollUtilTest {
|
||||
final List<String> list = CollUtil.unionAll(list1, list2, list3);
|
||||
Assertions.assertNotNull(list);
|
||||
|
||||
Assertions.assertEquals(
|
||||
assertEquals(
|
||||
ListUtil.of(1, 2, 3, 4),
|
||||
CollUtil.unionAll(ListUtil.of(1), ListUtil.of(2), ListUtil.of(3), ListUtil.of(4))
|
||||
);
|
||||
@ -1133,11 +1132,11 @@ public class CollUtilTest {
|
||||
Assertions.assertNull(CollUtil.getFirst(null));
|
||||
Assertions.assertNull(CollUtil.getFirst(ListUtil.of()));
|
||||
|
||||
Assertions.assertEquals("1", CollUtil.getFirst(ListUtil.of("1", "2", "3")));
|
||||
assertEquals("1", CollUtil.getFirst(ListUtil.of("1", "2", "3")));
|
||||
final ArrayDeque<String> deque = new ArrayDeque<>();
|
||||
deque.add("3");
|
||||
deque.add("4");
|
||||
Assertions.assertEquals("3", CollUtil.getFirst(deque));
|
||||
assertEquals("3", CollUtil.getFirst(deque));
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -1147,16 +1146,16 @@ public class CollUtilTest {
|
||||
stack.push(i);
|
||||
}
|
||||
final List<Integer> popPart1 = CollUtil.popPart(stack, 3);
|
||||
Assertions.assertEquals(ListUtil.of(9, 8, 7), popPart1);
|
||||
Assertions.assertEquals(7, stack.size());
|
||||
assertEquals(ListUtil.of(9, 8, 7), popPart1);
|
||||
assertEquals(7, stack.size());
|
||||
|
||||
final ArrayDeque<Integer> queue = new ArrayDeque<>();
|
||||
for (int i = 0; i < 10; i++) {
|
||||
queue.push(i);
|
||||
}
|
||||
final List<Integer> popPart2 = CollUtil.popPart(queue, 3);
|
||||
Assertions.assertEquals(ListUtil.of(9, 8, 7), popPart2);
|
||||
Assertions.assertEquals(7, queue.size());
|
||||
assertEquals(ListUtil.of(9, 8, 7), popPart2);
|
||||
assertEquals(7, queue.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -1185,7 +1184,7 @@ public class CollUtilTest {
|
||||
@Test
|
||||
public void maxTest() {
|
||||
final List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
|
||||
Assertions.assertEquals((Integer) 6, CollUtil.max(list));
|
||||
assertEquals((Integer) 6, CollUtil.max(list));
|
||||
}
|
||||
|
||||
@SuppressWarnings({"rawtypes", "unchecked"})
|
||||
@ -1204,7 +1203,7 @@ public class CollUtilTest {
|
||||
public void unionExtendTest() {
|
||||
final List<Dog> dog = Arrays.asList(new Dog("dog1", 12), new Dog("dog2", 12));
|
||||
final List<Cat> cat = Arrays.asList(new Cat("cat1", 12), new Cat("cat2", 12));
|
||||
Assertions.assertEquals(CollUtil.union(dog, cat).size(), dog.size() + cat.size());
|
||||
assertEquals(CollUtil.union(dog, cat).size(), dog.size() + cat.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -1212,7 +1211,7 @@ public class CollUtilTest {
|
||||
final List<Dog> dog = Arrays.asList(new Dog("dog1", 12), new Dog("dog2", 12));
|
||||
final List<Cat> cat = Arrays.asList(new Cat("cat1", 12), new Cat("cat2", 12));
|
||||
final List<Pig> pig = Arrays.asList(new Pig("pig1", 12), new Pig("pig2", 12));
|
||||
Assertions.assertEquals(CollUtil.unionAll(dog, cat, pig).size(), dog.size() + cat.size() + pig.size());
|
||||
assertEquals(CollUtil.unionAll(dog, cat, pig).size(), dog.size() + cat.size() + pig.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -1220,7 +1219,7 @@ public class CollUtilTest {
|
||||
final List<Dog> dog = Arrays.asList(new Dog("dog1", 12), new Dog("dog1", 12)); // same
|
||||
final List<Cat> cat = Arrays.asList(new Cat("cat1", 12), new Cat("cat2", 12));
|
||||
final List<Pig> pig = Arrays.asList(new Pig("pig1", 12), new Pig("pig2", 12));
|
||||
Assertions.assertEquals(CollUtil.unionDistinct(dog, cat, pig).size(), 5);
|
||||
assertEquals(5, CollUtil.unionDistinct(dog, cat, pig).size());
|
||||
}
|
||||
|
||||
|
||||
@ -1289,4 +1288,16 @@ public class CollUtilTest {
|
||||
|
||||
assertTrue(CollUtil.containsAll(coll1, coll2));
|
||||
}
|
||||
|
||||
@Test
|
||||
void issueIBHP68Test() {
|
||||
final List<Integer> view1 = ListUtil.view(1, 2, 3);
|
||||
final List<Integer> l3 = ListUtil.of(1);
|
||||
final Collection<Integer> subtract = CollUtil.subtract(view1, l3);
|
||||
assertEquals(2, subtract.size());
|
||||
assertEquals(2, subtract.iterator().next());
|
||||
assertFalse(subtract.contains(1));
|
||||
assertTrue(subtract.contains(2));
|
||||
assertTrue(subtract.contains(3));
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user