java集合之链式操作

如果用过js/jquery、groovy等语言，大概对这样的代码比较熟悉：

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

这样的对集合的链式操作不仅书写方便，而且更方便阅读。在java8中使用集合流和lamda表达式也可以达到这个效果。

本文提供一个简单的工具类，用java模拟集合链式操作，可以在非java8-的环境中使用。

使用方法如下：

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);
}

读者可以自行扩展从不同的源生成pipe，或者加上并行功能。