ZhouXY108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-04-19 03:01:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

add BoundedCollection

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

39
hutool-core/src/main/java/org/dromara/hutool/core/collection/BoundedCollection.java Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright (c) 2024. looly(loolly@aliyun.com)
* Hutool is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
* https://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
package org.dromara.hutool.core.collection;
import java.util.Collection;
/**
* 有边界限制的集合，边界集合有最大容量限制
*
* @param <E> 元素类型
* @since 6.0.0
*/
public interface BoundedCollection<E> extends Collection<E> {
/**
* 是否已满，如果集合已满，不允许新增元素
*
* @return 是否已满
*/
boolean isFull();
/**
* 获取集合最大允许容量
*
* @return 容量
*/
int maxSize();
}

90
hutool-core/src/main/java/org/dromara/hutool/core/collection/BoundedList.java Normal file
View File

@ -0,0 +1,90 @@
/*
* Copyright (c) 2024. looly(loolly@aliyun.com)
* Hutool is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
* https://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
package org.dromara.hutool.core.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
/**
* 指定边界大小的List<br>
* 通过指定边界，可以限制List的最大容量
*
* @param <E> 元素类型
* @author Looly
* @since 6.0.0
*/
public class BoundedList<E> extends ListWrapper<E> implements BoundedCollection<E> {
private final int maxSize;
/**
* 构造
*
* @param maxSize 最大容量
*/
public BoundedList(final int maxSize) {
this(new ArrayList<>(maxSize), maxSize);
}
/**
* 构造，限制集合的最大容量为提供的List
*
* @param raw 原始对象
* @param maxSize 最大容量
*/
public BoundedList(final List<E> raw, final int maxSize) {
super(raw);
this.maxSize = maxSize;
}
@Override
public boolean isFull() {
return size() == this.maxSize;
}
@Override
public int maxSize() {
return this.maxSize;
}
@Override
public boolean add(final E e) {
checkFull(1);
return super.add(e);
}
@Override
public void add(final int index, final E element) {
checkFull(1);
super.add(index, element);
}
@Override
public boolean addAll(final Collection<? extends E> c) {
checkFull(c.size());
return super.addAll(c);
}
@Override
public boolean addAll(final int index, final Collection<? extends E> c) {
checkFull(c.size());
return super.addAll(index, c);
}
private void checkFull(final int addSize) {
if (size() + addSize > this.maxSize) {
throw new IndexOutOfBoundsException("List is no space to add " + addSize + " elements!");
}
}
}

45
hutool-core/src/main/java/org/dromara/hutool/core/collection/CollUtil.java
View File

@ -2304,6 +2304,25 @@ public class CollUtil {
}
}
/**
* 判断subCollection是否为collection的子集合，不考虑顺序，只考虑元素数量。
* <ul>
* <li>如果两个集合为同一集合或，则返回true</li>
* <li>如果两个集合元素都相同，则返回true（无论顺序相同与否）</li>
* </ul>
*
* @param subCollection 第一个Iterable对象，即子集合。
* @param collection 第二个Iterable对象，可以为任何实现了Iterable接口的集合。
* @return 如果subCollection是collection的子集合，则返回true；否则返回false。
* @since 6.0.0
*/
public static boolean isSub(final Collection<?> subCollection, final Collection<?> collection) {
if(size(subCollection) > size(collection)){
return false;
}
return IterUtil.isSub(subCollection, collection);
}
/**
* 判断两个{@link Collection} 是否元素和顺序相同，返回{@code true}的条件是：
* <ul>
@ -2318,14 +2337,30 @@ public class CollUtil {
* @since 5.6.0
*/
public static boolean isEqualList(final Collection<?> list1, final Collection<?> list2) {
if (list1 == list2) {
return true;
}
if (list1 == null || list2 == null || list1.size() != list2.size()) {
return equals(list1, list2, false);
}
/**
* 判断两个{@link Iterable}中的元素是否相同，可选是否判断顺序
* 当满足下列情况时返回{@code true}：
* <ul>
* <li>两个{@link Iterable}都为{@code null}；</li>
* <li>两个{@link Iterable}满足{@code coll1 == coll2}；</li>
* <li>如果忽略顺序，则计算两个集合中元素和数量是否相同</li>
* <li>如果不忽略顺序，两个{@link Iterable}所有具有相同下标的元素皆满足{@link Objects#equals(Object, Object)}；</li>
* </ul>
*
* @param coll1 集合1
* @param coll2 集合2
* @param ignoreOrder 是否忽略顺序
* @return 是否相同
*/
public static boolean equals(final Collection<?> coll1, final Collection<?> coll2, final boolean ignoreOrder) {
if(size(coll1) != size(coll2)){
return false;
}
return IterUtil.isEqualList(list1, list2);
return IterUtil.equals(coll1, coll2, ignoreOrder);
}
/**

190
hutool-core/src/main/java/org/dromara/hutool/core/collection/ListWrapper.java Normal file
View File

@ -0,0 +1,190 @@
/*
* Copyright (c) 2024. looly(loolly@aliyun.com)
* Hutool is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
* https://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
package org.dromara.hutool.core.collection;
import org.dromara.hutool.core.lang.wrapper.SimpleWrapper;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
import java.util.stream.Stream;
/**
* 列表包装类<br>
* 提供列表包装，用于在执行列表方法前后自定义处理逻辑
*
* @param <E> 元素类型
*/
public class ListWrapper<E> extends SimpleWrapper<List<E>> implements List<E> {
/**
* 构造
*
* @param raw 原始对象
*/
public ListWrapper(final List<E> raw) {
super(raw);
}
@Override
public int size() {
return raw.size();
}
@Override
public boolean isEmpty() {
return raw.isEmpty();
}
@Override
public boolean contains(final Object o) {
return raw.contains(o);
}
@Override
public Iterator<E> iterator() {
return raw.iterator();
}
@Override
public void forEach(final Consumer<? super E> action) {
raw.forEach(action);
}
@Override
public Object[] toArray() {
return raw.toArray();
}
@Override
public <T> T[] toArray(final T[] a) {
return raw.toArray(a);
}
@Override
public boolean add(final E e) {
return raw.add(e);
}
@Override
public boolean remove(final Object o) {
return raw.remove(o);
}
@SuppressWarnings("SlowListContainsAll")
@Override
public boolean containsAll(final Collection<?> c) {
return raw.containsAll(c);
}
@Override
public boolean addAll(final Collection<? extends E> c) {
return raw.addAll(c);
}
@Override
public boolean addAll(final int index, final Collection<? extends E> c) {
return raw.addAll(index, c);
}
@Override
public boolean removeAll(final Collection<?> c) {
return raw.removeAll(c);
}
@Override
public boolean removeIf(final Predicate<? super E> filter) {
return raw.removeIf(filter);
}
@Override
public boolean retainAll(final Collection<?> c) {
return raw.retainAll(c);
}
@Override
public void replaceAll(final UnaryOperator<E> operator) {
raw.replaceAll(operator);
}
@Override
public void sort(final Comparator<? super E> c) {
raw.sort(c);
}
@Override
public void clear() {
raw.clear();
}
@Override
public E get(final int index) {
return raw.get(index);
}
@Override
public E set(final int index, final E element) {
return raw.set(index, element);
}
@Override
public void add(final int index, final E element) {
raw.add(index, element);
}
@Override
public E remove(final int index) {
return raw.remove(index);
}
@Override
public int indexOf(final Object o) {
return raw.indexOf(o);
}
@Override
public int lastIndexOf(final Object o) {
return raw.lastIndexOf(o);
}
@Override
public ListIterator<E> listIterator() {
return raw.listIterator();
}
@Override
public ListIterator<E> listIterator(final int index) {
return raw.listIterator(index);
}
@Override
public List<E> subList(final int fromIndex, final int toIndex) {
return raw.subList(fromIndex, toIndex);
}
@Override
public Spliterator<E> spliterator() {
return raw.spliterator();
}
@Override
public Stream<E> stream() {
return raw.stream();
}
@Override
public Stream<E> parallelStream() {
return raw.parallelStream();
}
}

100
hutool-core/src/main/java/org/dromara/hutool/core/collection/iter/IterUtil.java
View File

@ -17,6 +17,7 @@ import org.dromara.hutool.core.collection.CollUtil;
import org.dromara.hutool.core.collection.ListUtil;
import org.dromara.hutool.core.lang.Assert;
import org.dromara.hutool.core.map.MapUtil;
import org.dromara.hutool.core.math.NumberUtil;
import org.dromara.hutool.core.reflect.FieldUtil;
import org.dromara.hutool.core.reflect.method.MethodUtil;
import org.dromara.hutool.core.text.StrJoiner;
@ -745,6 +746,44 @@ public class IterUtil {
return size;
}
/**
* 判断subIter是否为iter的子集合，不考虑顺序，只考虑元素数量。<br>
* <ul>
* <li>如果两个集合为同一集合或，则返回true</li>
* <li>如果两个集合元素都相同，则返回true（无论顺序相同与否）</li>
* </ul>
*
* @param subIter 第一个Iterable对象，即子集合。
* @param iter 第二个Iterable对象，可以为任何实现了Iterable接口的集合。
* @return 如果subIter是iter的子集合，则返回true；否则返回false。
* @since 6.0.0
*/
public static boolean isSub(final Iterable<?> subIter, final Iterable<?> iter) {
// 如果两个Iterable对象引用相同，则肯定是一个的子集合
if (subIter == iter) {
return true;
}
// 如果有任何一个Iterable对象为null，则不是子集合关系
if (subIter == null || iter == null) {
return false;
}
// 使用Map记录每个Iterable中每个元素出现的次数
final Map<?, Integer> countMap1 = countMap(subIter.iterator());
final Map<?, Integer> countMap2 = countMap(iter.iterator());
// 遍历第一个Iterable中的每个元素
for (final Object obj : subIter) {
// 比较第一个Iterable中元素的出现次数和第二个Iterable中元素的出现次数
// 如果第一个Iterable中元素的出现次数大于第二个Iterable中元素的出现次数，则不是子集合关系
if (NumberUtil.nullToZero(countMap1.get(obj)) > NumberUtil.nullToZero(countMap2.get(obj))) {
return false;
}
}
// 如果所有元素的出现次数比较都满足子集合关系，则返回true
return true;
}
/**
* <p>判断两个{@link Iterable}中的元素与其顺序是否相同 <br>
* 当满足下列情况时返回{@code true}：
@ -761,25 +800,66 @@ public class IterUtil {
* @since 5.6.0
*/
public static boolean isEqualList(final Iterable<?> iterable1, final Iterable<?> iterable2) {
return equals(iterable1, iterable2, false);
}
/**
* 判断两个{@link Iterable}中的元素是否相同，可选是否判断顺序
* 当满足下列情况时返回{@code true}：
* <ul>
* <li>两个{@link Iterable}都为{@code null}；</li>
* <li>两个{@link Iterable}满足{@code iterable1 == iterable2}；</li>
* <li>如果忽略顺序，则计算两个集合中元素和数量是否相同</li>
* <li>如果不忽略顺序，两个{@link Iterable}所有具有相同下标的元素皆满足{@link Objects#equals(Object, Object)}；</li>
* </ul>
*
* @param iterable1 集合1
* @param iterable2 集合2
* @param ignoreOrder 是否忽略顺序
* @return 是否相同
*/
public static boolean equals(final Iterable<?> iterable1, final Iterable<?> iterable2, final boolean ignoreOrder) {
// 如果两个Iterable对象引用相同，则肯定相等
if (iterable1 == iterable2) {
return true;
}
// 如果有任何一个Iterable对象为null，则不是子集合关系
if (iterable1 == null || iterable2 == null) {
return false;
}
final Iterator<?> iter1 = iterable1.iterator();
final Iterator<?> iter2 = iterable2.iterator();
Object obj1;
Object obj2;
while (iter1.hasNext() && iter2.hasNext()) {
obj1 = iter1.next();
obj2 = iter2.next();
if (!Objects.equals(obj1, obj2)) {
if(ignoreOrder){
final Map<?, Integer> countMap1 = countMap(iterable1.iterator());
final Map<?, Integer> countMap2 = countMap(iterable2.iterator());
if(countMap1.size() != countMap2.size()){
// 如果两个Iterable中元素种类不同，则肯定不等
return false;
}
for (final Object obj : iterable1) {
// 比较第一个Iterable中元素的出现次数和第二个Iterable中元素的出现次数
if (NumberUtil.nullToZero(countMap1.get(obj)) != NumberUtil.nullToZero(countMap2.get(obj))) {
return false;
}
}
// 如果所有元素的出现次数比较都满足子集合关系，则返回true
return true;
} else{
final Iterator<?> iter1 = iterable1.iterator();
final Iterator<?> iter2 = iterable2.iterator();
Object obj1;
Object obj2;
while (iter1.hasNext() && iter2.hasNext()) {
obj1 = iter1.next();
obj2 = iter2.next();
if (!Objects.equals(obj1, obj2)) {
return false;
}
}
// 当两个Iterable长度不一致时返回false
return !(iter1.hasNext() || iter2.hasNext());
}
// 当两个Iterable长度不一致时返回false
return !(iter1.hasNext() || iter2.hasNext());
}
/**

26
hutool-core/src/main/java/org/dromara/hutool/core/collection/queue/BoundedPriorityQueue.java
View File

@ -12,11 +12,9 @@
package org.dromara.hutool.core.collection.queue;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
import java.util.PriorityQueue;
import org.dromara.hutool.core.collection.BoundedCollection;
import java.util.*;
/**
* 有界优先队列<br>
@ -25,13 +23,17 @@ import java.util.PriorityQueue;
*
* @param <E> 成员类型
*/
public class BoundedPriorityQueue<E> extends PriorityQueue<E>{
public class BoundedPriorityQueue<E> extends PriorityQueue<E> implements BoundedCollection<E> {
private static final long serialVersionUID = 3794348988671694820L;
//容量
private final int capacity;
private final Comparator<? super E> comparator;
/**
* 构造
* @param capacity 容量
*/
public BoundedPriorityQueue(final int capacity) {
this(capacity, null);
}
@ -57,6 +59,16 @@ public class BoundedPriorityQueue<E> extends PriorityQueue<E>{
this.comparator = comparator;
}
@Override
public boolean isFull() {
return size() == capacity;
}
@Override
public int maxSize() {
return capacity;
}
/**
* 加入元素，当队列满时，淘汰末尾元素
* @param e 元素
@ -64,7 +76,7 @@ public class BoundedPriorityQueue<E> extends PriorityQueue<E>{
*/
@Override
public boolean offer(final E e) {
if(size() >= capacity) {
if(isFull()) {
final E head = peek();
if (this.comparator().compare(e, head) <= 0){
return true;

4
hutool-core/src/main/java/org/dromara/hutool/core/lang/selector/Selector.java
View File

@ -13,12 +13,14 @@
package org.dromara.hutool.core.lang.selector;
/**
* 选择器接口
* 选择器接口<br>
* 用于抽象负载均衡策略中的选择方式
*
* @param <T> 选择对象类型
* @author looly
* @since 6.0.0
*/
@FunctionalInterface
public interface Selector<T> {
/**

3
hutool-core/src/main/java/org/dromara/hutool/core/lang/selector/package-info.java
View File

@ -13,6 +13,9 @@
/**
* 选择器相关封装，包括：
* <ul>
* <li>{@link org.dromara.hutool.core.lang.selector.IncrementSelector}</li>
* <li>{@link org.dromara.hutool.core.lang.selector.RandomSelector}</li>
* <li>{@link org.dromara.hutool.core.lang.selector.SmoothWeightSelector}</li>
* <li>{@link org.dromara.hutool.core.lang.selector.WeightRandomSelector}</li>
* </ul>
*

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

@ -27,6 +27,9 @@ import org.junit.jupiter.api.Test;
import java.util.*;
import java.util.function.Function;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* 集合工具类单元测试
*
@ -50,16 +53,16 @@ public class CollUtilTest {
@Test
public void hasNullTest() {
List<Object> list = null;
Assertions.assertTrue(CollUtil.hasNull(list));
assertTrue(CollUtil.hasNull(list));
list = ListUtil.of();
Assertions.assertFalse(CollUtil.hasNull(list));
assertFalse(CollUtil.hasNull(list));
list = ListUtil.of("");
Assertions.assertFalse(CollUtil.hasNull(list));
assertFalse(CollUtil.hasNull(list));
list = ListUtil.of("", null);
Assertions.assertTrue(CollUtil.hasNull(list));
assertTrue(CollUtil.hasNull(list));
}
@Test
@ -80,8 +83,8 @@ public class CollUtilTest {
@Test
public void testPredicateContains() {
final List<String> list = ListUtil.of("bbbbb", "aaaaa", "ccccc");
Assertions.assertTrue(CollUtil.contains(list, s -> s.startsWith("a")));
Assertions.assertFalse(CollUtil.contains(list, s -> s.startsWith("d")));
assertTrue(CollUtil.contains(list, s -> s.startsWith("a")));
assertFalse(CollUtil.contains(list, s -> s.startsWith("d")));
}
@Test
@ -131,7 +134,7 @@ public class CollUtilTest {
@SuppressWarnings("ConstantValue")
@Test
public void isNotEmptyTest() {
Assertions.assertFalse(CollUtil.isNotEmpty((Collection<?>) null));
assertFalse(CollUtil.isNotEmpty((Collection<?>) null));
}
@Test
@ -171,7 +174,7 @@ public class CollUtilTest {
final Collection<String> intersectionDistinct2 = CollUtil.intersectionDistinct(list1, list2, list3);
Console.log(intersectionDistinct2);
Assertions.assertTrue(intersectionDistinct2.isEmpty());
assertTrue(intersectionDistinct2.isEmpty());
}
@Test
@ -180,14 +183,14 @@ public class CollUtilTest {
final List<String> list2 = ListUtil.of("a", "b", "b", "b", "c", "d", "x2");
final Collection<String> disjunction = CollUtil.disjunction(list1, list2);
Assertions.assertTrue(disjunction.contains("b"));
Assertions.assertTrue(disjunction.contains("x2"));
Assertions.assertTrue(disjunction.contains("x"));
assertTrue(disjunction.contains("b"));
assertTrue(disjunction.contains("x2"));
assertTrue(disjunction.contains("x"));
final Collection<String> disjunction2 = CollUtil.disjunction(list2, list1);
Assertions.assertTrue(disjunction2.contains("b"));
Assertions.assertTrue(disjunction2.contains("x2"));
Assertions.assertTrue(disjunction2.contains("x"));
assertTrue(disjunction2.contains("b"));
assertTrue(disjunction2.contains("x2"));
assertTrue(disjunction2.contains("x"));
}
@Test
@ -209,19 +212,19 @@ public class CollUtilTest {
final List<String> list2 = ListUtil.of("a", "b", "c");
final Collection<String> disjunction = CollUtil.disjunction(list1, list2);
Assertions.assertTrue(disjunction.contains("1"));
Assertions.assertTrue(disjunction.contains("2"));
Assertions.assertTrue(disjunction.contains("3"));
Assertions.assertTrue(disjunction.contains("a"));
Assertions.assertTrue(disjunction.contains("b"));
Assertions.assertTrue(disjunction.contains("c"));
assertTrue(disjunction.contains("1"));
assertTrue(disjunction.contains("2"));
assertTrue(disjunction.contains("3"));
assertTrue(disjunction.contains("a"));
assertTrue(disjunction.contains("b"));
assertTrue(disjunction.contains("c"));
final Collection<String> disjunction2 = CollUtil.disjunction(list2, list1);
Assertions.assertTrue(disjunction2.contains("1"));
Assertions.assertTrue(disjunction2.contains("2"));
Assertions.assertTrue(disjunction2.contains("3"));
Assertions.assertTrue(disjunction2.contains("a"));
Assertions.assertTrue(disjunction2.contains("b"));
Assertions.assertTrue(disjunction2.contains("c"));
assertTrue(disjunction2.contains("1"));
assertTrue(disjunction2.contains("2"));
assertTrue(disjunction2.contains("3"));
assertTrue(disjunction2.contains("a"));
assertTrue(disjunction2.contains("b"));
assertTrue(disjunction2.contains("c"));
}
@Test
@ -408,7 +411,7 @@ public class CollUtilTest {
public void groupTest() {
final List<String> list = ListUtil.of("1", "2", "3", "4", "5", "6");
final List<List<String>> group = CollUtil.group(list, null);
Assertions.assertFalse(group.isEmpty());
assertFalse(group.isEmpty());
final List<List<String>> group2 = CollUtil.group(list, t -> {
// 按照奇数偶数分类
@ -625,7 +628,7 @@ public class CollUtilTest {
// Act
final List<Integer> retval = CollUtil.sub(list, start, end, step);
// Assert result
Assertions.assertTrue(retval.isEmpty());
assertTrue(retval.isEmpty());
}
@Test
@ -684,7 +687,7 @@ public class CollUtilTest {
// Act
final List<Integer> retval = CollUtil.sub(list, start, end, step);
// Assert result
Assertions.assertTrue(retval.isEmpty());
assertTrue(retval.isEmpty());
}
@Test
@ -741,7 +744,7 @@ public class CollUtilTest {
// Act
final List<Integer> retval = CollUtil.sub(list, start, end);
// Assert result
Assertions.assertTrue(retval.isEmpty());
assertTrue(retval.isEmpty());
}
@Test
@ -757,18 +760,18 @@ public class CollUtilTest {
final List<Integer> list1 = ListUtil.of(1, 2, 3, 4, 5);
final List<Integer> list2 = ListUtil.of(5, 3, 1, 9, 11);
Assertions.assertTrue(CollUtil.containsAny(list1, list2));
assertTrue(CollUtil.containsAny(list1, list2));
}
@Test
public void containsAllTest() {
final List<Integer> list1 = ListUtil.of(1, 2, 3, 4, 5);
final List<Integer> list2 = ListUtil.of(5, 3, 1);
Assertions.assertTrue(CollUtil.containsAll(list1, list2));
assertTrue(CollUtil.containsAll(list1, list2));
final List<Integer> list3 = ListUtil.of(1);
final List<Integer> list4 = ListUtil.of();
Assertions.assertTrue(CollUtil.containsAll(list3, list4));
assertTrue(CollUtil.containsAll(list3, list4));
}
@Test
@ -1069,18 +1072,18 @@ public class CollUtilTest {
@Test
public void addIfAbsentTest() {
// 为false的情况
Assertions.assertFalse(CollUtil.addIfAbsent(null, null));
Assertions.assertFalse(CollUtil.addIfAbsent(ListUtil.of(), null));
Assertions.assertFalse(CollUtil.addIfAbsent(null, "123"));
Assertions.assertFalse(CollUtil.addIfAbsent(ListUtil.of("123"), "123"));
Assertions.assertFalse(CollUtil.addIfAbsent(ListUtil.of(new Animal("jack", 20)),
assertFalse(CollUtil.addIfAbsent(null, null));
assertFalse(CollUtil.addIfAbsent(ListUtil.of(), null));
assertFalse(CollUtil.addIfAbsent(null, "123"));
assertFalse(CollUtil.addIfAbsent(ListUtil.of("123"), "123"));
assertFalse(CollUtil.addIfAbsent(ListUtil.of(new Animal("jack", 20)),
new Animal("jack", 20)));
// 正常情况
Assertions.assertTrue(CollUtil.addIfAbsent(ListUtil.of("456"), "123"));
Assertions.assertTrue(CollUtil.addIfAbsent(ListUtil.of(new Animal("jack", 20)),
assertTrue(CollUtil.addIfAbsent(ListUtil.of("456"), "123"));
assertTrue(CollUtil.addIfAbsent(ListUtil.of(new Animal("jack", 20)),
new Dog("jack", 20)));
Assertions.assertTrue(CollUtil.addIfAbsent(ListUtil.of(new Animal("jack", 20)),
assertTrue(CollUtil.addIfAbsent(ListUtil.of(new Animal("jack", 20)),
new Animal("tom", 20)));
}
@ -1155,24 +1158,24 @@ public class CollUtilTest {
@Test
public void isEqualListTest() {
final List<Integer> list = ListUtil.of(1, 2, 3, 4);
Assertions.assertTrue(CollUtil.isEqualList(null, null));
Assertions.assertTrue(CollUtil.isEqualList(ListUtil.of(), ListUtil.of()));
Assertions.assertTrue(CollUtil.isEqualList(list, list));
Assertions.assertTrue(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3, 4)));
assertTrue(CollUtil.isEqualList(null, null));
assertTrue(CollUtil.isEqualList(ListUtil.of(), ListUtil.of()));
assertTrue(CollUtil.isEqualList(list, list));
assertTrue(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3, 4)));
Assertions.assertFalse(CollUtil.isEqualList(null, ListUtil.of()));
Assertions.assertFalse(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3, 3)));
Assertions.assertFalse(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3)));
Assertions.assertFalse(CollUtil.isEqualList(list, ListUtil.of(4, 3, 2, 1)));
assertFalse(CollUtil.isEqualList(null, ListUtil.of()));
assertFalse(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3, 3)));
assertFalse(CollUtil.isEqualList(list, ListUtil.of(1, 2, 3)));
assertFalse(CollUtil.isEqualList(list, ListUtil.of(4, 3, 2, 1)));
}
@Test
public void testMatch() {
final List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
Assertions.assertTrue(CollUtil.anyMatch(list, i -> i == 1));
Assertions.assertFalse(CollUtil.anyMatch(list, i -> i > 6));
Assertions.assertFalse(CollUtil.allMatch(list, i -> i == 1));
Assertions.assertTrue(CollUtil.allMatch(list, i -> i <= 6));
assertTrue(CollUtil.anyMatch(list, i -> i == 1));
assertFalse(CollUtil.anyMatch(list, i -> i > 6));
assertFalse(CollUtil.allMatch(list, i -> i == 1));
assertTrue(CollUtil.allMatch(list, i -> i <= 6));
}
@Test
@ -1280,6 +1283,6 @@ public class CollUtilTest {
coll2.add("1");
coll2.add("1");
Assertions.assertTrue(CollUtil.containsAll(coll1, coll2));
assertTrue(CollUtil.containsAll(coll1, coll2));
}
}

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

@ -25,6 +25,8 @@ import org.w3c.dom.NodeList;
import java.util.*;
import java.util.function.Function;
import static org.junit.jupiter.api.Assertions.*;
/**
* test for {@link IterUtil}
*/
@ -33,7 +35,7 @@ public class IterUtilTest {
@Test
public void testGetIter() {
Assertions.assertNull(IterUtil.getIter(null));
Assertions.assertEquals(Collections.emptyIterator(), IterUtil.getIter(Collections.emptyList()));
assertEquals(Collections.emptyIterator(), IterUtil.getIter(Collections.emptyList()));
Assertions.assertNull(IterUtil.getIter((Object)null));
Assertions.assertNotNull(IterUtil.getIter(Collections.emptyIterator()));
@ -45,38 +47,38 @@ public class IterUtilTest {
@Test
public void testIsEmpty() {
Assertions.assertTrue(IterUtil.isEmpty(Collections.emptyIterator()));
Assertions.assertFalse(IterUtil.isEmpty(Arrays.asList(1, 2).iterator()));
assertTrue(IterUtil.isEmpty(Collections.emptyIterator()));
assertFalse(IterUtil.isEmpty(Arrays.asList(1, 2).iterator()));
Assertions.assertTrue(IterUtil.isEmpty(Collections.emptyList()));
Assertions.assertFalse(IterUtil.isEmpty(Arrays.asList(1, 2)));
assertTrue(IterUtil.isEmpty(Collections.emptyList()));
assertFalse(IterUtil.isEmpty(Arrays.asList(1, 2)));
}
@Test
public void testIsNotEmpty() {
Assertions.assertFalse(IterUtil.isNotEmpty(Collections.emptyIterator()));
Assertions.assertTrue(IterUtil.isNotEmpty(Arrays.asList(1, 2).iterator()));
assertFalse(IterUtil.isNotEmpty(Collections.emptyIterator()));
assertTrue(IterUtil.isNotEmpty(Arrays.asList(1, 2).iterator()));
Assertions.assertFalse(IterUtil.isNotEmpty(Collections.emptyList()));
Assertions.assertTrue(IterUtil.isNotEmpty(Arrays.asList(1, 2)));
assertFalse(IterUtil.isNotEmpty(Collections.emptyList()));
assertTrue(IterUtil.isNotEmpty(Arrays.asList(1, 2)));
}
@Test
public void testHasNull() {
Assertions.assertFalse(IterUtil.hasNull(Arrays.asList(1, 3, 2).iterator()));
Assertions.assertTrue(IterUtil.hasNull(Arrays.asList(1, null, 2).iterator()));
Assertions.assertFalse(IterUtil.hasNull(Collections.emptyIterator()));
Assertions.assertTrue(IterUtil.hasNull(null));
assertFalse(IterUtil.hasNull(Arrays.asList(1, 3, 2).iterator()));
assertTrue(IterUtil.hasNull(Arrays.asList(1, null, 2).iterator()));
assertFalse(IterUtil.hasNull(Collections.emptyIterator()));
assertTrue(IterUtil.hasNull(null));
}
@Test
public void testIsAllNull() {
Assertions.assertTrue(IterUtil.isAllNull(Arrays.asList(null, null)));
Assertions.assertFalse(IterUtil.isAllNull(Arrays.asList(1, null)));
Assertions.assertTrue(IterUtil.isAllNull((Iterable<?>)null));
Assertions.assertTrue(IterUtil.isAllNull(Arrays.asList(null, null).iterator()));
Assertions.assertFalse(IterUtil.isAllNull(Arrays.asList(1, null).iterator()));
Assertions.assertTrue(IterUtil.isAllNull((Iterator<?>)null));
assertTrue(IterUtil.isAllNull(Arrays.asList(null, null)));
assertFalse(IterUtil.isAllNull(Arrays.asList(1, null)));
assertTrue(IterUtil.isAllNull((Iterable<?>)null));
assertTrue(IterUtil.isAllNull(Arrays.asList(null, null).iterator()));
assertFalse(IterUtil.isAllNull(Arrays.asList(1, null).iterator()));
assertTrue(IterUtil.isAllNull((Iterator<?>)null));
}
@Test
@ -84,8 +86,8 @@ public class IterUtilTest {
final Object o1 = new Object();
final Object o2 = new Object();
final Map<Object, Integer> countMap = IterUtil.countMap(Arrays.asList(o1, o2, o1, o1).iterator());
Assertions.assertEquals((Integer)3, countMap.get(o1));
Assertions.assertEquals((Integer)1, countMap.get(o2));
assertEquals((Integer)3, countMap.get(o1));
assertEquals((Integer)1, countMap.get(o2));
}
@Test
@ -93,8 +95,8 @@ public class IterUtilTest {
final Bean bean1 = new Bean(1, "A");
final Bean bean2 = new Bean(2, "B");
final Map<Integer, Bean> map = IterUtil.fieldValueMap(Arrays.asList(bean1, bean2).iterator(), "id");
Assertions.assertEquals(bean1, map.get(1));
Assertions.assertEquals(bean2, map.get(2));
assertEquals(bean1, map.get(1));
assertEquals(bean2, map.get(2));
}
@Test
@ -104,16 +106,16 @@ public class IterUtilTest {
final Map<Integer, String> map = IterUtil.fieldValueAsMap(
Arrays.asList(bean1, bean2).iterator(), "id", "name"
);
Assertions.assertEquals("A", map.get(1));
Assertions.assertEquals("B", map.get(2));
assertEquals("A", map.get(1));
assertEquals("B", map.get(2));
}
@Test
public void testFieldValueList() {
final Bean bean1 = new Bean(1, "A");
final Bean bean2 = new Bean(2, "B");
Assertions.assertEquals(Arrays.asList(1, 2), IterUtil.fieldValueList(Arrays.asList(bean1, bean2), "id"));
Assertions.assertEquals(
assertEquals(Arrays.asList(1, 2), IterUtil.fieldValueList(Arrays.asList(bean1, bean2), "id"));
assertEquals(
Arrays.asList(1, 2),
IterUtil.fieldValueList(Arrays.asList(bean1, bean2).iterator(), "id")
);
@ -122,9 +124,9 @@ public class IterUtilTest {
@Test
public void testJoin() {
final List<String> stringList = Arrays.asList("1", "2", "3");
Assertions.assertEquals("123", IterUtil.join(stringList.iterator(), ""));
Assertions.assertEquals("-1--2--3-", IterUtil.join(stringList.iterator(), "", "-", "-"));
Assertions.assertEquals("123", IterUtil.join(stringList.iterator(), "", Function.identity()));
assertEquals("123", IterUtil.join(stringList.iterator(), ""));
assertEquals("-1--2--3-", IterUtil.join(stringList.iterator(), "", "-", "-"));
assertEquals("123", IterUtil.join(stringList.iterator(), "", Function.identity()));
}
@Test
@ -132,28 +134,28 @@ public class IterUtilTest {
final List<Integer> keys = Arrays.asList(1, 2, 3);
Map<Integer, Integer> map = IterUtil.toMap(keys, keys);
Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
Assertions.assertEquals(keys, new ArrayList<>(map.values()));
assertEquals(keys, new ArrayList<>(map.keySet()));
assertEquals(keys, new ArrayList<>(map.values()));
map = IterUtil.toMap(keys.iterator(), keys.iterator());
Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
Assertions.assertEquals(keys, new ArrayList<>(map.values()));
assertEquals(keys, new ArrayList<>(map.keySet()));
assertEquals(keys, new ArrayList<>(map.values()));
map = IterUtil.toMap(keys.iterator(), keys.iterator(), true);
Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
Assertions.assertEquals(keys, new ArrayList<>(map.values()));
assertEquals(keys, new ArrayList<>(map.keySet()));
assertEquals(keys, new ArrayList<>(map.values()));
map = IterUtil.toMap(keys, keys, true);
Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
Assertions.assertEquals(keys, new ArrayList<>(map.values()));
assertEquals(keys, new ArrayList<>(map.keySet()));
assertEquals(keys, new ArrayList<>(map.values()));
map = IterUtil.toMap(keys, Function.identity());
Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
Assertions.assertEquals(keys, new ArrayList<>(map.values()));
assertEquals(keys, new ArrayList<>(map.keySet()));
assertEquals(keys, new ArrayList<>(map.values()));
map = IterUtil.toMap(keys, Function.identity(), Function.identity());
Assertions.assertEquals(keys, new ArrayList<>(map.keySet()));
Assertions.assertEquals(keys, new ArrayList<>(map.values()));
assertEquals(keys, new ArrayList<>(map.keySet()));
assertEquals(keys, new ArrayList<>(map.values()));
}
@Test
@ -161,18 +163,18 @@ public class IterUtilTest {
final List<Integer> keys = Arrays.asList(1, 2, 3, 4);
Map<Boolean, List<Integer>> map = IterUtil.toListMap(keys, i -> (i & 1) == 0, Function.identity());
Assertions.assertEquals(Arrays.asList(2, 4), map.get(true));
Assertions.assertEquals(Arrays.asList(1, 3), map.get(false));
assertEquals(Arrays.asList(2, 4), map.get(true));
assertEquals(Arrays.asList(1, 3), map.get(false));
map = IterUtil.toListMap(keys, i -> (i & 1) == 0);
Assertions.assertEquals(Arrays.asList(2, 4), map.get(true));
Assertions.assertEquals(Arrays.asList(1, 3), map.get(false));
assertEquals(Arrays.asList(2, 4), map.get(true));
assertEquals(Arrays.asList(1, 3), map.get(false));
map = new LinkedHashMap<>();
final Map<Boolean, List<Integer>> rawMap = IterUtil.toListMap(map, keys, i -> (i & 1) == 0, Function.identity());
Assertions.assertSame(rawMap, map);
Assertions.assertEquals(Arrays.asList(2, 4), rawMap.get(true));
Assertions.assertEquals(Arrays.asList(1, 3), rawMap.get(false));
assertEquals(Arrays.asList(2, 4), rawMap.get(true));
assertEquals(Arrays.asList(1, 3), rawMap.get(false));
}
@Test
@ -183,38 +185,38 @@ public class IterUtilTest {
final Map<String, List<String>> testMap = IterUtil.toListMap(Arrays.asList("and", "brave", "back"),
v -> v.substring(0, 1));
Assertions.assertEquals(testMap, expectedMap);
assertEquals(testMap, expectedMap);
}
@SuppressWarnings("DataFlowIssue")
@Test
public void testAsIterable() {
final Iterator<Integer> iter = Arrays.asList(1, 2, 3).iterator();
Assertions.assertEquals(iter, IterUtil.asIterable(iter).iterator());
assertEquals(iter, IterUtil.asIterable(iter).iterator());
Assertions.assertNull(IterUtil.asIterable(null).iterator());
final Enumeration<Integer> enumeration = new IteratorEnumeration<>(iter);
final Iterator<Integer> iter2 = IterUtil.asIterator(enumeration);
Assertions.assertEquals((Integer)1, iter2.next());
Assertions.assertEquals((Integer)2, iter2.next());
Assertions.assertEquals((Integer)3, iter2.next());
assertEquals((Integer)1, iter2.next());
assertEquals((Integer)2, iter2.next());
assertEquals((Integer)3, iter2.next());
}
@Test
public void testGet() {
final Iterator<Integer> iter = Arrays.asList(1, 2, 3, 4).iterator();
Assertions.assertEquals((Integer)3, IterUtil.get(iter, 2));
assertEquals((Integer)3, IterUtil.get(iter, 2));
Assertions.assertThrows(IllegalArgumentException.class, () -> IterUtil.get(iter, -1));
}
@Test
public void testGetFirst() {
final Iterator<Integer> iter = Arrays.asList(1, 2, 3, 4).iterator();
Assertions.assertEquals((Integer)1, IterUtil.getFirst(iter));
assertEquals((Integer)1, IterUtil.getFirst(iter));
Assertions.assertNull(IterUtil.getFirst(null));
Assertions.assertNull(IterUtil.getFirst(Collections.emptyIterator()));
Assertions.assertEquals((Integer)2, IterUtil.getFirst(iter, t -> (t & 1) == 0));
assertEquals((Integer)2, IterUtil.getFirst(iter, t -> (t & 1) == 0));
Assertions.assertNull(IterUtil.getFirst((Iterator<Integer>)null, t -> (t & 1) == 0));
Assertions.assertNull(IterUtil.getFirst(Collections.emptyIterator(), Objects::nonNull));
}
@ -222,7 +224,7 @@ public class IterUtilTest {
@Test
public void testGetFirstNoneNull() {
final Iterator<Integer> iter = Arrays.asList(null, 2, null, 4).iterator();
Assertions.assertEquals((Integer)2, IterUtil.getFirstNoneNull(iter));
assertEquals((Integer)2, IterUtil.getFirstNoneNull(iter));
Assertions.assertNull(IterUtil.getFirstNoneNull(null));
Assertions.assertNull(IterUtil.getFirstNoneNull(Collections.emptyIterator()));
}
@ -230,40 +232,40 @@ public class IterUtilTest {
@Test
public void testGetElementType() {
final List<Object> list = Arrays.asList(null, "str", null);
Assertions.assertEquals(String.class, IterUtil.getElementType(list));
assertEquals(String.class, IterUtil.getElementType(list));
Assertions.assertNull(IterUtil.getElementType((Iterable<?>)null));
Assertions.assertNull(IterUtil.getElementType(Collections.emptyList()));
Assertions.assertEquals(String.class, IterUtil.getElementType(list.iterator()));
assertEquals(String.class, IterUtil.getElementType(list.iterator()));
Assertions.assertNull(IterUtil.getElementType((Iterator<?>)null));
Assertions.assertNull(IterUtil.getElementType(Collections.emptyIterator()));
}
@Test
public void testEdit() {
Assertions.assertEquals(
assertEquals(
Collections.singletonList("str"),
IterUtil.edit(Arrays.asList(null, "str", null).iterator(), t -> t)
);
Assertions.assertEquals(
assertEquals(
Collections.singletonList("str"),
IterUtil.edit(Arrays.asList(null, "str", null).iterator(), null)
);
Assertions.assertEquals(Collections.emptyList(), IterUtil.edit(null, t -> t));
assertEquals(Collections.emptyList(), IterUtil.edit(null, t -> t));
}
@Test
public void testRemove() {
final List<Integer> list = new ArrayList<>(Arrays.asList(1, null, null, 3));
IterUtil.remove(list.iterator(), Objects::isNull);
Assertions.assertEquals(Arrays.asList(1, 3), list);
assertEquals(Arrays.asList(1, 3), list);
}
@Test
public void testFilterToList() {
final List<Integer> list1 = new ArrayList<>(Arrays.asList(1, null, null, 3));
final List<Integer> list2 = IterUtil.filterToList(list1.iterator(), Objects::nonNull);
Assertions.assertEquals(Arrays.asList(1, 3), list2);
assertEquals(Arrays.asList(1, 3), list2);
}
@Test
@ -283,46 +285,46 @@ public class IterUtilTest {
@Test
public void testSize() {
Assertions.assertEquals(0, IterUtil.size((Iterator<?>)null));
Assertions.assertEquals(0, IterUtil.size(Collections.emptyIterator()));
Assertions.assertEquals(3, IterUtil.size(Arrays.asList(1, 2, 3).iterator()));
assertEquals(0, IterUtil.size((Iterator<?>)null));
assertEquals(0, IterUtil.size(Collections.emptyIterator()));
assertEquals(3, IterUtil.size(Arrays.asList(1, 2, 3).iterator()));
Assertions.assertEquals(0, IterUtil.size((Iterable<?>)null));
Assertions.assertEquals(0, IterUtil.size(Collections.emptyList()));
Assertions.assertEquals(3, IterUtil.size(Arrays.asList(1, 2, 3)));
assertEquals(0, IterUtil.size((Iterable<?>)null));
assertEquals(0, IterUtil.size(Collections.emptyList()));
assertEquals(3, IterUtil.size(Arrays.asList(1, 2, 3)));
}
@Test
public void testIsEqualList() {
Assertions.assertFalse(IterUtil.isEqualList(null, Collections.emptyList()));
Assertions.assertFalse(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Collections.emptyList()));
Assertions.assertFalse(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Arrays.asList(1, 2)));
Assertions.assertTrue(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Arrays.asList(1, 2, 3)));
Assertions.assertTrue(IterUtil.isEqualList(null, null));
Assertions.assertTrue(IterUtil.isEqualList(Collections.emptyList(), Collections.emptyList()));
assertFalse(IterUtil.isEqualList(null, Collections.emptyList()));
assertFalse(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Collections.emptyList()));
assertFalse(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Arrays.asList(1, 2)));
assertTrue(IterUtil.isEqualList(Arrays.asList(1, 2, 3), Arrays.asList(1, 2, 3)));
assertTrue(IterUtil.isEqualList(null, null));
assertTrue(IterUtil.isEqualList(Collections.emptyList(), Collections.emptyList()));
}
@Test
public void testClear() {
final List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
IterUtil.clear(list.iterator());
Assertions.assertTrue(list.isEmpty());
assertTrue(list.isEmpty());
Assertions.assertThrows(UnsupportedOperationException.class, () -> IterUtil.clear(Arrays.asList(1, 2).iterator()));
}
@Test
public void testToStr() {
final List<Integer> list = Arrays.asList(1, 2, 3);
Assertions.assertEquals("[1, 2, 3]", IterUtil.toStr(list.iterator()));
Assertions.assertEquals("[1, 2, 3]", IterUtil.toStr(list.iterator(), Objects::toString));
Assertions.assertEquals("{1:2:3}", IterUtil.toStr(list.iterator(), Objects::toString, ":", "{", "}"));
assertEquals("[1, 2, 3]", IterUtil.toStr(list.iterator()));
assertEquals("[1, 2, 3]", IterUtil.toStr(list.iterator(), Objects::toString));
assertEquals("{1:2:3}", IterUtil.toStr(list.iterator(), Objects::toString, ":", "{", "}"));
}
@Test
public void testForEach() {
final List<Integer> list = new ArrayList<>();
IterUtil.forEach(Arrays.asList(1, 2, 3, 4).iterator(), list::add);
Assertions.assertEquals(Arrays.asList(1, 2, 3, 4), list);
assertEquals(Arrays.asList(1, 2, 3, 4), list);
}
@SuppressWarnings("unused")
@ -335,7 +337,7 @@ public class IterUtilTest {
@Test
public void getFirstNonNullTest() {
final List<String> strings = ListUtil.of(null, null, "123", "456", null);
Assertions.assertEquals("123", CollUtil.getFirstNoneNull(strings));
assertEquals("123", CollUtil.getFirstNoneNull(strings));
}
@Test
@ -346,39 +348,39 @@ public class IterUtilTest {
new Car("567", "路虎"));
final Map<String, Car> carNameMap = IterUtil.fieldValueMap(carList.iterator(), "carNumber");
Assertions.assertEquals("大众", carNameMap.get("123").getCarName());
Assertions.assertEquals("奔驰", carNameMap.get("345").getCarName());
Assertions.assertEquals("路虎", carNameMap.get("567").getCarName());
assertEquals("大众", carNameMap.get("123").getCarName());
assertEquals("奔驰", carNameMap.get("345").getCarName());
assertEquals("路虎", carNameMap.get("567").getCarName());
}
@Test
public void joinTest() {
final List<String> list = ListUtil.of("1", "2", "3", "4");
final String join = IterUtil.join(list.iterator(), ":");
Assertions.assertEquals("1:2:3:4", join);
assertEquals("1:2:3:4", join);
final List<Integer> list1 = ListUtil.of(1, 2, 3, 4);
final String join1 = IterUtil.join(list1.iterator(), ":");
Assertions.assertEquals("1:2:3:4", join1);
assertEquals("1:2:3:4", join1);
// 包装每个节点
final List<String> list2 = ListUtil.of("1", "2", "3", "4");
final String join2 = IterUtil.join(list2.iterator(), ":", "\"", "\"");
Assertions.assertEquals("\"1\":\"2\":\"3\":\"4\"", join2);
assertEquals("\"1\":\"2\":\"3\":\"4\"", join2);
}
@Test
public void joinWithFuncTest() {
final List<String> list = ListUtil.of("1", "2", "3", "4");
final String join = IterUtil.join(list.iterator(), ":", String::valueOf);
Assertions.assertEquals("1:2:3:4", join);
assertEquals("1:2:3:4", join);
}
@Test
public void joinWithNullTest() {
final List<String> list = ListUtil.of("1", null, "3", "4");
final String join = IterUtil.join(list.iterator(), ":", String::valueOf);
Assertions.assertEquals("1:null:3:4", join);
assertEquals("1:null:3:4", join);
}
@Test
@ -392,14 +394,14 @@ public class IterUtilTest {
expectedMap.put("456", benz);
final Map<String, Car> testMap = IterUtil.toMap(Arrays.asList(bmw, benz), Car::getCarNumber);
Assertions.assertEquals(expectedMap, testMap);
assertEquals(expectedMap, testMap);
}
@Test
public void getElementTypeTest() {
final List<Integer> integers = Arrays.asList(null, 1);
final Class<?> elementType = IterUtil.getElementType(integers);
Assertions.assertEquals(Integer.class, elementType);
assertEquals(Integer.class, elementType);
}
@Data
@ -416,8 +418,8 @@ public class IterUtilTest {
IterUtil.remove(obj.iterator(), (e)-> !obj2.contains(e));
Assertions.assertEquals(1, obj.size());
Assertions.assertEquals("3", obj.get(0));
assertEquals(1, obj.size());
assertEquals("3", obj.get(0));
}
@Test
@ -427,8 +429,8 @@ public class IterUtilTest {
final FilterIter<String> filtered = IterUtil.filtered(obj.iterator(), obj2::contains);
Assertions.assertEquals("3", filtered.next());
Assertions.assertFalse(filtered.hasNext());
assertEquals("3", filtered.next());
assertFalse(filtered.hasNext());
}
@Test
@ -438,15 +440,49 @@ public class IterUtilTest {
final List<String> filtered = IterUtil.filterToList(obj.iterator(), obj2::contains);
Assertions.assertEquals(1, filtered.size());
Assertions.assertEquals("3", filtered.get(0));
assertEquals(1, filtered.size());
assertEquals("3", filtered.get(0));
}
@Test
public void getTest() {
final HashSet<String> set = SetUtil.ofLinked("A", "B", "C", "D");
final String str = IterUtil.get(set.iterator(), 2);
Assertions.assertEquals("C", str);
assertEquals("C", str);
}
@Test
public void testIsSubTrue() {
final List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
assertTrue(IterUtil.isSub(list, list), "Expected a list to be a subset of itself");
final List<Integer> subList = Arrays.asList(1, 2, 3);
assertTrue(IterUtil.isSub(subList, list), "Expected subList to be a subset of list");
assertFalse(IterUtil.isSub(list, subList), "Expected subList to not be a subset of list due to extra elements");
}
@Test
public void testIsSubFalseDueToMissingElements() {
final List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
final List<Integer> subList = Arrays.asList(1, 2, 6);
assertFalse(IterUtil.isSub(subList, list), "Expected subList to not be a subset of list due to missing elements");
}
@Test
public void testIsSubWithEmptySubList() {
final List<Integer> list = Arrays.asList(1, 2, 3);
final List<Integer> subList = Collections.emptyList();
assertTrue(IterUtil.isSub(subList, list), "Expected an empty subList to be considered a subset of list");
assertFalse(IterUtil.isSub(list, subList), "Expected subList to not be a subset of an empty list");
}
@Test
public void testIsSubWithNullIterable() {
final List<Integer> list = Arrays.asList(1, 2, 3);
assertFalse(IterUtil.isSub(null, list), "Expected null to not be considered a subset of list");
assertFalse(IterUtil.isSub(list, null), "Expected list to not be considered a subset of null");
assertTrue(IterUtil.isSub(null, null), "Expected null to not be considered a subset of null");
}
}

2
hutool-poi/src/main/java/org/dromara/hutool/poi/csv/CsvParser.java
View File

@ -115,7 +115,7 @@ public final class CsvParser extends ComputeIter<CsvRow> implements Closeable, S
if (lineNo < config.beginLineNo) {
throw new IllegalStateException("No header available - call nextRow() first");
}
return header.fields;
return header.getRaw();
}
@Override

136
hutool-poi/src/main/java/org/dromara/hutool/poi/csv/CsvRow.java
View File

@ -14,6 +14,7 @@ package org.dromara.hutool.poi.csv;
import org.dromara.hutool.core.bean.BeanUtil;
import org.dromara.hutool.core.bean.copier.CopyOptions;
import org.dromara.hutool.core.collection.ListWrapper;
import org.dromara.hutool.core.lang.Assert;
import java.util.*;
@ -23,13 +24,12 @@ import java.util.*;
*
* @author Looly
*/
public final class CsvRow implements List<String> {
public final class CsvRow extends ListWrapper<String> {
/** 原始行号 */
private final long originalLineNumber;
final Map<String, Integer> headerMap;
final List<String> fields;
/**
* 构造
@ -39,10 +39,9 @@ public final class CsvRow implements List<String> {
* @param fields 数据列表
*/
public CsvRow(final long originalLineNumber, final Map<String, Integer> headerMap, final List<String> fields) {
Assert.notNull(fields, "fields must be not null!");
super(Assert.notNull(fields, "fields must be not null!"));
this.originalLineNumber = originalLineNumber;
this.headerMap = headerMap;
this.fields = fields;
}
/**
@ -71,15 +70,6 @@ public final class CsvRow implements List<String> {
return null;
}
/**
* 获取本行所有字段值列表
*
* @return 字段值列表
*/
public List<String> getRawList() {
return fields;
}
/**
* 获取标题与字段值对应的Map
*
@ -117,128 +107,14 @@ public final class CsvRow implements List<String> {
return BeanUtil.toBean(getFieldMap(), clazz, CopyOptions.of().setIgnoreError(true));
}
/**
* 获取字段格式
*
* @return 字段格式
*/
public int getFieldCount() {
return fields.size();
}
@Override
public int size() {
return this.fields.size();
}
@Override
public boolean isEmpty() {
return this.fields.isEmpty();
}
@Override
public boolean contains(final Object o) {
return this.fields.contains(o);
}
@Override
public Iterator<String> iterator() {
return this.fields.iterator();
}
@Override
public Object[] toArray() {
return this.fields.toArray();
}
@Override
public <T> T[] toArray(final T[] a) {
return this.fields.toArray(a);
}
@Override
public boolean add(final String e) {
return this.fields.add(e);
}
@Override
public boolean remove(final Object o) {
return this.fields.remove(o);
}
@Override
public boolean containsAll(final Collection<?> c) {
return new HashSet<>(this.fields).containsAll(c);
}
@Override
public boolean addAll(final Collection<? extends String> c) {
return this.fields.addAll(c);
}
@Override
public boolean addAll(final int index, final Collection<? extends String> c) {
return this.fields.addAll(index, c);
}
@Override
public boolean removeAll(final Collection<?> c) {
return this.fields.removeAll(c);
}
@Override
public boolean retainAll(final Collection<?> c) {
return this.fields.retainAll(c);
}
@Override
public void clear() {
this.fields.clear();
return new HashSet<>(this.raw).containsAll(c);
}
@Override
public String get(final int index) {
return index >= fields.size() ? null : fields.get(index);
}
@Override
public String set(final int index, final String element) {
return this.fields.set(index, element);
}
@Override
public void add(final int index, final String element) {
this.fields.add(index, element);
}
@Override
public String remove(final int index) {
return this.fields.remove(index);
}
@Override
public int indexOf(final Object o) {
return this.fields.indexOf(o);
}
@Override
public int lastIndexOf(final Object o) {
return this.fields.lastIndexOf(o);
}
@Override
public ListIterator<String> listIterator() {
return this.fields.listIterator();
}
@Override
public ListIterator<String> listIterator(final int index) {
return this.fields.listIterator(index);
}
@Override
public List<String> subList(final int fromIndex, final int toIndex) {
return this.fields.subList(fromIndex, toIndex);
return index >= size() ? null : super.get(index);
}
@Override
@ -265,7 +141,7 @@ public final class CsvRow implements List<String> {
}
sb.append('}');
} else {
sb.append(fields.toString());
sb.append(this.raw.toString());
}
sb.append('}');

8
hutool-poi/src/test/java/org/dromara/hutool/poi/csv/CsvParserTest.java
View File

@ -27,7 +27,7 @@ public class CsvParserTest {
final CsvParser parser = new CsvParser(reader, null);
final CsvRow row = parser.nextRow();
//noinspection ConstantConditions
Assertions.assertEquals("b\"bba\"", row.getRawList().get(1));
Assertions.assertEquals("b\"bba\"", row.getRaw().get(1));
IoUtil.closeQuietly(parser);
}
@ -37,7 +37,7 @@ public class CsvParserTest {
final CsvParser parser = new CsvParser(reader, null);
final CsvRow row = parser.nextRow();
//noinspection ConstantConditions
Assertions.assertEquals("\"bba\"bbb", row.getRawList().get(1));
Assertions.assertEquals("\"bba\"bbb", row.getRaw().get(1));
IoUtil.closeQuietly(parser);
}
@ -47,7 +47,7 @@ public class CsvParserTest {
final CsvParser parser = new CsvParser(reader, null);
final CsvRow row = parser.nextRow();
//noinspection ConstantConditions
Assertions.assertEquals("bba", row.getRawList().get(1));
Assertions.assertEquals("bba", row.getRaw().get(1));
IoUtil.closeQuietly(parser);
}
@ -57,7 +57,7 @@ public class CsvParserTest {
final CsvParser parser = new CsvParser(reader, null);
final CsvRow row = parser.nextRow();
//noinspection ConstantConditions
Assertions.assertEquals("", row.getRawList().get(1));
Assertions.assertEquals("", row.getRaw().get(1));
IoUtil.closeQuietly(parser);
}