封装Java8 StreamApi常用的使用方法,工具类代码如下:
import java.math.BigDecimal;
import java.util.*;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* Java8 StreamAPI 常用方法封装
*
* @author *** 2020/12/18
*/
public class StreamApiUtil {
/**
* 集合转换为List
*
* @param collection 集合对象
* @param valueMapper value映射规则
* @param <E> 集合元素类型的泛型
* @param <V> 最终输出类型的泛型
* @return List<V>
*/
public static <E, V> List<V> mapList(Collection<E> collection, Function<E, V> valueMapper) {
if (collection == null) {
return null;
}
return collection.stream().map(valueMapper).collect(Collectors.toList());
}
/**
* 集合转换为Set
*
* @param collection 集合对象
* @param valueMapper value映射规则
* @param <E> 集合元素类型的泛型
* @param <V> 最终输出类型的泛型
* @return Set<V>
*/
public static <E, V> Set<V> mapSet(Collection<E> collection, Function<E, V> valueMapper) {
if (collection == null) {
return null;
}
return collection.stream().map(valueMapper).collect(Collectors.toSet());
}
/**
* 集合转换为Map
*
* @param collection 集合对象
* @param keyMapper Key的映射规则
* @param valueMapper value映射规则
* @param <K> Key的泛型
* @param <E> 集合元素类型的泛型
* @param <V> 最终输出类型的泛型
* @return Map<K, V>
*/
public static <K, E, V> Map<K, V> toMap(Collection<E> collection, Function<E, K> keyMapper, Function<E, V> valueMapper) {
if (collection == null) {
return null;
}
return collection.stream().collect(Collectors.toMap(keyMapper, valueMapper));
}
public static <K, E> Map<K, E> toMap(Collection<E> collection, Function<E, K> keyMapper) {
return toMap(collection, keyMapper, Function.identity());
}
/**
* 按照指定Key进行分组
*
* @param collection 集合对象
* @param keyMapper Key的映射规则
* @param <K> Key的泛型
* @param <E> 集合元素类型的泛型
* @return Map<K, List < E>>
*/
public static <K, E> Map<K, List<E>> groupBy(Collection<E> collection, Function<E, K> keyMapper) {
if (collection == null) {
return null;
}
return collection.stream().collect(Collectors.groupingBy(keyMapper, Collectors.toList()));
}
/**
* 集合根据指定的Key规则进行分组求最大值(比如:按照用户ID分组,取每个用户的最近的订单数据 或者 按照用户ID分组,统计每个用户某个属性的最大值)
*
* @param collection 集合对象
* @param keyMapper 分组Key的映射规则
* @param valueMapper value映射规则
* @param comparator 集合合并的比较器
* @return Map<K, V>
*/
public static <K, E, V> Map<K, V> maxByGroup(Collection<E> collection, Function<E, K> keyMapper, Function<E, V> valueMapper, Comparator<V> comparator) {
return merge(collection, keyMapper, valueMapper, BinaryOperator.maxBy(comparator));
}
public static <K, E> Map<K, E> maxByGroup(Collection<E> collection, Function<E, K> keyMapper, Comparator<E> comparator) {
return merge(collection, keyMapper, Function.identity(), BinaryOperator.maxBy(comparator));
}
/**
* 集合根据指定的Key规则进行分组求最小值(比如:按照用户ID分组,取每个用户的最早的历史数据 或者 按照用户ID分组,统计每个用户某个属性的最小值)
*
* @param collection 集合对象
* @param keyMapper 分组Key的映射规则
* @param valueMapper value映射规则
* @param comparator 集合合并的比较器
* @return Map<K, V>
*/
public static <K, E, V> Map<K, V> minByGroup(Collection<E> collection, Function<E, K> keyMapper, Function<E, V> valueMapper, Comparator<V> comparator) {
return merge(collection, keyMapper, valueMapper, BinaryOperator.minBy(comparator));
}
public static <K, E> Map<K, E> minByGroup(Collection<E> collection, Function<E, K> keyMapper, Comparator<E> comparator) {
return merge(collection, keyMapper, Function.identity(), BinaryOperator.minBy(comparator));
}
/**
* 集合对象的最大值
*
* @param collection 集合对象
* @param comparator 集合合并的比较器
* @return E
*/
public static <E> E max(Collection<E> collection, Comparator<E> comparator) {
if (collection == null) {
return null;
}
Optional<E> maxResult = collection.stream().reduce(BinaryOperator.maxBy(comparator));
return maxResult.orElse(null);
}
/**
* 集合对象的最小值
*
* @param collection 集合对象
* @param comparator 集合合并的比较器
* @return E
*/
public static <E> E min(Collection<E> collection, Comparator<E> comparator) {
if (collection == null) {
return null;
}
Optional<E> minResult = collection.stream().reduce(BinaryOperator.minBy(comparator));
return minResult.orElse(null);
}
/**
* 集合根据指定的Key规则进行分组求和(比如:按照用户ID分组,取每个用户的余额总值)
*
* @param collection 集合对象
* @param keyMapper 分组Key的映射规则
* @param valueMapper value映射规则
* @return Map<K, Integer>
*/
public static <K, E> Map<K, Integer> sumIntegerByGroup(Collection<E> collection, Function<E, K> keyMapper, Function<E, Integer> valueMapper) {
return merge(collection, keyMapper, valueMapper, Integer::sum);
}
public static <K, E> Map<K, Long> sumLongByGroup(Collection<E> collection, Function<E, K> keyMapper, Function<E, Long> valueMapper) {
return merge(collection, keyMapper, valueMapper, Long::sum);
}
public static <K, E> Map<K, Double> sumDoubleByGroup(Collection<E> collection, Function<E, K> keyMapper, Function<E, Double> valueMapper) {
return merge(collection, keyMapper, valueMapper, Double::sum);
}
/**
* 集合根据指定的Key规则进行分组计数(比如:按照订单状态分组,统计订单的条数)
*
* @param collection 集合对象
* @param keyMapper 分组Key的映射规则
* @return Map<K, Long>
*/
public static <K, E> Map<K, Long> countingByGroup(Collection<E> collection, Function<E, K> keyMapper) {
if (collection == null) {
return null;
}
if (collection.isEmpty()) {
return new HashMap<>();
}
return collection.stream().collect(Collectors.groupingBy(keyMapper, Collectors.counting()));
}
/**
* 集合根据指定的Key规则进行分组合并
*
* @param collection 集合对象
* @param keyMapper 分组Key的映射规则
* @param valueMapper value映射规则
* @param binaryOperator 自定义集合合并的规则
* @param <K> Key的泛型
* @param <E> 集合元素类型的泛型
* @param <V> 最终输出类型的泛型
* @return Map<K, V>
*/
public static <K, E, V> Map<K, V> merge(Collection<E> collection, Function<E, K> keyMapper, Function<E, V> valueMapper, BinaryOperator<V> binaryOperator) {
if (collection == null) {
return null;
}
if (collection.isEmpty()) {
return new HashMap<>();
}
return collection.stream().collect(Collectors.toMap(keyMapper, valueMapper, binaryOperator));
}
/**
* 集合元素求和
*
* @param collection 集合对象
* @return Integer
*/
public static int sumInteger(Collection<Integer> collection) {
return sum(collection, Integer::sum, 0);
}
public static long sumLong(Collection<Long> collection) {
return sum(collection, Long::sum, 0L);
}
public static double sumDouble(Collection<Double> collection) {
return sum(collection, Double::sum, 0.d);
}
/**
* 集合元素求和
*
* @param collection 集合对象
* @param keyMapper 需要求和的属性映射
* @param binaryOperator 函数式接口,取两个值并产生一个新值
* @param defaultResult 默认值或初始值。
* @return U
*/
public static <E, U> U sum(Collection<E> collection, Function<E, U> keyMapper, BinaryOperator<U> binaryOperator, U defaultResult) {
if (collection == null) {
return defaultResult;
}
return collection.stream().map(keyMapper).reduce(defaultResult, binaryOperator);
}
public static <E> E sum(Collection<E> collection, BinaryOperator<E> binaryOperator, E defaultResult) {
return sum(collection, Function.identity(), binaryOperator, defaultResult);
}
public static void main(String[] args) {
class User {
private String name;
private int count;
private String date;
private User(String name, int count, String date) {
this.name = name;
this.count = count;
this.date = date;
}
private String getName() {
return name;
}
private int getCount() {
return count;
}
private String getDate() {
return date;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", count=" + count +
", date='" + date + '\'' +
'}';
}
}
List<User> list = Arrays.asList(
new User("张三", 1, "2020-12-20")
, new User("张三", 2, "2020-12-21")
, new User("李四", 3, "2020-12-22")
, new User("李四", 4, "2020-12-24"),
new User("王五", 100, "2020-12-27"));
System.out.println(maxByGroup(list, User::getName, Comparator.comparing(User::getDate)));
System.out.println(minByGroup(list, User::getName, Comparator.comparing(User::getDate)));
System.out.println(sumIntegerByGroup(list, User::getName, User::getCount));
System.out.println("======================================");
System.out.println(maxByGroup(new ArrayList<>(), User::getName, Comparator.comparing(User::getDate)));
System.out.println(toMap(new ArrayList<>(), User::getName));
System.out.println(mapList(list, User::getName));
System.out.println(mapSet(list, User::getName));
System.out.println("=======================================");
System.out.println(sumInteger(Arrays.asList(6, 9)));
System.out.println(sum(list, User::getCount, Integer::sum, 0));
System.out.println(sum(Arrays.asList(new BigDecimal(2), new BigDecimal(6)), BigDecimal::add, BigDecimal.ZERO));
}