package cn.jk.cloud.framework.common.util.collection; import cn.hutool.core.collection.CollUtil;import cn.hutool.core.collection.CollectionUtil;import com.google.common.collect.ImmutableMap;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;/**Collection 工具类 *@author 芋道源码 */public class CollectionUtils {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 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 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 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 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 <T, K> Map<K, T> convertImmutableMap(Collection<T> from, Function<T, K> keyFunc) { if (CollUtil.isEmpty(from)) { return Collections.emptyMap(); } ImmutableMap.Builder<K, T> builder = ImmutableMap.builder(); from.forEach(item -> builder.put(keyFunc.apply(item), item)); return builder.build(); } 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); } }