Stream流

Java 8 API添加了一种新的机制——Stream（流）。Stream和IO流不是一回事。

流式思想：像生产流水线一样，一个操作接一个操作。

使用Stream流的步骤：数据源→转换成流→操作1→操作2→……

数据源（source）：可以是集合、数组等。

Stream操作有两个基础特征：
(1)Pipelining（流水线）：流操作会返回流对象（新的对象），以便后续继续进行流操作。
(2)内部迭代：不需要像for循环或Iterator一样进行显式的迭代。

import java.util.*;
public class TestStream {
    public static void main(String[] args) {
        List<String> lst = new ArrayList<>();
        lst.add("孙悟空");
        lst.add("猪八戒");
        lst.add("沙僧");
        lst.add("唐僧");
        // 需求：(1)筛选名字是3个字的人,(2)输出结果
        System.out.println("-----流式写法");
        // .stream():把集合转换成流
        // .filter的参数是Predicate接口，抽象方法test()方法用于判断
        // .forEach的参数是Consumer接口，抽象方法accept()用于接受数据
        lst.stream().filter(name -> name.length() == 3)
                .forEach(name -> System.out.println(name));
        System.out.println("------ 方法引用(关注做什么，不管怎么做)");
        printStr(s -> System.out.println(s), "Lambda");
        printStr(System.out::println, "方法引用");
    }
    static void printStr(Printable p, String s) {
        p.print(s);
    }
}
interface Printable {
    void print(String s);
}

-----流式写法
孙悟空
猪八戒
------ 方法引用(关注做什么，不管怎么做)
Lambda
方法引用

获取流

import java.util.*;
import java.util.Map.Entry;
import java.util.stream.Stream;
public class GetStream {
    public static void main(String[] args) {
        // List和Set
        Collection<String> c = new ArrayList<>();
        Stream stream = c.stream();
        // Map(分k,v,k&v三种)
        Map<String, String> map = new HashMap<>();
        Stream<String> stream2 = map.keySet().stream();
        Stream<String> stream3 = map.values().stream();
        Stream<Entry<String, String>> stream4 = map.entrySet().stream();
        // 数组
        Integer[] arr = { 1, 2, 3, 4, 5 };
        Stream<Integer> stream5 = Stream.of(arr);
    }
}

常用方法

延迟方法：返回值还是Stream接口类型。
终结方法：返回类型不是Stream。如count和forEach。

import java.util.stream.Stream;
public class TestStream {
    public static void main(String[] args) {
        System.out.println("-- void forEach(Consumer),accept(T)获取参数");
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
        stream.forEach(e -> System.out.println(e));
        // -------------
        System.out.println("-- Stream filter(Predicate),test(T)用于判断");
        // 必须重新获取流，因为Stream只能被使用一次，数据流到下一个Stream上。
        // 如果不重新获取，会得到异常：stream has already been operated upon or closed
        stream = Stream.of(1, 2, 3, 4, 5);
        Stream<Integer> stream2 = stream.filter(e -> e % 2 == 0);
        stream2.forEach(e -> System.out.println(e));
        // -------------
        stream = Stream.of(1, 2, 3, 4, 5);
        System.out.println("-- Stream map(Function),R apply(T t)，类型转换");
        Stream<String> stream3 = stream.map(n -> "第" + n);
        stream3.forEach(e -> System.out.println(e));
        // -------------
        stream = Stream.of(1, 2, 3, 4, 5);
        System.out.println("-- Stream limit(long maxSize):取前maxSize个");
        Stream<Integer> limit = stream.limit(3);
        limit.forEach(e -> System.out.println(e));
        // -------------
        stream = Stream.of(1, 2, 3, 4, 5);
        System.out.println("-- Stream skip(long n):跳过前n个");
        Stream<Integer> skip = stream.skip(1);
        skip.forEach(e -> System.out.println(e));
        // -------------
        stream = Stream.of(1, 2, 3, 4, 5);
        Stream<Integer> stream4 = Stream.of(11, 12, 13);
        System.out.println("-- Stream concat(Stream a, Stream b):二流归一");
        Stream<Integer> concat = Stream.concat(stream, stream4);
        concat.forEach(e -> System.out.println(e));
        // -------------
        stream = Stream.of(1, 2, 3, 4, 5);
        System.out.println("-- long count():终结方法");
        long count = stream.count();
        System.out.println(count);
    }
}

-- void forEach(Consumer),accept(T)获取参数
1
2
3
4
5
-- Stream filter(Predicate),test(T)用于判断
2
4
-- Stream map(Function),R apply(T t)，类型转换
第1
第2
第3
第4
第5
-- Stream limit(long maxSize):取前maxSize个
1
2
3
-- Stream skip(long n):跳过前n个
2
3
4
5
-- Stream concat(Stream a, Stream b):二流归一
1
2
3
4
5
11
12
13
-- long count():终结方法
5

Java基础教程——Stream

原文：https://www.cnblogs.com/tigerlion/p/11182866.html