MyList

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

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
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.function.Supplier;
import java.util.stream.Collectors;

import org.springframework.util.CollectionUtils;

public class MyList<T> extends ArrayList<T> implements Serializable{
	private static final long serialVersionUID = 3824069159053424386L;
	
	@SafeVarargs
	public MyList(T... array){
		addAll(Arrays.asList(array));
	}
	
	public MyList(Collection<? extends T> c){
		addAll(c);
	}
	
	/**
     * 根据Function,返回List
     * @author peter
     * @param mapper Function<T,R> : 函数型接口
     */
	public <R> List<R> toList(Function<T, R> mapper) {
		if (CollectionUtils.isEmpty(this)) {
			return new ArrayList<>();
		}
		return this.stream().map(mapper).collect(Collectors.toList());
	}
	
	/**
     * 根据Function,返回Set
     * @author peter
     * @param mapper Function<T,R> : 函数型接口
     */
    public <R> Set<R> toSet(Function<T,R> mapper){
    	if(CollectionUtils.isEmpty(this)){
    		return new HashSet<>();
    	}
    	return this.stream().map(mapper).collect(Collectors.toSet());
    }
    
    /**
     * 根据Predicate,返回Set
     * @author peter
     * @param predicate Predicate<T> : 断言型接口
     */
    public Set<T> toPredicateSet(Predicate<T> predicate){
    	if(CollectionUtils.isEmpty(this)){
    		return new HashSet<>();
    	}
    	return this.stream().filter(predicate).collect(Collectors.toSet());
    }
    
    /**
     * 根据Predicate,返回List
     * @author peter
     * @param predicate Predicate<T> : 断言型接口
     */
    public List<T> toPredicateList(Predicate<T> predicate){
    	if(CollectionUtils.isEmpty(this)){
    		return new ArrayList<>();
    	}
    	return this.stream().filter(predicate).collect(Collectors.toList());
    }
    
    /**
     * 根据Function,BinaryOperator,返回Map
     * @author peter
     * @param valueMapper Function<T,R> : 函数型接口
     * @param keyMapper Function<T,U> : 函数型接口
     * @param mergeFunction BinaryOperator<U> : 断言型接口
     */
    public <R,U> Map<R, U> toMap(Function<T,R> keyMapper,Function<T,U> valueMapper,BinaryOperator<U> mergeFunction){
    	if(CollectionUtils.isEmpty(this)){
    		return new HashMap<>();
    	}
    	return this.stream().collect(Collectors.toMap(keyMapper, valueMapper,mergeFunction));
    }
    
    /**
     * 根据Function,BinaryOperator,返回Map
     * @author peter
     * @param list 数据数组
     * @param keyMapper Function<T,R> : 函数型接口
     */
    public <R> Map<R, T> toMap(Function<T,R> keyMapper,BinaryOperator<T> mergeFunction){
    	if(CollectionUtils.isEmpty(this)){
    		return new HashMap<>();
    	}
    	return this.stream().collect(Collectors.toMap(keyMapper, t -> t,mergeFunction));
    }
    
    /**
     * 根据Function组装对象,返回Map
     * @author peter
     * @param list 数据数组
     * @param keyMapper Function<T,R> : 函数型接口
     * @param valueMapper Function<T,U> : 函数型接口
     */
    public <R,U> Map<R, U> toMap(Function<T,R> keyMapper,Function<T,U> valueMapper){
    	if(CollectionUtils.isEmpty(this)){
    		return new HashMap<>();
    	}
    	return this.stream().collect(Collectors.toMap(keyMapper, valueMapper));
    }
    
    /**
     * 根据Function组装对象,返回Map
     * @author peter
     * @param list 数据数组
     * @param keyMapper Function<T,R> : 函数型接口
     */
    public <R> Map<R, T> toMap(Function<T,R> keyMapper){
    	if(CollectionUtils.isEmpty(this)){
    		return new HashMap<>();
    	}
    	return this.stream().collect(Collectors.toMap(keyMapper, e -> e));
    }
    
    /**
     * 根据Function进行分组,返回Map
     * @author peter
     * @param list 数据数组
     * @param mapper Function<T,R> 函数型接口
     */
    public <R> Map<R, List<T>> groupingBy(Function<T,R> mapper){
    	if(CollectionUtils.isEmpty(this)){
    		return new HashMap<>();
    	}
    	return this.stream().collect(Collectors.groupingBy(mapper));
    }
    
    /**
     * 根据Predicate,Function组装对象,返回Map
     * @author peter
     * @param predicate Predicate<T> : 断言型接口
     * @param keyMapper Function<T,R> : 函数型接口
     */
    public <R> Map<R, T> toPredicateMap(Predicate<T> predicate,Function<T,R> keyMapper){
    	if(CollectionUtils.isEmpty(this)){
    		return new HashMap<>();
    	}
    	return this.stream().filter(predicate).collect(Collectors.toMap(keyMapper, e -> e));
    }
    
	public <R> Collection<R> toCollection(Function<T, R> mapper,Supplier<Collection<R>> collectionFactory){
		return stream().map(mapper).collect(Collectors.toCollection(collectionFactory));
	}
    
}

 

转载于:https://my.oschina.net/u/2284316/blog/3097942