java集合之链式操作

[1,2,3].map(function(d){...}).grep(function(d){...}).join(‘,‘)

new CollectionPipe<Integer>(new Integer[]{1,2,3})
    .filter(new Filter<Integer>(){...})
    .map(new Mapper<Integer,String>(){...})
    .join(",")

/////////////

CollectionPipe.fromArray(new double[]{1.5d,1.6d,2.8d})
    .filter(new Filter<Double>(){...})
     .map(new Mapper<Double,Integer>(){...})
    .join(",")

// S--> 集合元素类型
public class CollectionPipe<S> {
	List<S> source=new ArrayList<S>();
	
	public CollectionPipe() {
		super();
	}
	public CollectionPipe(Collection<? extends S> collection) {
		super();
		source.addAll(collection);
	}
	public CollectionPipe(S[] array){
		super();
		for(S item:array)
			source.add(item);
	}
	
　　　　 // O-->映射后集合类型
	public <O> CollectionPipe<O> map(
			Mapper<S,O> mapper) {
		List<O> result=new ArrayList<O>();
		for(S item:source)
			result.add(mapper.map(item));
		return new CollectionPipe<O>(result);
	}
	
	public CollectionPipe<S> filter(Filter<S> filter){
		Iterator<S> it=source.iterator();
		while(it.hasNext()){
			if(!filter.filter(it.next()))
				it.remove();
		}
		return this;
	}
	
	public String join(String seg){
		String result="";
		if(source==null)
			return result;
		int index=0;
		for(Object o:source){
			index++;
			if(index==source.size())
				result+=String.valueOf(o);
			else
				result+=String.valueOf(o)+seg;
		}
		return result;
	}
	
	public List<S> getList() {
		return source;
	}
	
	public Set<S> getSet(){
		return new HashSet<S>(source);
	}
	
	public static CollectionPipe<Double> fromArray(double [] array){
		CollectionPipe<Double> result=new CollectionPipe<>();
		for(double item:array)
			result.source.add(item);
		return result;
	}
	
	public static CollectionPipe<Integer> fromArray(int [] array){
		CollectionPipe<Integer> result=new CollectionPipe<>();
		for(int item:array)
			result.source.add(item);
		return result;
	}
	

}

public interface Mapper<I,O> {
    O map(I item);
}

//true-->保留；false-->舍弃
public interface Filter<I> {
    boolean filter(I item);
}