操作集合
public class CollectionUtils { public static boolean containsAny(Object source, Object... targets) { return asList(targets).contains(source); } public static boolean isAnyEmpty(Collection<?>... collections) { return Arrays.stream(collections).anyMatch(CollectionUtil::isEmpty); } public static <T> boolean anyMatch(Collection<T> from, Predicate<T> predicate) { return from.stream().anyMatch(predicate); } 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(T[] from, Function<T, U> func) { if (ArrayUtil.isEmpty(from)) { return new ArrayList<>(); } return convertList(Arrays.asList(from), func); } 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> List<U> convertListByFlatMap(Collection<T> from, Function<T, ? extends Stream<? extends U>> func) { if (CollUtil.isEmpty(from)) { return new ArrayList<>(); } return from.stream().flatMap(func).filter(Objects::nonNull).collect(Collectors.toList()); } public static <T, U, R> List<R> convertListByFlatMap(Collection<T> from, Function<? super T, ? extends U> mapper, Function<U, ? extends Stream<? extends R>> func) { if (CollUtil.isEmpty(from)) { return new ArrayList<>(); } return from.stream().map(mapper).flatMap(func).filter(Objects::nonNull).collect(Collectors.toList()); } public static <K, V> List<V> mergeValuesFromMap(Map<K, List<V>> map) { return map.values() .stream() .flatMap(List::stream) .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> convertMapByFilter(Collection<T> from, Predicate<T> filter, Function<T, K> keyFunc) { if (CollUtil.isEmpty(from)) { return new HashMap<>(); } return from.stream().filter(filter).collect(Collectors.toMap(keyFunc, v -> v)); } public static <T, U> Set<U> convertSetByFlatMap(Collection<T> from, Function<T, ? extends Stream<? extends U>> func) { if (CollUtil.isEmpty(from)) { return new HashSet<>(); } return from.stream().flatMap(func).filter(Objects::nonNull).collect(Collectors.toSet()); } public static <T, U, R> Set<R> convertSetByFlatMap(Collection<T> from, Function<? super T, ? extends U> mapper, Function<U, ? extends Stream<? extends R>> func) { if (CollUtil.isEmpty(from)) { return new HashSet<>(); } return from.stream().map(mapper).flatMap(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(); } /** * 对比老、新两个列表,找出新增、修改、删除的数据 * * @param oldList 老列表 * @param newList 新列表 * @param sameFunc 对比函数,返回 true 表示相同,返回 false 表示不同 * 注意,same 是通过每个元素的“标识”,判断它们是不是同一个数据 * @return [新增列表、修改列表、删除列表] */ public static <T> List<List<T>> diffList(Collection<T> oldList, Collection<T> newList, BiFunction<T, T, Boolean> sameFunc) { List<T> createList = new LinkedList<>(newList); // 默认都认为是新增的,后续会进行移除 List<T> updateList = new ArrayList<>(); List<T> deleteList = new ArrayList<>(); // 通过以 oldList 为主遍历,找出 updateList 和 deleteList for (T oldObj : oldList) { // 1. 寻找是否有匹配的 T foundObj = null; for (Iterator<T> iterator = createList.iterator(); iterator.hasNext(); ) { T newObj = iterator.next(); // 1.1 不匹配,则直接跳过 if (!sameFunc.apply(oldObj, newObj)) { continue; } // 1.2 匹配,则移除,并结束寻找 iterator.remove(); foundObj = newObj; break; } // 2. 匹配添加到 updateList;不匹配则添加到 deleteList 中 if (foundObj != null) { updateList.add(foundObj); } else { deleteList.add(oldObj); } } return asList(createList, updateList, deleteList); } 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) { return findFirst(from, predicate, Function.identity()); } public static <T, U> U findFirst(List<T> from, Predicate<T> predicate, Function<T, U> func) { if (CollUtil.isEmpty(from)) { return null; } return from.stream().filter(predicate).findFirst().map(func).orElse(null); } public static <T, V extends Comparable<? super V>> V getMaxValue(Collection<T> from, Function<T, V> valueFunc) { if (CollUtil.isEmpty(from)) { return null; } assert !from.isEmpty(); // 断言,避免告警 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); } }
用法如下,简化一些较简单的stream流操作
Set<String> codegenColumnNames = convertSet(codegenColumns, CodegenColumnDO::getColumnName);
MapUtils,操作map
public class MapUtils { /** * 从哈希表表中,获得 keys 对应的所有 value 数组 * * @param multimap 哈希表 * @param keys keys * @return value 数组 */ public static <K, V> List<V> getList(Multimap<K, V> multimap, Collection<K> keys) { List<V> result = new ArrayList<>(); keys.forEach(k -> { Collection<V> values = multimap.get(k); if (CollectionUtil.isEmpty(values)) { return; } result.addAll(values); }); return result; } /** * 从哈希表查找到 key 对应的 value,然后进一步处理 * 注意,如果查找到的 value 为 null 时,不进行处理 * * @param map 哈希表 * @param key key * @param consumer 进一步处理的逻辑 */ public static <K, V> void findAndThen(Map<K, V> map, K key, Consumer<V> consumer) { if (CollUtil.isEmpty(map)) { return; } V value = map.get(key); if (value == null) { return; } consumer.accept(value); } public static <K, V> Map<K, V> convertMap(List<KeyValue<K, V>> keyValues) { Map<K, V> map = Maps.newLinkedHashMapWithExpectedSize(keyValues.size()); keyValues.forEach(keyValue -> map.put(keyValue.getKey(), keyValue.getValue())); return map; } }
使用案例:找到value进行其他操作
MapUtils.findAndThen(userMap,NumberUtils.parseLong(assignee), assignUser-> bpmTaskSubSignRespVO.setAssigneeUser(convert3(assignUser)));
标签:Function,return,stream,流等,编程,Collection,static,isEmpty,public From: https://www.cnblogs.com/jiutang001/p/18233280