stream 流工具类

package com.hfwy.common.core.utils;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.StrUtil;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;

import java.util.*;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * stream 流工具类
 *
 * @author Lion Li
 */
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class StreamUtils {

	/**
	 * 将collection过滤
	 * @param collection 需要转化的集合
	 * @param function 过滤方法
	 * @return 过滤后的list
	 */
	public static <E> List<E> filter(Collection<E> collection, Predicate<E> function) {
		if (CollUtil.isEmpty(collection)) {
			return CollUtil.newArrayList();
		}
		return collection.stream().filter(function).collect(Collectors.toList());
	}

	/**
	 * 将collection拼接
	 * @param collection 需要转化的集合
	 * @param function 拼接方法
	 * @return 拼接后的list
	 */
	public static <E> String join(Collection<E> collection, Function<E, String> function) {
		return join(collection, function, StringUtils.SEPARATOR);
	}

	/**
	 * 将collection拼接
	 * @param collection 需要转化的集合
	 * @param function 拼接方法
	 * @param delimiter 拼接符
	 * @return 拼接后的list
	 */
	public static <E> String join(Collection<E> collection, Function<E, String> function, CharSequence delimiter) {
		if (CollUtil.isEmpty(collection)) {
			return StrUtil.EMPTY;
		}
		return collection.stream().map(function).filter(Objects::nonNull).collect(Collectors.joining(delimiter));
	}

	/**
	 * 将collection排序
	 * @param collection 需要转化的集合
	 * @param comparing 排序方法
	 * @return 排序后的list
	 */
	public static <E> List<E> sorted(Collection<E> collection, Comparator<E> comparing) {
		if (CollUtil.isEmpty(collection)) {
			return CollUtil.newArrayList();
		}
		return collection.stream().sorted(comparing).collect(Collectors.toList());
	}

	/**
	 * 将collection转化为类型不变的map

	 * {@code Collection  ---->  Map}
	 * @param collection 需要转化的集合
	 * @param key V类型转化为K类型的lambda方法
	 * @param  collection中的泛型
	 * @param  map中的key类型
	 * @return 转化后的map
	 */
	public static <V, K> Map<K, V> toIdentityMap(Collection<V> collection, Function<V, K> key) {
		if (CollUtil.isEmpty(collection)) {
			return MapUtil.newHashMap();
		}
		return collection.stream().collect(Collectors.toMap(key, Function.identity(), (l, r) -> l));
	}

	/**
	 * 将Collection转化为map(value类型与collection的泛型不同)

	 * {@code Collection -----> Map  }
	 * @param collection 需要转化的集合
	 * @param key E类型转化为K类型的lambda方法
	 * @param value E类型转化为V类型的lambda方法
	 * @param  collection中的泛型
	 * @param  map中的key类型
	 * @param  map中的value类型
	 * @return 转化后的map
	 */
	public static <E, K, V> Map<K, V> toMap(Collection<E> collection, Function<E, K> key, Function<E, V> value) {
		if (CollUtil.isEmpty(collection)) {
			return MapUtil.newHashMap();
		}
		return collection.stream().collect(Collectors.toMap(key, value, (l, r) -> l));
	}

	/**
	 * 将collection按照规则(比如有相同的班级id)分类成map

	 * {@code Collection -------> Map> } 
	 * @param collection 需要分类的集合
	 * @param key 分类的规则
	 * @param  collection中的泛型
	 * @param  map中的key类型
	 * @return 分类后的map
	 */
	public static <E, K> Map<K, List<E>> groupByKey(Collection<E> collection, Function<E, K> key) {
		if (CollUtil.isEmpty(collection)) {
			return MapUtil.newHashMap();
		}
		return collection.stream().collect(Collectors.groupingBy(key, LinkedHashMap::new, Collectors.toList()));
	}

	/**
	 * 将collection按照两个规则(比如有相同的年级id,班级id)分类成双层map

	 * {@code Collection  --->  Map>> } 
	 * @param collection 需要分类的集合
	 * @param key1 第一个分类的规则
	 * @param key2 第二个分类的规则
	 * @param  集合元素类型
	 * @param  第一个map中的key类型
	 * @param  第二个map中的key类型
	 * @return 分类后的map
	 */
	public static <E, K, U> Map<K, Map<U, List<E>>> groupBy2Key(Collection<E> collection, Function<E, K> key1,
			Function<E, U> key2) {
		if (CollUtil.isEmpty(collection)) {
			return MapUtil.newHashMap();
		}
		return collection.stream().collect(Collectors.groupingBy(key1, LinkedHashMap::new,
				Collectors.groupingBy(key2, LinkedHashMap::new, Collectors.toList())));
	}

	/**
	 * 将collection按照两个规则(比如有相同的年级id,班级id)分类成双层map

	 * {@code Collection  --->  Map> } 
	 * @param collection 需要分类的集合
	 * @param key1 第一个分类的规则
	 * @param key2 第二个分类的规则
	 * @param  第一个map中的key类型
	 * @param  第二个map中的key类型
	 * @param  collection中的泛型
	 * @return 分类后的map
	 */
	public static <E, T, U> Map<T, Map<U, E>> group2Map(Collection<E> collection, Function<E, T> key1,
			Function<E, U> key2) {
		if (CollUtil.isEmpty(collection) || key1 == null || key2 == null) {
			return MapUtil.newHashMap();
		}
		return collection.stream().collect(Collectors.groupingBy(key1, LinkedHashMap::new,
				Collectors.toMap(key2, Function.identity(), (l, r) -> l)));
	}

	/**
	 * 将collection转化为List集合，但是两者的泛型不同

	 * {@code Collection  ------>  List } 
	 * @param collection 需要转化的集合
	 * @param function collection中的泛型转化为list泛型的lambda表达式
	 * @param  collection中的泛型
	 * @param  List中的泛型
	 * @return 转化后的list
	 */
	public static <E, T> List<T> toList(Collection<E> collection, Function<E, T> function) {
		if (CollUtil.isEmpty(collection)) {
			return CollUtil.newArrayList();
		}
		return collection.stream().map(function).filter(Objects::nonNull).collect(Collectors.toList());
	}

	/**
	 * 将collection转化为Set集合，但是两者的泛型不同

	 * {@code Collection  ------>  Set } 
	 * @param collection 需要转化的集合
	 * @param function collection中的泛型转化为set泛型的lambda表达式
	 * @param  collection中的泛型
	 * @param  Set中的泛型
	 * @return 转化后的Set
	 */
	public static <E, T> Set<T> toSet(Collection<E> collection, Function<E, T> function) {
		if (CollUtil.isEmpty(collection) || function == null) {
			return CollUtil.newHashSet();
		}
		return collection.stream().map(function).filter(Objects::nonNull).collect(Collectors.toSet());
	}

	/**
	 * 合并两个相同key类型的map
	 * @param map1 第一个需要合并的 map
	 * @param map2 第二个需要合并的 map
	 * @param merge 合并的lambda，将key value1 value2合并成最终的类型,注意value可能为空的情况
	 * @param  map中的key类型
	 * @param  第一个 map的value类型
	 * @param  第二个 map的value类型
	 * @param  最终map的value类型
	 * @return 合并后的map
	 */
	public static <K, X, Y, V> Map<K, V> merge(Map<K, X> map1, Map<K, Y> map2, BiFunction<X, Y, V> merge) {
		if (MapUtil.isEmpty(map1) && MapUtil.isEmpty(map2)) {
			return MapUtil.newHashMap();
		}
		else if (MapUtil.isEmpty(map1)) {
			map1 = MapUtil.newHashMap();
		}
		else if (MapUtil.isEmpty(map2)) {
			map2 = MapUtil.newHashMap();
		}
		Set<K> key = new HashSet<>();
		key.addAll(map1.keySet());
		key.addAll(map2.keySet());
		Map<K, V> map = new HashMap<>();
		for (K t : key) {
			X x = map1.get(t);
			Y y = map2.get(t);
			V z = merge.apply(x, y);
			if (z != null) {
				map.put(t, z);
			}
		}
		return map;
	}

}