java8新特性之Stream

Stream是java8新增的抽象类流 ，他提供了一些聚合操作，比如map,reduce,filter,forEach等，流并不存储数据，他是一个基于数据源的队列并支持聚合操作。这些聚合操作有个特点，他们的结果是一个新的流Stream，因此支持pipeline管道操作，在javascript中我们称之为链式(chain)操作，就像链条一样，可以将所有的操作串起来，最终得到一个需要的结果。

Lambda表达式也是java8新特性之一，可以将带参数的方法简化为表达式，这么做很简洁，代码量少，就是难以改变这种编程习惯。比如，整数求和，一般来说代码如下：

public static int add(int a,int b){
    return a + b;
}

如果使用表达式，就很简单了：

(a,b) -> a + b

这里需要介绍一下Stream的数据来源，他可以是集合List，也可以是数组[]，同时还可以是 IO Channel或者是产生器generator。以下方式都可以成为一个流Stream：

Arrays.asList(1,2,3).stream()

Stream.of(1,2,3)

流的操作map从字面意思来看就是一个映射，功能很简单，就是对每个队列元素做变换，成为一个新的Stream，他不会改变元素个数，但是有可能会改变元素的值。filter是过滤的意思，就是满足条件的会留下，他也是会生成一个新的Stream，他不会改变元素的值，但是可能会改变元素的个数，一般而言，过滤会有丢失的可能，因此元素个数会减少。flatMap从字面意思来看就是打平一个映射，将元素会经过一些变换会形成新的元素集合，再组合成一个大的新的集合，一般来说不仅会改变元素个数，还会改变元素的值，而且元素个数会增加。下面通过对别来说明他们三者的区别：

下面给出一个完整的示例，通过示例来看看Stream的一些功能：

package com.xxx.stream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class JDK8 {
	public static void streamOfTest(){
		List<Integer> list = Stream.of(1,3,4,5).collect(Collectors.toList());
		System.out.println(list);
		// [1,3,4,5]
	}
	
	public static void mapTest(){
		List<String> list = Stream.of("a","b","c").map(x->x+1).collect(Collectors.toList());
		System.out.println(list);
		// [a1,b1,c1]
	}
	
	public static void filterTest(){
		List<Integer> list = Stream.of(1,10,20,9,4).filter( x -> x > 10 ).collect(Collectors.toList());
		System.out.println(list);
		// [20]
	}
	
	public static void reduceTest(){
		int result = Arrays.asList(1,2,3,4).stream().reduce(0,(a,b) -> a + b);
		System.out.println(result);
		// 10
	}
	
	public static void forEachTest(){
		Stream.of(1,2,3).forEach(System.out::println);
		// 1
		// 2
		// 3
	}
	
	public static void sortTest(){
		Arrays.asList(4,5,3,2,1).stream().sorted().forEach(System.out::println);
		// 1
		// 2
		// 3
		// 4
		// 5
	}
	
	public static void limitTest(){
		Arrays.asList(4,5,3,2,1).stream().sorted().limit(4).forEach(System.out::println);
		// 1
		// 2
		// 3
		// 4
	}
	
	
	public static void map2IntTest(){
		List<Person> persons = new ArrayList<Person>();
		persons.add(new Person(18,60));
		persons.add(new Person(20,65));
		persons.add(new Person(32,80));
		persons.add(new Person(30,50));
		persons.add(new Person(20,60));
		persons.add(new Person(20,70));
		persons.add(new Person(20,75));
		persons.stream().filter(b->b.age==20)
		.sorted((x,y)->x.weight-y.weight)
		.mapToInt(a->a.weight).forEach(System.out::println);
		// 60
		// 65
		// 70
		// 75
	}
	
	public static void flatMapTest(){
		Stream.of("a b c d","e","f g").flatMap(x->Arrays.stream(x.split(" "))).forEach(System.out::println);
		// a
		// b
		// c
		// d
		// e
		// f
		// g
	}
	
	public static void distinctTest(){
		Stream.of("a","a","b","c","c").distinct().forEach(System.out::println);
		// a
		// b
		// c
	}
	
	public static void matchTest(){
		boolean all = Stream.of("b","aa","abc","a","ab","ac").allMatch(x->x.startsWith("a"));
		System.out.println("allMatch result : "+all); 
		// allMatch result : false
		
		boolean any = Stream.of("b","aa","ab","a","ab","ac").anyMatch(x->x.startsWith("a"));
		System.out.println("anyMatch result : "+any);  
		// anyMatch result : true
	}
	
	public static void main(String[] args) {
		//streamOfTest();
		//mapTest();
		//filterTest();
		//reduceTest();
		//forEachTest();
		//sortTest();
		//limitTest();
		//map2IntTest();
		//flatMapTest();
		//distinctTest();
		matchTest();
	}
}

class Person{
	int age;
	int weight;
	public Person(){}
	public Person(int age,int weight){
		this.age = age;
		this.weight = weight;
	}
}

 Stream能够很方便的操作集合或者数组，他的使用场合也很特殊，能够很简单的操作，而不需要定义一个新的方法来操作集合或者数组。