package com.fastbee.common.utils.collection;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.collection.CollectionUtil;
|
|
import java.util.*;
|
import java.util.function.BinaryOperator;
|
import java.util.function.Function;
|
import java.util.function.Predicate;
|
import java.util.function.Supplier;
|
import java.util.stream.Collectors;
|
|
/**
|
* @author gsb
|
* @date 2022/9/15 16:52
|
*/
|
public class CollectionUtils {
|
|
/*数组复制*/
|
public static String[] copy(String[] source){
|
if(isEmpty(source)){
|
return null;
|
}
|
int len = source.length;
|
String[] arr = new String[len];
|
for(int i=0; i < len; i ++){
|
arr[i] = source[i];
|
}
|
return arr;
|
}
|
|
|
/*数组连接*/
|
public static String concat(String[] source, String split){
|
if(isEmpty(source)){
|
return null;
|
}
|
String result = "";
|
for(int i=0; i < source.length; i ++){
|
result = result.concat(source[i]);
|
if(i != source.length - 1){
|
result = result.concat(split);
|
}
|
}
|
return result;
|
}
|
|
public static boolean isEmpty(String[] source){
|
if(null == source){
|
return true;
|
}
|
if(0 == source.length){
|
return true;
|
}
|
return false;
|
}
|
|
public static boolean containsAny(Object source, Object... targets) {
|
return Arrays.asList(targets).contains(source);
|
}
|
|
public static boolean isAnyEmpty(Collection<?>... collections) {
|
return Arrays.stream(collections).anyMatch(CollectionUtil::isEmpty);
|
}
|
|
public static <T> List<T> filterList(Collection<T> from, Predicate<T> predicate) {
|
if (CollUtil.isEmpty(from)) {
|
return new ArrayList<>();
|
}
|
return from.stream().filter(predicate).collect(Collectors.toList());
|
}
|
|
public static <T, R> List<T> distinct(Collection<T> from, Function<T, R> keyMapper) {
|
if (CollUtil.isEmpty(from)) {
|
return new ArrayList<>();
|
}
|
return distinct(from, keyMapper, (t1, t2) -> t1);
|
}
|
|
public static <T, R> List<T> distinct(Collection<T> from, Function<T, R> keyMapper, BinaryOperator<T> cover) {
|
if (CollUtil.isEmpty(from)) {
|
return new ArrayList<>();
|
}
|
return new ArrayList<>(convertMap(from, keyMapper, Function.identity(), cover).values());
|
}
|
|
public static <T, U> List<U> convertList(Collection<T> from, Function<T, U> func) {
|
if (CollUtil.isEmpty(from)) {
|
return new ArrayList<>();
|
}
|
return from.stream().map(func).filter(Objects::nonNull).collect(Collectors.toList());
|
}
|
|
public static <T, U> List<U> convertList(Collection<T> from, Function<T, U> func, Predicate<T> filter) {
|
if (CollUtil.isEmpty(from)) {
|
return new ArrayList<>();
|
}
|
return from.stream().filter(filter).map(func).filter(Objects::nonNull).collect(Collectors.toList());
|
}
|
|
public static <T, U> Set<U> convertSet(Collection<T> from, Function<T, U> func) {
|
if (CollUtil.isEmpty(from)) {
|
return new HashSet<>();
|
}
|
return from.stream().map(func).filter(Objects::nonNull).collect(Collectors.toSet());
|
}
|
|
public static <T, U> Set<U> convertSet(Collection<T> from, Function<T, U> func, Predicate<T> filter) {
|
if (CollUtil.isEmpty(from)) {
|
return new HashSet<>();
|
}
|
return from.stream().filter(filter).map(func).filter(Objects::nonNull).collect(Collectors.toSet());
|
}
|
|
public static <T, K> Map<K, T> convertMap(Collection<T> from, Function<T, K> keyFunc) {
|
if (CollUtil.isEmpty(from)) {
|
return new HashMap<>();
|
}
|
return convertMap(from, keyFunc, Function.identity());
|
}
|
|
public static <T, K> Map<K, T> convertMap(Collection<T> from, Function<T, K> keyFunc, Supplier<? extends Map<K, T>> supplier) {
|
if (CollUtil.isEmpty(from)) {
|
return supplier.get();
|
}
|
return convertMap(from, keyFunc, Function.identity(), supplier);
|
}
|
|
public static <T, K, V> Map<K, V> convertMap(Collection<T> from, Function<T, K> keyFunc, Function<T, V> valueFunc) {
|
if (CollUtil.isEmpty(from)) {
|
return new HashMap<>();
|
}
|
return convertMap(from, keyFunc, valueFunc, (v1, v2) -> v1);
|
}
|
|
public static <T, K, V> Map<K, V> convertMap(Collection<T> from, Function<T, K> keyFunc, Function<T, V> valueFunc, BinaryOperator<V> mergeFunction) {
|
if (CollUtil.isEmpty(from)) {
|
return new HashMap<>();
|
}
|
return convertMap(from, keyFunc, valueFunc, mergeFunction, HashMap::new);
|
}
|
|
public static <T, K, V> Map<K, V> convertMap(Collection<T> from, Function<T, K> keyFunc, Function<T, V> valueFunc, Supplier<? extends Map<K, V>> supplier) {
|
if (CollUtil.isEmpty(from)) {
|
return supplier.get();
|
}
|
return convertMap(from, keyFunc, valueFunc, (v1, v2) -> v1, supplier);
|
}
|
|
public static <T, K, V> Map<K, V> convertMap(Collection<T> from, Function<T, K> keyFunc, Function<T, V> valueFunc, BinaryOperator<V> mergeFunction, Supplier<? extends Map<K, V>> supplier) {
|
if (CollUtil.isEmpty(from)) {
|
return new HashMap<>();
|
}
|
return from.stream().collect(Collectors.toMap(keyFunc, valueFunc, mergeFunction, supplier));
|
}
|
|
public static <T, K> Map<K, List<T>> convertMultiMap(Collection<T> from, Function<T, K> keyFunc) {
|
if (CollUtil.isEmpty(from)) {
|
return new HashMap<>();
|
}
|
return from.stream().collect(Collectors.groupingBy(keyFunc, Collectors.mapping(t -> t, Collectors.toList())));
|
}
|
|
public static <T, K, V> Map<K, List<V>> convertMultiMap(Collection<T> from, Function<T, K> keyFunc, Function<T, V> valueFunc) {
|
if (CollUtil.isEmpty(from)) {
|
return new HashMap<>();
|
}
|
return from.stream()
|
.collect(Collectors.groupingBy(keyFunc, Collectors.mapping(valueFunc, Collectors.toList())));
|
}
|
|
// 暂时没想好名字，先以 2 结尾噶
|
public static <T, K, V> Map<K, Set<V>> convertMultiMap2(Collection<T> from, Function<T, K> keyFunc, Function<T, V> valueFunc) {
|
if (CollUtil.isEmpty(from)) {
|
return new HashMap<>();
|
}
|
return from.stream().collect(Collectors.groupingBy(keyFunc, Collectors.mapping(valueFunc, Collectors.toSet())));
|
}
|
|
|
public static boolean containsAny(Collection<?> source, Collection<?> candidates) {
|
return org.springframework.util.CollectionUtils.containsAny(source, candidates);
|
}
|
|
public static <T> T getFirst(List<T> from) {
|
return !CollectionUtil.isEmpty(from) ? from.get(0) : null;
|
}
|
|
public static <T> T findFirst(List<T> from, Predicate<T> predicate) {
|
if (CollUtil.isEmpty(from)) {
|
return null;
|
}
|
return from.stream().filter(predicate).findFirst().orElse(null);
|
}
|
|
public static <T, V extends Comparable<? super V>> V getMaxValue(List<T> from, Function<T, V> valueFunc) {
|
if (CollUtil.isEmpty(from)) {
|
return null;
|
}
|
assert from.size() > 0; // 断言，避免告警
|
T t = from.stream().max(Comparator.comparing(valueFunc)).get();
|
return valueFunc.apply(t);
|
}
|
|
public static <T, V extends Comparable<? super V>> V getMinValue(List<T> from, Function<T, V> valueFunc) {
|
if (CollUtil.isEmpty(from)) {
|
return null;
|
}
|
assert from.size() > 0; // 断言，避免告警
|
T t = from.stream().min(Comparator.comparing(valueFunc)).get();
|
return valueFunc.apply(t);
|
}
|
|
public static <T, V extends Comparable<? super V>> V getSumValue(List<T> from, Function<T, V> valueFunc, BinaryOperator<V> accumulator) {
|
if (CollUtil.isEmpty(from)) {
|
return null;
|
}
|
assert from.size() > 0; // 断言，避免告警
|
return from.stream().map(valueFunc).reduce(accumulator).get();
|
}
|
|
public static <T> void addIfNotNull(Collection<T> coll, T item) {
|
if (item == null) {
|
return;
|
}
|
coll.add(item);
|
}
|
|
public static <T> Collection<T> singleton(T deptId) {
|
return deptId == null ? Collections.emptyList() : Collections.singleton(deptId);
|
}
|
}
|
