cn.geektool.core.collection.CollStreamUtil Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of geektool-core Show documentation
geektool核心，包括集合、字符串、Bean等工具
The newest version!
package cn.geektool.core.collection;


import cn.geektool.core.map.MapUtil;

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

/**
 * 集合的stream操作封装
 *
 * @author [email protected]
 * @since 5.5.2
 */
public class CollStreamUtil {

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

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

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

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

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

	 * {@code Collection -------> Map> } 
	 *
	 * @param collection 需要分类的集合
	 * @param key        分类的规则
	 * @param         collection中的泛型
	 * @param         map中的key类型
	 * @return 分类后的map
	 */
	public static  Map> groupByKey(Collection collection, Function key) {
		if (CollUtil.isEmpty(collection)) {
			return Collections.emptyMap();
		}
		return collection
				.stream()
				.collect(Collectors.groupingBy(key, 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  Map>> groupBy2Key(Collection collection, Function key1, Function key2) {
		if (CollUtil.isEmpty(collection)) {
			return Collections.emptyMap();
		}
		return collection
				.stream()
				.collect(Collectors.groupingBy(key1, Collectors.groupingBy(key2, 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  Map> group2Map(Collection collection, Function key1, Function key2) {
		if (CollUtil.isEmpty(collection) || key1 == null || key2 == null) {
			return Collections.emptyMap();
		}
		return collection
				.stream()
				.collect(Collectors.groupingBy(key1, Collectors.toMap(key2, Function.identity())));
	}

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

	 * {@code Collection  ------>  List } 
	 *
	 * @param collection 需要转化的集合
	 * @param function   collection中的泛型转化为list泛型的lambda表达式
	 * @param         collection中的泛型
	 * @param         List中的泛型
	 * @return 转化后的list
	 */
	public static  List toList(Collection collection, Function function) {
		if (CollUtil.isEmpty(collection)) {
			return Collections.emptyList();
		}
		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  Set toSet(Collection collection, Function function) {
		if (CollUtil.isEmpty(collection) || function == null) {
			return Collections.emptySet();
		}
		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  Map merge(Map map1, Map map2, BiFunction merge) {
		if (MapUtil.isEmpty(map1) && MapUtil.isEmpty(map2)) {
			return Collections.emptyMap();
		} else if (MapUtil.isEmpty(map1)) {
			map1 = Collections.emptyMap();
		} else if (MapUtil.isEmpty(map2)) {
			map2 = Collections.emptyMap();
		}
		Set key = new HashSet<>();
		key.addAll(map1.keySet());
		key.addAll(map2.keySet());
		Map 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;
	}
}