Stream流学习

什么是流（Stream）

是数据渠道，用于数据操作数据源（数组集合等等）所生成的元素序列。

• Stream 自己不会存储元素
• Stream 不会改变源对象。
• 操作延迟。

操作过程

● 创建Stream
一个数据源（集合、数组）获取一个流
● 中间操作
中间操作对数据进行处理(过滤等操作)
● 终止操作
产生结果的操作（如Sys.out.Prilntly）

创建流的几种方法

/**
* 创建流
*/
@Test
public void test01(){
    /**
    * 集合流
    *  - Collection.stream() 穿行流
    *  - Collection.parallelStream() 并行流
    */
    List<String> list = new ArrayList<>();
    Stream<String> stream1 = list.stream();

    //数组流
    //Arrays.stream(array)
    String[] strings = new String[10];
    Stream<String> stream2 = Arrays.stream(strings);

    //Stream 静态方法
    //Stream.of(...)
    Stream<Integer> stream3 = Stream.of(1, 2, 3);

    //无限流
    //迭代
    Stream<Integer> stream4 = Stream.iterate(0, (i) -> ++i+i++);
    stream4.forEach(System.out::println);

    //生成
    Stream.generate(() -> Math.random())
        .limit(5)
        .forEach(System.out::println);
}

中间操作

筛选

● filter：接收 Lambda ，从流中排除某些元素
● limit：截断流，使其元素不超过给定数量
● skip(n)：跳过元素，返回一个舍弃了前n个元素的流；若流中元素不足n个，则返回一个空流；与 limit(n) 互补
● distinct：筛选，通过流所生成的 hashCode() 与 equals() 取除重复元素

映射

● map：接收 Lambda ，将元素转换为其他形式或提取信息；接受一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
● flatMap：接收一个函数作为参数，将流中每一个值都换成另一个流，然后把所有流重新连接成一个流

查找终止操作

● allMatch：检查是否匹配所有元素
● anyMatch：检查是否至少匹配一个元素
● noneMatch：检查是否没有匹配所有元素
● findFirst：返回第一个元素
● findAny：返回当前流中的任意元素
● count：返回流中元素的总个数
● max：返回流中最大值
● min：返回流中最小值

归约/收集操作

● 归约：reduce(T identity, BinaryOperator) / reduce(BinaryOperator) 可以将流中的数据反复结合起来，得到一个值。
● 收集：collect 将流转换成其他形式；接收一个 Collector 接口的实现，用于给流中元素做汇总的方法。

Stream练习

package com.zgf.Stream;

import com.zgf.Lamada.Test1.Employee;
import org.junit.Before;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * @program: Java8New
 * @description:
 * @author: zhengguofeng
 * @create: 2020-10-14 21:09
 **/
public class Practice {

    @Test
    public void test1() {
        int aa[] = {1, 2, 3, 4, 5, 6};
        Arrays.stream(aa)
                .map(x -> x * x)
                .forEach(System.out::println);
    }

    List<Transation> transations = null;

    @Before
    public void chushihua() {
        Trader trader = new Trader("Adasdsa", "青岛");
        Trader trader1 = new Trader("Bdasdsad", "青岛");
        Trader trader2 = new Trader("Casdasd", "北京");
        Trader trader3 = new Trader("Edsadasd", "北京");
        Trader trader4 = new Trader("BSDASD", "上海");
        Trader trader5 = new Trader("asd", "上海");

        transations = Arrays.asList(new Transation(trader, 2011, 300),
                new Transation(trader1, 2010, 300),
                new Transation(trader2, 2012, 666),
                new Transation(trader3, 2013, 777),
                new Transation(trader4, 2012, 666),
                new Transation(trader5, 2011, 666)
        );
    }

    @Test
    public void test() {
        //1。找出2011年发生的所有交易，并按交易额排序（从低到高）
        System.out.println("-------------------找出2011年发生的所有交易，并按交易额排序（从低到高）--------------------------");
        transations.stream()
                .filter(x -> x.getYear() == 2011)
                .sorted((t, y) -> Integer.compare(t.getValue(), y.getValue()))
                .forEach(System.out::println);
        // 2．交易员都在哪些不同的城市工作过?
        System.out.println("---------------------交易员都在哪些不同的城市工作过?-------------------------");
        transations.stream()
                .map(x->x.getTrader().getCity())
                .distinct()
                .forEach(System.out::println);
        //3．查找所有来自剑桥的交易员，并按姓名排序
        System.out.println("---------------------查找所有来自青岛的交易员，并按姓名排序-------------------");
        transations.stream()
                .map(x->x.getTrader())
                .filter(y->y.getCity().equals("青岛"))
                .sorted((t1,t2)->t1.getName().compareTo(t2.getName()))
                .forEach(System.out::println);

        //4。返回所有交易员的姓名字符串，按字母顺序排序
        System.out.println("-------------------返回所有交易员的姓名字符串，按字母顺序排序-------------------");
        transations.stream()
                .map(t->t.getTrader().getName())
                .sorted()
                .forEach(System.out::println);

        String reduce = transations.stream()
                .map(t -> t.getTrader().getName())
                .sorted()
                .reduce("", (x, y) -> x + y);
        System.out.println(reduce);
        String collect = transations.stream()
                .map(t -> t.getTrader().getName())
                .sorted()
                .collect(Collectors.joining(","));
        System.out.println(collect);

        //5．有没有交易员是在米兰工作的?
        System.out.println("-------------------有没有交易员是在上海工作的?-------------------");
        boolean flag = transations.stream()
                .map(x -> x.getTrader())
                .anyMatch(x -> x.getCity().equals("上海"));
        System.out.println(flag);


        //6.打印生活在剑桥的交易员的所有交易额
        System.out.println("-------------------打印生活在北京的交易员的所有交易额-------------------");
        transations.stream()
                .filter(x -> x.getTrader().getCity().equals("北京"))
                .collect(Collectors.toList())
                .stream()
                .map(y->y.getValue())
                .forEach(System.out::println);
        //7。所有交易中，最高的交易额是多少
        System.out.println("-------------------所有交易中，最高的交易额是多少-------------------");
        Optional<Integer> max = transations.stream()
                .map(x -> x.getValue())
                .max(Integer::compare);
        System.out.println(max);
        //  8。找到交易额最小的交易
        System.out.println("-------------------找到交易额最小的交易-------------------");
 	 }
}

并行流 / 串行流

@Test
public void test03(){
    //串行流(单线程)：切换为并行流 parallel()
    //并行流：切换为串行流 sequential()
    LongStream.rangeClosed(0, 100000000L)
        .parallel() //底层：ForkJoin
        .reduce(0, Long::sum);

}