JAVA8流的使用

一、筛选和切片

1. 用谓词筛选 ==filter(T -> T.getXX())==
2. 判断相同 ==distinct()==
3. 截断流 ==limit(n)==
4. 跳过元素 ==skip(n)==
5. 排序 ==sorted(Comparator.comparing(T::getXX))==
6. 遍历 ==forEach(XXX)==

二、映射

1. 对流中每一个元素应用函数 ==map()==
   ==> 一般用于提取流中的内容 map(T :: getXX)
2. 流的扁平化 ==flatMap()==
   ==> 将一个流中每个值都转换成另外一个流，然后再将转换的所有的流链接成一个流

三、查找与匹配

1. 查找至少一个匹配 ==anyMatch()==
2. 查找是全匹配 ==allMatch()==
   对应的无匹配是 ==noneMatch()==
3. 查找任意元素 ==findAny()==
4. 查找第一个元素 ==findFirst()==
5. 查找最小/最大的
   ==min(Comparator.comparing(T::getXX))==
   ==max(Comparator.comparing(T::getXX))==

四、归约

1. 求和 ==reduce(初始值,Integer :: sum)==

ins2.stream().reduce(0,Integer::sum)

不加初始值 返回Optional类型

1. 求最大最小 ==reduce(初始值,Integer :: sum)==

ins.stream().reduce(0,Integer::max)
ins.stream().reduce(0,Integer::min)

不加初始值 返回Optional类型

五、数值流

五A、原始类型流特化

1. 映射到数值流
   ==mapToInt(XX :: getX)==
   ==mapToDouble(XX :: getX)==
   ==mapToLong(XX :: getX)==

映射成功后 可以使用sum(),max(),min(),avg() 等方法

1. 转换为对象流 (类似装箱)
   ==boxed()==

2. 默认值
   ==OptionalInt==
   ==OptionalDouble==
   ==OptionalLong==

OptionalInt XX =trans.parallelStream().mapToInt(Transaction::getValue).max()
int max = XX.orElse(N)   拖过没有最大值，则为默认的N

五B、数值范围

IntStream和LongStream 有 方法

==range(m,n)==
==rangeClosed(m,n)==
对比是 后者包含n，前者不包含n

生成勾股数
Stream<double[]> sqrt = IntStream.rangeClosed(1, 100).boxed()
    .flatMap(a -> IntStream.rangeClosed(a, 100)
            .mapToObj(b -> new double[]{a,b,Math.sqrt(a*a + b*b)})
            .filter(t -> t[2] % 1 == 0));
sqrt.limit(10).forEach(t -> System.out.println((int)t[0] + "," + (int)t[1] + "," + (int)t[2]));

六、构建流

//1.由值创建流
Stream<String> s = Stream.of("1","2","3","6");
Stream<String> s2 = Stream.empty(); //创建空流
s.forEach(System.out::println);

//2.由数组创建流
int[] nums = { 11,60,61,12,16,20 };
int sum = Arrays.stream(nums).sum();

//3.由文件生成流
long lines = 0;
try (Stream<String> s3 = Files.lines(Paths.get("data.txt"),
        Charset.defaultCharset())) {
    lines = s3.flatMap(line -> Arrays.stream(line.split(""))).distinct().count();
} catch (Exception e) {
}
System.out.println(sum + "::" + lines);

//4.函数生成流
//4.1 迭代 iterate(n,lambda) 方法接受初始值，并将lambda作用于每个值
Stream.iterate(0, a -> a+2).limit(10).forEach(System.out::println);
//4.1.1 测试 斐波那契数列
Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1], t[0]+ t[1]})
        .limit(10).forEach(t -> System.out.print(t[0]+ " "));
Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1], t[0]+ t[1]})
.limit(10).map(t -> t[0] + " ").forEach(System.out::print);

//4.2 生成 generate 接受一个 Supplier<T> 类型 Lambda值
IntStream.generate(new IntSupplier() {
    public int getAsInt(){
        return 2;
    }
});
IntStream.generate(() -> 2).limit(10).forEach(System.out::print);;
//4.2.2 测试 斐波那契数列
IntStream.generate(new IntSupplier(){           
    private int a = 0;private int b = 1;
    public int getAsInt() {
        int oldPrevious = a;
        int nextValue = a + b;
        a = b;
        b = nextValue;
        return oldPrevious;}
    }).limit(10).forEach(System.out::println);