StreamUtil

package com.haizol.mk.rfq.common.utils;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

import org.springframework.util.CollectionUtils;

/**
 * @Author: peter
 * @Date: 2019年8月12日
 */
public class StreamUtil {

    /**
     * 根據Function進行分組,返回Map
     * @author peter
     * @param list 數據數組
     * @param mapper Function<T,R> 函數型接口
     */
    public static <T, R> Map<R, List<T>> groupingBy(Collection<T> list,Function<T,R> mapper){
    	if(CollectionUtils.isEmpty(list)){
    		return new HashMap<>();
    	}
    	return list.stream().collect(Collectors.groupingBy(mapper));
    }
    
    /**
     * 根據Function組裝對象,返回Map
     * @author peter
     * @param list 數據數組
     * @param keyMapper Function<T,R> : 函數型接口
     * @param predicate Predicate<T> : 斷言型接口
     * @param keyMapper Function<T,R> : 函數型接口
     */
    public static <T, R> Map<R, T> toPredicateMap(Collection<T> list,Predicate<T> predicate,Function<T,R> keyMapper){
    	if(CollectionUtils.isEmpty(list)){
    		return new HashMap<>();
    	}
    	return list.stream().filter(predicate).collect(Collectors.toMap(keyMapper, e -> e));
    }
    
    /**
     * 根據Function組裝對象,返回Map
     * @author peter
     * @param list 數據數組
     * @param keyMapper Function<T,R> : 函數型接口
     */
    public static <T, R> Map<R, T> toMap(Collection<T> list,Function<T,R> keyMapper){
    	if(CollectionUtils.isEmpty(list)){
    		return new HashMap<>();
    	}
    	return list.stream().collect(Collectors.toMap(keyMapper, e -> e));
    }
    
    /**
     * 根據Function組裝對象,返回Map
     * @author P總
     * @param list 數據數組
     * @param keyMapper Function<T,R> : 函數型接口
     * @param valueMapper Function<T,U> : 函數型接口
     */
    public static <T, R,U> Map<R, U> toMap(Collection<T> list,Function<T,R> keyMapper,Function<T,U> valueMapper){
    	if(CollectionUtils.isEmpty(list)){
    		return new HashMap<>();
    	}
    	return list.stream().collect(Collectors.toMap(keyMapper, valueMapper));
    }
    
    /**
     * 根據Function,BinaryOperator組裝對象,返回Map
     * @author peter
     * @param list 數據數組
     * @param keyMapper Function<T,R> : 函數型接口
     */
    public static <T, R> Map<R, T> toMap(Collection<T> list,Function<T,R> keyMapper,BinaryOperator<T> mergeFunction){
    	if(CollectionUtils.isEmpty(list)){
    		return new HashMap<>();
    	}
    	return list.stream().collect(Collectors.toMap(keyMapper, t -> t,mergeFunction));
    }
    /**
     * 根據Function,BinaryOperator組裝對象,返回Map
     * @author coco
     * @param list 數據數組
     * @param keyMapper Function<T,R> : 函數型接口
     * @param valueMapper Function<T,U> : 函數型接口
     */
    public static <T, R,U> Map<R, U> toMap(Collection<T> list,Function<T,R> keyMapper,Function<T,U> valueMapper,BinaryOperator<U> mergeFunction){
    	if(CollectionUtils.isEmpty(list)){
    		return new HashMap<>();
    	}
    	return list.stream().collect(Collectors.toMap(keyMapper, valueMapper,mergeFunction));
    }
    
    /**
     * 獲得數組中的id,返回List
     * @author peter
     * @param list 數據數組
     * @param mapper Function<T,R> : 函數型接口
     */
    public static <T, R> List<R> toList(Collection<T> list,Function<T,R> mapper){
    	if(CollectionUtils.isEmpty(list)){
    		return new ArrayList<>();
    	}
    	return list.stream().map(mapper).collect(Collectors.toList());
    }
    
    /**
     * 獲得數組中的id,返回List
     * @author peter
     * @param list 數據數組
     * @param predicate Predicate<T> : 斷言型接口
     * @param mapper Function<T,R> : 函數型接口
     */
    public static <T, R> List<R> toList(Collection<T> list,Predicate<T> predicate,Function<T,R> mapper){
    	if(CollectionUtils.isEmpty(list)){
    		return new ArrayList<>();
    	}
    	return list.stream().filter(predicate).map(mapper).collect(Collectors.toList());
    }
    
    /**
     * 根據斷言函數接口,返回List
     * @author peter
     * @param list 數據數組
     * @param predicate Predicate<T> : 斷言型接口
     */
    public static <T> List<T> toPredicateList(Collection<T> list,Predicate<T> predicate){
    	if(CollectionUtils.isEmpty(list)){
    		return new ArrayList<>();
    	}
    	return list.stream().filter(predicate).collect(Collectors.toList());
    }
    
    /**
     * 獲得數組中的id,返回Set
     * @author peter
     * @param list 數據數組
     * @param mapper Function<T,R> : 函數型接口
     */
    public static <T, R> Set<R> toSet(Collection<T> list,Function<T,R> mapper){
    	if(CollectionUtils.isEmpty(list)){
    		return new HashSet<>();
    	}
    	return list.stream().map(mapper).collect(Collectors.toSet());
    }
    
    /**
     * 根據斷言函數接口,返回Set
     * @author peter
     * @param list 數據數組
     * @param predicate Predicate<T> : 斷言型接口
     */
    public static <T> Set<T> toPredicateSet(Collection<T> list,Predicate<T> predicate){
    	if(CollectionUtils.isEmpty(list)){
    		return new HashSet<>();
    	}
    	return list.stream().filter(predicate).collect(Collectors.toSet());
    }
    
}