lsm/hutool
1
0
Fork 0
mirror of https://gitee.com/dromara/hutool.git synced 2025-06-28 13:34:09 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix bug

Browse Source
This commit is contained in:
Looly 2022-07-05 22:26:27 +08:00
parent 99d83e142f
commit 6ac537d6c3
2 changed files with 136 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -15,6 +15,7 @@
* 【core 】 新增CollectorUtil.reduceListMap()（pr#676@Gitee）
*
### 🐞Bug修复
* 【core 】 修复CollUtil里面关于可变参数传null造成的crash问题（pr#2428@Github）
-------------------------------------------------------------------------------------------------------------

270
hutool-core/src/test/java/cn/hutool/core/collection/CollUtilTest.java
View File

@ -21,7 +21,7 @@ public class CollUtilTest {
@Test
public void testPredicateContains() {
ArrayList<String> list = CollUtil.newArrayList("bbbbb", "aaaaa", "ccccc");
final ArrayList<String> list = CollUtil.newArrayList("bbbbb", "aaaaa", "ccccc");
Assert.assertTrue(CollUtil.contains(list, s -> s.startsWith("a")));
Assert.assertFalse(CollUtil.contains(list, s -> s.startsWith("d")));
}
@ -29,8 +29,8 @@ public class CollUtilTest {
@Test
public void testRemoveWithAddIf() {
ArrayList<Integer> list = CollUtil.newArrayList(1, 2, 3);
ArrayList<Integer> exceptRemovedList = CollUtil.newArrayList(2, 3);
ArrayList<Integer> exceptResultList = CollUtil.newArrayList(1);
final ArrayList<Integer> exceptRemovedList = CollUtil.newArrayList(2, 3);
final ArrayList<Integer> exceptResultList = CollUtil.newArrayList(1);
List<Integer> resultList = CollUtil.removeWithAddIf(list, ele -> 1 == ele);
Assert.assertEquals(list, exceptRemovedList);
@ -64,8 +64,8 @@ public class CollUtilTest {
@Test
public void testPadRight() {
List<String> srcList = CollUtil.newArrayList("a");
List<String> answerList = CollUtil.newArrayList("a", "b", "b", "b", "b");
final List<String> srcList = CollUtil.newArrayList("a");
final List<String> answerList = CollUtil.newArrayList("a", "b", "b", "b", "b");
CollUtil.padRight(srcList, 5, "b");
Assert.assertEquals(srcList, answerList);
}
@ -77,22 +77,22 @@ public class CollUtilTest {
@Test
public void newHashSetTest() {
Set<String> set = CollUtil.newHashSet((String[]) null);
final Set<String> set = CollUtil.newHashSet((String[]) null);
Assert.assertNotNull(set);
}
@Test
public void valuesOfKeysTest() {
Dict v1 = Dict.create().set("id", 12).set("name", "张三").set("age", 23);
Dict v2 = Dict.create().set("age", 13).set("id", 15).set("name", "李四");
final Dict v1 = Dict.create().set("id", 12).set("name", "张三").set("age", 23);
final Dict v2 = Dict.create().set("age", 13).set("id", 15).set("name", "李四");
final String[] keys = v1.keySet().toArray(new String[0]);
ArrayList<Object> v1s = CollUtil.valuesOfKeys(v1, keys);
final ArrayList<Object> v1s = CollUtil.valuesOfKeys(v1, keys);
Assert.assertTrue(v1s.contains(12));
Assert.assertTrue(v1s.contains(23));
Assert.assertTrue(v1s.contains("张三"));
ArrayList<Object> v2s = CollUtil.valuesOfKeys(v2, keys);
final ArrayList<Object> v2s = CollUtil.valuesOfKeys(v2, keys);
Assert.assertTrue(v2s.contains(15));
Assert.assertTrue(v2s.contains(13));
Assert.assertTrue(v2s.contains("李四"));
@ -100,47 +100,47 @@ public class CollUtilTest {
@Test
public void unionTest() {
ArrayList<String> list1 = CollUtil.newArrayList("a", "b", "b", "c", "d", "x");
ArrayList<String> list2 = CollUtil.newArrayList("a", "b", "b", "b", "c", "d");
final ArrayList<String> list1 = CollUtil.newArrayList("a", "b", "b", "c", "d", "x");
final ArrayList<String> list2 = CollUtil.newArrayList("a", "b", "b", "b", "c", "d");
Collection<String> union = CollUtil.union(list1, list2);
final Collection<String> union = CollUtil.union(list1, list2);
Assert.assertEquals(3, CollUtil.count(union, "b"::equals));
}
@Test
public void intersectionTest() {
ArrayList<String> list1 = CollUtil.newArrayList("a", "b", "b", "c", "d", "x");
ArrayList<String> list2 = CollUtil.newArrayList("a", "b", "b", "b", "c", "d");
final ArrayList<String> list1 = CollUtil.newArrayList("a", "b", "b", "c", "d", "x");
final ArrayList<String> list2 = CollUtil.newArrayList("a", "b", "b", "b", "c", "d");
Collection<String> intersection = CollUtil.intersection(list1, list2);
final Collection<String> intersection = CollUtil.intersection(list1, list2);
Assert.assertEquals(2, CollUtil.count(intersection, "b"::equals));
}
@Test
public void intersectionDistinctTest() {
ArrayList<String> list1 = CollUtil.newArrayList("a", "b", "b", "c", "d", "x");
ArrayList<String> list2 = CollUtil.newArrayList("a", "b", "b", "b", "c", "d");
ArrayList<String> list3 = CollUtil.newArrayList();
final ArrayList<String> list1 = CollUtil.newArrayList("a", "b", "b", "c", "d", "x");
final ArrayList<String> list2 = CollUtil.newArrayList("a", "b", "b", "b", "c", "d");
final ArrayList<String> list3 = CollUtil.newArrayList();
Collection<String> intersectionDistinct = CollUtil.intersectionDistinct(list1, list2);
final Collection<String> intersectionDistinct = CollUtil.intersectionDistinct(list1, list2);
Assert.assertEquals(CollUtil.newLinkedHashSet("a", "b", "c", "d"), intersectionDistinct);
Collection<String> intersectionDistinct2 = CollUtil.intersectionDistinct(list1, list2, list3);
final Collection<String> intersectionDistinct2 = CollUtil.intersectionDistinct(list1, list2, list3);
Assert.assertTrue(intersectionDistinct2.isEmpty());
}
@Test
public void disjunctionTest() {
ArrayList<String> list1 = CollUtil.newArrayList("a", "b", "b", "c", "d", "x");
ArrayList<String> list2 = CollUtil.newArrayList("a", "b", "b", "b", "c", "d", "x2");
final ArrayList<String> list1 = CollUtil.newArrayList("a", "b", "b", "c", "d", "x");
final ArrayList<String> list2 = CollUtil.newArrayList("a", "b", "b", "b", "c", "d", "x2");
Collection<String> disjunction = CollUtil.disjunction(list1, list2);
final Collection<String> disjunction = CollUtil.disjunction(list1, list2);
Assert.assertTrue(disjunction.contains("b"));
Assert.assertTrue(disjunction.contains("x2"));
Assert.assertTrue(disjunction.contains("x"));
Collection<String> disjunction2 = CollUtil.disjunction(list2, list1);
final Collection<String> disjunction2 = CollUtil.disjunction(list2, list1);
Assert.assertTrue(disjunction2.contains("b"));
Assert.assertTrue(disjunction2.contains("x2"));
Assert.assertTrue(disjunction2.contains("x"));
@ -149,29 +149,29 @@ public class CollUtilTest {
@Test
public void disjunctionTest2() {
// 任意一个集合为空，差集为另一个集合
ArrayList<String> list1 = CollUtil.newArrayList();
ArrayList<String> list2 = CollUtil.newArrayList("a", "b", "b", "b", "c", "d", "x2");
final ArrayList<String> list1 = CollUtil.newArrayList();
final ArrayList<String> list2 = CollUtil.newArrayList("a", "b", "b", "b", "c", "d", "x2");
Collection<String> disjunction = CollUtil.disjunction(list1, list2);
final Collection<String> disjunction = CollUtil.disjunction(list1, list2);
Assert.assertEquals(list2, disjunction);
Collection<String> disjunction2 = CollUtil.disjunction(list2, list1);
final Collection<String> disjunction2 = CollUtil.disjunction(list2, list1);
Assert.assertEquals(list2, disjunction2);
}
@Test
public void disjunctionTest3() {
// 无交集下返回共同的元素
ArrayList<String> list1 = CollUtil.newArrayList("1", "2", "3");
ArrayList<String> list2 = CollUtil.newArrayList("a", "b", "c");
final ArrayList<String> list1 = CollUtil.newArrayList("1", "2", "3");
final ArrayList<String> list2 = CollUtil.newArrayList("a", "b", "c");
Collection<String> disjunction = CollUtil.disjunction(list1, list2);
final Collection<String> disjunction = CollUtil.disjunction(list1, list2);
Assert.assertTrue(disjunction.contains("1"));
Assert.assertTrue(disjunction.contains("2"));
Assert.assertTrue(disjunction.contains("3"));
Assert.assertTrue(disjunction.contains("a"));
Assert.assertTrue(disjunction.contains("b"));
Assert.assertTrue(disjunction.contains("c"));
Collection<String> disjunction2 = CollUtil.disjunction(list2, list1);
final Collection<String> disjunction2 = CollUtil.disjunction(list2, list1);
Assert.assertTrue(disjunction2.contains("1"));
Assert.assertTrue(disjunction2.contains("2"));
Assert.assertTrue(disjunction2.contains("3"));
@ -182,8 +182,8 @@ public class CollUtilTest {
@Test
public void subtractTest() {
List<String> list1 = CollUtil.newArrayList("a", "b", "b", "c", "d", "x");
List<String> list2 = CollUtil.newArrayList("a", "b", "b", "b", "c", "d", "x2");
final List<String> list1 = CollUtil.newArrayList("a", "b", "b", "c", "d", "x");
final List<String> list2 = CollUtil.newArrayList("a", "b", "b", "b", "c", "d", "x2");
final Collection<String> subtract = CollUtil.subtract(list1, list2);
Assert.assertEquals(1, subtract.size());
Assert.assertEquals("x", subtract.iterator().next());
@ -191,55 +191,55 @@ public class CollUtilTest {
@Test
public void subtractSetTest() {
HashMap<String, Object> map1 = MapUtil.newHashMap();
HashMap<String, Object> map2 = MapUtil.newHashMap();
final HashMap<String, Object> map1 = MapUtil.newHashMap();
final HashMap<String, Object> map2 = MapUtil.newHashMap();
map1.put("1", "v1");
map1.put("2", "v2");
map2.put("2", "v2");
Collection<String> r2 = CollUtil.subtract(map1.keySet(), map2.keySet());
final Collection<String> r2 = CollUtil.subtract(map1.keySet(), map2.keySet());
Assert.assertEquals("[1]", r2.toString());
}
@Test
public void subtractSetToListTest() {
HashMap<String, Object> map1 = MapUtil.newHashMap();
HashMap<String, Object> map2 = MapUtil.newHashMap();
final HashMap<String, Object> map1 = MapUtil.newHashMap();
final HashMap<String, Object> map2 = MapUtil.newHashMap();
map1.put("1", "v1");
map1.put("2", "v2");
map2.put("2", "v2");
List<String> r2 = CollUtil.subtractToList(map1.keySet(), map2.keySet());
final List<String> r2 = CollUtil.subtractToList(map1.keySet(), map2.keySet());
Assert.assertEquals("[1]", r2.toString());
}
@Test
public void toMapListAndToListMapTest() {
HashMap<String, String> map1 = new HashMap<>();
final HashMap<String, String> map1 = new HashMap<>();
map1.put("a", "值1");
map1.put("b", "值1");
HashMap<String, String> map2 = new HashMap<>();
final HashMap<String, String> map2 = new HashMap<>();
map2.put("a", "值2");
map2.put("c", "值3");
// ----------------------------------------------------------------------------------------
ArrayList<HashMap<String, String>> list = CollUtil.newArrayList(map1, map2);
Map<String, List<String>> map = CollUtil.toListMap(list);
final ArrayList<HashMap<String, String>> list = CollUtil.newArrayList(map1, map2);
final Map<String, List<String>> map = CollUtil.toListMap(list);
Assert.assertEquals("值1", map.get("a").get(0));
Assert.assertEquals("值2", map.get("a").get(1));
// ----------------------------------------------------------------------------------------
List<Map<String, String>> listMap = CollUtil.toMapList(map);
final List<Map<String, String>> listMap = CollUtil.toMapList(map);
Assert.assertEquals("值1", listMap.get(0).get("a"));
Assert.assertEquals("值2", listMap.get(1).get("a"));
}
@Test
public void getFieldValuesTest() {
Dict v1 = Dict.create().set("id", 12).set("name", "张三").set("age", 23);
Dict v2 = Dict.create().set("age", 13).set("id", 15).set("name", "李四");
ArrayList<Dict> list = CollUtil.newArrayList(v1, v2);
final Dict v1 = Dict.create().set("id", 12).set("name", "张三").set("age", 23);
final Dict v2 = Dict.create().set("age", 13).set("id", 15).set("name", "李四");
final ArrayList<Dict> list = CollUtil.newArrayList(v1, v2);
List<Object> fieldValues = CollUtil.getFieldValues(list, "name");
final List<Object> fieldValues = CollUtil.getFieldValues(list, "name");
Assert.assertEquals("张三", fieldValues.get(0));
Assert.assertEquals("李四", fieldValues.get(1));
}
@ -247,20 +247,20 @@ public class CollUtilTest {
@Test
public void splitTest() {
final ArrayList<Integer> list = CollUtil.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9);
List<List<Integer>> split = CollUtil.split(list, 3);
final List<List<Integer>> split = CollUtil.split(list, 3);
Assert.assertEquals(3, split.size());
Assert.assertEquals(3, split.get(0).size());
}
@Test
public void foreachTest() {
HashMap<String, String> map = MapUtil.newHashMap();
final HashMap<String, String> map = MapUtil.newHashMap();
map.put("a", "1");
map.put("b", "2");
map.put("c", "3");
final String[] result = new String[1];
String a = "a";
final String a = "a";
CollUtil.forEach(map, (key, value, index) -> {
if (a.equals(key)) {
result[0] = value;
@ -271,18 +271,18 @@ public class CollUtilTest {
@Test
public void filterTest() {
ArrayList<String> list = CollUtil.newArrayList("a", "b", "c");
final ArrayList<String> list = CollUtil.newArrayList("a", "b", "c");
Collection<String> filtered = CollUtil.edit(list, t -> t + 1);
final Collection<String> filtered = CollUtil.edit(list, t -> t + 1);
Assert.assertEquals(CollUtil.newArrayList("a1", "b1", "c1"), filtered);
}
@Test
public void filterTest2() {
ArrayList<String> list = CollUtil.newArrayList("a", "b", "c");
final ArrayList<String> list = CollUtil.newArrayList("a", "b", "c");
ArrayList<String> filtered = CollUtil.filter(list, t -> false == "a".equals(t));
final ArrayList<String> filtered = CollUtil.filter(list, t -> false == "a".equals(t));
// 原地过滤
Assert.assertSame(list, filtered);
@ -291,18 +291,18 @@ public class CollUtilTest {
@Test
public void filterSetTest() {
Set<String> set = CollUtil.newLinkedHashSet("a", "b", "", " ", "c");
Set<String> filtered = CollUtil.filter(set, StrUtil::isNotBlank);
final Set<String> set = CollUtil.newLinkedHashSet("a", "b", "", " ", "c");
final Set<String> filtered = CollUtil.filter(set, StrUtil::isNotBlank);
Assert.assertEquals(CollUtil.newLinkedHashSet("a", "b", "c"), filtered);
}
@Test
public void filterRemoveTest() {
ArrayList<String> list = CollUtil.newArrayList("a", "b", "c");
final ArrayList<String> list = CollUtil.newArrayList("a", "b", "c");
List<String> removed = new ArrayList<>();
ArrayList<String> filtered = CollUtil.filter(list, t -> {
final List<String> removed = new ArrayList<>();
final ArrayList<String> filtered = CollUtil.filter(list, t -> {
if("a".equals(t)){
removed.add(t);
return false;
@ -320,9 +320,9 @@ public class CollUtilTest {
@Test
public void removeNullTest() {
ArrayList<String> list = CollUtil.newArrayList("a", "b", "c", null, "", " ");
final ArrayList<String> list = CollUtil.newArrayList("a", "b", "c", null, "", " ");
ArrayList<String> filtered = CollUtil.removeNull(list);
final ArrayList<String> filtered = CollUtil.removeNull(list);
// 原地过滤
Assert.assertSame(list, filtered);
@ -331,9 +331,9 @@ public class CollUtilTest {
@Test
public void removeEmptyTest() {
ArrayList<String> list = CollUtil.newArrayList("a", "b", "c", null, "", " ");
final ArrayList<String> list = CollUtil.newArrayList("a", "b", "c", null, "", " ");
ArrayList<String> filtered = CollUtil.removeEmpty(list);
final ArrayList<String> filtered = CollUtil.removeEmpty(list);
// 原地过滤
Assert.assertSame(list, filtered);
@ -342,9 +342,9 @@ public class CollUtilTest {
@Test
public void removeBlankTest() {
ArrayList<String> list = CollUtil.newArrayList("a", "b", "c", null, "", " ");
final ArrayList<String> list = CollUtil.newArrayList("a", "b", "c", null, "", " ");
ArrayList<String> filtered = CollUtil.removeBlank(list);
final ArrayList<String> filtered = CollUtil.removeBlank(list);
// 原地过滤
Assert.assertSame(list, filtered);
@ -353,11 +353,11 @@ public class CollUtilTest {
@Test
public void groupTest() {
List<String> list = CollUtil.newArrayList("1", "2", "3", "4", "5", "6");
List<List<String>> group = CollUtil.group(list, null);
final List<String> list = CollUtil.newArrayList("1", "2", "3", "4", "5", "6");
final List<List<String>> group = CollUtil.group(list, null);
Assert.assertTrue(group.size() > 0);
List<List<String>> group2 = CollUtil.group(list, t -> {
final List<List<String>> group2 = CollUtil.group(list, t -> {
// 按照奇数偶数分类
return Integer.parseInt(t) % 2;
});
@ -367,8 +367,8 @@ public class CollUtilTest {
@Test
public void groupByFieldTest() {
List<TestBean> list = CollUtil.newArrayList(new TestBean("张三", 12), new TestBean("李四", 13), new TestBean("王五", 12));
List<List<TestBean>> groupByField = CollUtil.groupByField(list, "age");
final List<TestBean> list = CollUtil.newArrayList(new TestBean("张三", 12), new TestBean("李四", 13), new TestBean("王五", 12));
final List<List<TestBean>> groupByField = CollUtil.groupByField(list, "age");
Assert.assertEquals("张三", groupByField.get(0).get(0).getName());
Assert.assertEquals("王五", groupByField.get(0).get(1).getName());
@ -377,7 +377,7 @@ public class CollUtilTest {
@Test
public void sortByPropertyTest() {
List<TestBean> list = CollUtil.newArrayList(
final List<TestBean> list = CollUtil.newArrayList(
new TestBean("张三", 12, DateUtil.parse("2018-05-01")), //
new TestBean("李四", 13, DateUtil.parse("2018-03-01")), //
new TestBean("王五", 12, DateUtil.parse("2018-04-01"))//
@ -391,7 +391,7 @@ public class CollUtilTest {
@Test
public void sortByPropertyTest2() {
List<TestBean> list = CollUtil.newArrayList(
final List<TestBean> list = CollUtil.newArrayList(
new TestBean("张三", 0, DateUtil.parse("2018-05-01")), //
new TestBean("李四", -12, DateUtil.parse("2018-03-01")), //
new TestBean("王五", 23, DateUtil.parse("2018-04-01"))//
@ -405,7 +405,7 @@ public class CollUtilTest {
@Test
public void fieldValueMapTest() {
List<TestBean> list = CollUtil.newArrayList(new TestBean("张三", 12, DateUtil.parse("2018-05-01")), //
final List<TestBean> list = CollUtil.newArrayList(new TestBean("张三", 12, DateUtil.parse("2018-05-01")), //
new TestBean("李四", 13, DateUtil.parse("2018-03-01")), //
new TestBean("王五", 12, DateUtil.parse("2018-04-01"))//
);
@ -418,7 +418,7 @@ public class CollUtilTest {
@Test
public void fieldValueAsMapTest() {
List<TestBean> list = CollUtil.newArrayList(new TestBean("张三", 12, DateUtil.parse("2018-05-01")), //
final List<TestBean> list = CollUtil.newArrayList(new TestBean("张三", 12, DateUtil.parse("2018-05-01")), //
new TestBean("李四", 13, DateUtil.parse("2018-03-01")), //
new TestBean("王五", 14, DateUtil.parse("2018-04-01"))//
);
@ -448,7 +448,7 @@ public class CollUtilTest {
private int age;
private Date createTime;
public TestBean(String name, int age) {
public TestBean(final String name, final int age) {
this.name = name;
this.age = age;
}
@ -456,8 +456,8 @@ public class CollUtilTest {
@Test
public void listTest() {
List<Object> list1 = CollUtil.list(false);
List<Object> list2 = CollUtil.list(true);
final List<Object> list1 = CollUtil.list(false);
final List<Object> list2 = CollUtil.list(true);
Assert.assertTrue(list1 instanceof ArrayList);
Assert.assertTrue(list2 instanceof LinkedList);
@ -465,28 +465,28 @@ public class CollUtilTest {
@Test
public void listTest2() {
List<String> list1 = CollUtil.list(false, "a", "b", "c");
List<String> list2 = CollUtil.list(true, "a", "b", "c");
final List<String> list1 = CollUtil.list(false, "a", "b", "c");
final List<String> list2 = CollUtil.list(true, "a", "b", "c");
Assert.assertEquals("[a, b, c]", list1.toString());
Assert.assertEquals("[a, b, c]", list2.toString());
}
@Test
public void listTest3() {
HashSet<String> set = new LinkedHashSet<>();
final HashSet<String> set = new LinkedHashSet<>();
set.add("a");
set.add("b");
set.add("c");
List<String> list1 = CollUtil.list(false, set);
List<String> list2 = CollUtil.list(true, set);
final List<String> list1 = CollUtil.list(false, set);
final List<String> list2 = CollUtil.list(true, set);
Assert.assertEquals("[a, b, c]", list1.toString());
Assert.assertEquals("[a, b, c]", list2.toString());
}
@Test
public void getTest() {
HashSet<String> set = CollUtil.set(true, "A", "B", "C", "D");
final HashSet<String> set = CollUtil.set(true, "A", "B", "C", "D");
String str = CollUtil.get(set, 2);
Assert.assertEquals("C", str);
@ -496,10 +496,10 @@ public class CollUtilTest {
@Test
public void addAllIfNotContainsTest() {
ArrayList<String> list1 = new ArrayList<>();
final ArrayList<String> list1 = new ArrayList<>();
list1.add("1");
list1.add("2");
ArrayList<String> list2 = new ArrayList<>();
final ArrayList<String> list2 = new ArrayList<>();
list2.add("2");
list2.add("3");
CollUtil.addAllIfNotContains(list1, list2);
@ -687,45 +687,45 @@ public class CollUtilTest {
@Test
public void sortPageAllTest() {
List<Integer> list = CollUtil.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9);
List<Integer> sortPageAll = CollUtil.sortPageAll(1, 5, Comparator.reverseOrder(), list);
final List<Integer> list = CollUtil.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9);
final List<Integer> sortPageAll = CollUtil.sortPageAll(1, 5, Comparator.reverseOrder(), list);
Assert.assertEquals(CollUtil.newArrayList(4, 3, 2, 1), sortPageAll);
}
@Test
public void containsAnyTest() {
ArrayList<Integer> list1 = CollUtil.newArrayList(1, 2, 3, 4, 5);
ArrayList<Integer> list2 = CollUtil.newArrayList(5, 3, 1, 9, 11);
final ArrayList<Integer> list1 = CollUtil.newArrayList(1, 2, 3, 4, 5);
final ArrayList<Integer> list2 = CollUtil.newArrayList(5, 3, 1, 9, 11);
Assert.assertTrue(CollUtil.containsAny(list1, list2));
}
@Test
public void containsAllTest() {
ArrayList<Integer> list1 = CollUtil.newArrayList(1, 2, 3, 4, 5);
ArrayList<Integer> list2 = CollUtil.newArrayList(5, 3, 1);
final ArrayList<Integer> list1 = CollUtil.newArrayList(1, 2, 3, 4, 5);
final ArrayList<Integer> list2 = CollUtil.newArrayList(5, 3, 1);
Assert.assertTrue(CollUtil.containsAll(list1, list2));
ArrayList<Integer> list3 = CollUtil.newArrayList(1);
ArrayList<Integer> list4 = CollUtil.newArrayList();
final ArrayList<Integer> list3 = CollUtil.newArrayList(1);
final ArrayList<Integer> list4 = CollUtil.newArrayList();
Assert.assertTrue(CollUtil.containsAll(list3, list4));
}
@Test
public void getLastTest() {
// 测试：空数组返回null而不是报错
List<String> test = CollUtil.newArrayList();
String last = CollUtil.getLast(test);
final List<String> test = CollUtil.newArrayList();
final String last = CollUtil.getLast(test);
Assert.assertNull(last);
}
@Test
public void zipTest() {
Collection<String> keys = CollUtil.newArrayList("a", "b", "c", "d");
Collection<Integer> values = CollUtil.newArrayList(1, 2, 3, 4);
final Collection<String> keys = CollUtil.newArrayList("a", "b", "c", "d");
final Collection<Integer> values = CollUtil.newArrayList(1, 2, 3, 4);
Map<String, Integer> map = CollUtil.zip(keys, values);
final Map<String, Integer> map = CollUtil.zip(keys, values);
Assert.assertEquals(4, Objects.requireNonNull(map).size());
@ -737,7 +737,7 @@ public class CollUtilTest {
@Test
public void toMapTest() {
Collection<String> keys = CollUtil.newArrayList("a", "b", "c", "d");
final Collection<String> keys = CollUtil.newArrayList("a", "b", "c", "d");
final Map<String, String> map = CollUtil.toMap(keys, new HashMap<>(), (value) -> "key" + value);
Assert.assertEquals("a", map.get("keya"));
Assert.assertEquals("b", map.get("keyb"));
@ -764,8 +764,8 @@ public class CollUtilTest {
@Test
public void countMapTest() {
ArrayList<String> list = CollUtil.newArrayList("a", "b", "c", "c", "a", "b", "d");
Map<String, Integer> countMap = CollUtil.countMap(list);
final ArrayList<String> list = CollUtil.newArrayList("a", "b", "c", "c", "a", "b", "d");
final Map<String, Integer> countMap = CollUtil.countMap(list);
Assert.assertEquals(Integer.valueOf(2), countMap.get("a"));
Assert.assertEquals(Integer.valueOf(2), countMap.get("b"));
@ -775,7 +775,7 @@ public class CollUtilTest {
@Test
public void indexOfTest() {
ArrayList<String> list = CollUtil.newArrayList("a", "b", "c", "c", "a", "b", "d");
final ArrayList<String> list = CollUtil.newArrayList("a", "b", "c", "c", "a", "b", "d");
final int i = CollUtil.indexOf(list, (str) -> str.charAt(0) == 'c');
Assert.assertEquals(2, i);
}
@ -783,14 +783,14 @@ public class CollUtilTest {
@Test
public void lastIndexOfTest() {
// List有优化
ArrayList<String> list = CollUtil.newArrayList("a", "b", "c", "c", "a", "b", "d");
final ArrayList<String> list = CollUtil.newArrayList("a", "b", "c", "c", "a", "b", "d");
final int i = CollUtil.lastIndexOf(list, (str) -> str.charAt(0) == 'c');
Assert.assertEquals(3, i);
}
@Test
public void lastIndexOfSetTest() {
Set<String> list = CollUtil.set(true, "a", "b", "c", "c", "a", "b", "d");
final Set<String> list = CollUtil.set(true, "a", "b", "c", "c", "a", "b", "d");
// 去重后c排第三
final int i = CollUtil.lastIndexOf(list, (str) -> str.charAt(0) == 'c');
Assert.assertEquals(2, i);
@ -798,7 +798,7 @@ public class CollUtilTest {
@Test
public void pageTest() {
List<Dict> objects = CollUtil.newArrayList();
final List<Dict> objects = CollUtil.newArrayList();
for (int i = 0; i < 10; i++) {
objects.add(Dict.create().set("name", "姓名：" + i));
}
@ -808,10 +808,10 @@ public class CollUtilTest {
@Test
public void subtractToListTest() {
List<Long> list1 = Arrays.asList(1L, 2L, 3L);
List<Long> list2 = Arrays.asList(2L, 3L);
final List<Long> list1 = Arrays.asList(1L, 2L, 3L);
final List<Long> list2 = Arrays.asList(2L, 3L);
List<Long> result = CollUtil.subtractToList(list1, list2);
final List<Long> result = CollUtil.subtractToList(list1, list2);
Assert.assertEquals(1, result.size());
Assert.assertEquals(1L, result.get(0), 1);
}
@ -826,7 +826,7 @@ public class CollUtilTest {
@Test
public void setValueByMapTest(){
// https://gitee.com/dromara/hutool/pulls/482
List<Person> people = Arrays.asList(
final List<Person> people = Arrays.asList(
new Person("aa", 12, "man", 1),
new Person("bb", 13, "woman", 2),
new Person("cc", 14, "man", 3),
@ -835,7 +835,7 @@ public class CollUtilTest {
new Person("ff", 17, "man", 6)
);
Map<Integer, String> genderMap = new HashMap<>();
final Map<Integer, String> genderMap = new HashMap<>();
genderMap.put(1, null);
genderMap.put(2, "妇女");
genderMap.put(3, "少女");
@ -847,7 +847,7 @@ public class CollUtilTest {
CollUtil.setValueByMap(people, genderMap, Person::getId, Person::setGender);
Assert.assertEquals(people.get(1).getGender(), "妇女");
Map<Integer, Person> personMap = new HashMap<>();
final Map<Integer, Person> personMap = new HashMap<>();
personMap.put(1, new Person("AA", 21, "男", 1));
personMap.put(2, new Person("BB", 7, "小孩", 2));
personMap.put(3, new Person("CC", 65, "老人", 3));
@ -872,7 +872,7 @@ public class CollUtilTest {
@Test
public void distinctByFunctionTest(){
List<Person> people = Arrays.asList(
final List<Person> people = Arrays.asList(
new Person("aa", 12, "man", 1),
new Person("bb", 13, "woman", 2),
new Person("cc", 14, "man", 3),
@ -896,50 +896,50 @@ public class CollUtilTest {
@Test
public void unionNullTest() {
List<String> list1 = new ArrayList<>();
List<String> list2 = null;
List<String> list3 = null;
Collection<String> union = CollUtil.union(list1, list2, list3);
final List<String> list1 = new ArrayList<>();
final List<String> list2 = null;
final List<String> list3 = null;
final Collection<String> union = CollUtil.union(list1, list2, list3);
Assert.assertNotNull(union);
}
@Test
public void unionDistinctNullTest() {
List<String> list1 = new ArrayList<>();
List<String> list2 = null;
List<String> list3 = null;
Set<String> set = CollUtil.unionDistinct(list1, list2, list3);
final List<String> list1 = new ArrayList<>();
final List<String> list2 = null;
final List<String> list3 = null;
final Set<String> set = CollUtil.unionDistinct(list1, list2, list3);
Assert.assertNotNull(set);
}
@Test
public void unionAllNullTest() {
List<String> list1 = new ArrayList<>();
List<String> list2 = null;
List<String> list3 = null;
List<String> list = CollUtil.unionAll(list1, list2, list3);
final List<String> list1 = new ArrayList<>();
final List<String> list2 = null;
final List<String> list3 = null;
final List<String> list = CollUtil.unionAll(list1, list2, list3);
Assert.assertNotNull(list);
}
@Test
public void intersectionNullTest() {
List<String> list1 = new ArrayList<>();
final List<String> list1 = new ArrayList<>();
list1.add("aa");
List<String> list2 = new ArrayList<>();
final List<String> list2 = new ArrayList<>();
list2.add("aa");
List<String> list3 = null;
Collection<String> collection = CollUtil.intersection(list1, list2, list3);
final List<String> list3 = null;
final Collection<String> collection = CollUtil.intersection(list1, list2, list3);
Assert.assertNotNull(collection);
}
@Test
public void intersectionDistinctNullTest() {
List<String> list1 = new ArrayList<>();
final List<String> list1 = new ArrayList<>();
list1.add("aa");
List<String> list2 = null;
final List<String> list2 = null;
// list2.add("aa");
List<String> list3 = null;
Collection<String> collection = CollUtil.intersectionDistinct(list1, list2, list3);
final List<String> list3 = null;
final Collection<String> collection = CollUtil.intersectionDistinct(list1, list2, list3);
Assert.assertNotNull(collection);
}