Java8之Stream

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

什么是 Stream？

Stream（流）是一个来自数据源的元素队列并支持聚合操作：

• 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
• 数据源 流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。
• 聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。

和以前的Collection操作不同， Stream操作还有两个基础的特征：

• Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
• 内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。

流的创建

• stream() − 为集合创建串行流。
• parallelStream() − 为集合创建并行流。parallelStream其实就是一个并行执行的流.它通过默认的ForkJoinPool,可能提高你的多线程任务的速度。并行流在遍历时可能是无序的。

public class StreamTest {
    public static void main(String[] args) {
        //通过Arrays.stream创建流
        int[] intarr = {1,2,3,4,5,6};
        Arrays.stream(intarr).forEach(System.out::println);
        //通过Stream.of创建流
        Stream.of("a","b","c").forEach(System.out::println);
        //通过Collection的stream方法创建流
        List list = Arrays.asList("a","b","c");
        list.stream().forEach(System.out::println);
        //通过Stream.iterate方法创建流(不断循环创建出无限流)
        Stream.iterate(1,i->i+1).limit(5).forEach(System.out::println);
        //通过Stream.generate创建流(不断循环创建无限流)
        Stream.generate(()->1).limit(5).forEach(System.out::println);
    }
}

常用方法forEach、map、filter、limit、sorted、collect

forEach用来对stream中的数据进行迭代，传入一个Consumer参数：

void forEach(Consumersuper T> action);

//Consumer
@FunctionalInterface
public interface Consumer {
    void accept(T t);

    default Consumer andThen(Consumersuper T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

//例:以下两种方式效果相同，下面一种为lambda方法推导方式，写法更为简洁
//forEach方法传入一个Consumer接口实现类，流中的所有数据都依次执行Consumer中的accept方法
 Stream.of("a","b","c").forEach((str)-> System.out.println(str)); 
 Stream.of("a","b","c").forEach(System.out::println); 

filter 方法用于通过设置的条件过滤出元素

Stream filter(Predicatesuper T> predicate);

//Predicate
@FunctionalInterface
public interface Predicate {

    boolean test(T t);

    default Predicate negate() {
        return (t) -> !test(t);
    }

    default Predicate or(Predicatesuper T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static  Predicate isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

//filter中传入一个Predicate接口实现类//将流中等于"a"的字符串过滤出来
Stream.of("a","b","c").filter((str)>str.equals("a")).forEach(System.out::println);

map 方法用于映射每个元素到对应的结果，可以将提取集合类中某一个类型：

 Stream map(Functionsuper T, ? extends R> mapper);

//Function apply方法:传入参数类型T，返回结果类型R
@FunctionalInterface
public interface Function {

    R apply(T t);

    default  Function compose(Functionsuper V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default  Function andThen(Functionsuper R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static  Function identity() {
        return t -> t;
    }
}

//Apple类中有int类型weight和String类型color,提取出List中的所有weight
class Apple{
    private int weight;
    private String color;

    public Apple(int weight, String color) {
        this.weight = weight;
        this.color = color;
    }
    //省略getter、setter、toString
}

public class Java8T1 {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        for (int i=0;i<10;i++){
            list.add(new Apple(i,"color"+i));
        }
        System.out.println(list);
        List collect = list.stream().map((apple -> apple.getWeight())).collect(Collectors.toList());
        System.out.println(collect);
    }
}

//打印如下：
[Apple{weight=0, color='color0'}, Apple{weight=1, color='color1'}, Apple{weight=2, color='color2'}, Apple{weight=3, color='color3'}, Apple{weight=4, color='color4'}, Apple{weight=5, color='color5'}, Apple{weight=6, color='color6'}, Apple{weight=7, color='color7'}, Apple{weight=8, color='color8'}, Apple{weight=9, color='color9'}]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

limit 方法用于获取指定数量的流：

Stream limit(long maxSize);

//传入一个long类型数字，获取前面多少个数据
Stream.of("a","b","c").limit(2).forEach(System.out::print);

sorted 方法用于对流进行排序：

Stream sorted();
Stream sorted(Comparatorsuper T> comparator);

//无参数方法使用默认排序方法，有参数排序自定义排序规则
Stream.of(1,2,3,4,5).sorted().forEach(System.out::print);
System.out.println();
Stream.of(1,2,3,4,5).sorted((a,b)->b-a).forEach(System.out::print);

//打印如下
12345
54321

collect用于返回新的数据结构，在map方法中使用到了collect返回一个新的int类型List

 R collect(Collectorsuper T, A, R> collector);

 R collect(Supplier supplier,
                  BiConsumersuper T> accumulator,
                  BiConsumer combiner);

 R collect(Collectorsuper T, A, R> collector);

//可以转为其他数据结构
Set set = Stream.of(1, 2, 3, 4, 5).collect(Collectors.toSet());
List list = Stream.of(1, 2, 3, 4, 5).collect(Collectors.toList());