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