Java 流处理

流是jdk8新增的一个特性。大概可以理解为将集合转为流，处理之后再转换成自己想要的其他类型。

对流的操作大概可以分成两类，中间操作和结束操作。

每次调用中间操作都会生成一个新的流，当结束操作执行时会触发实际运算，计算完成之后流就会失效。

Java的优点：

Stream不是一个数据结构，它应该可以说是数据源的视图，数据源可以是Java容器，数组等等。

Stream是惰式操作，Stream的操作并不会真正运行，而是要等到用户需要结果的时候才会运行

为函数编程而生。对stream的任何修改都不会影响背后的数据源，比如对Stream进行数据过滤操作并不会删除不符合条件的元素，而是会生成一个包含符合条件元素的新Stream。

可消费性。Stream只能被使用一次，一旦遍历之后就会失效，就像迭代器那样，需要使用就需要再次生成。

下面是一个网上的例子，我加了自己理解的注解。

public static void main(String[] args) {
    Trader raoul = new Trader("raoul", "Cambridge");
    Trader mario = new Trader("mario", "Milan");
    Trader alan = new Trader("alan", "Cambridge");
    Trader brian = new Trader("brian", "Cambridge");
    //交易记录
    List<Transaction> transactions = Arrays.asList(
            new Transaction(brian, 2011, 300),
            new Transaction(raoul, 2012, 1000),
            new Transaction(raoul, 2011, 400),
            new Transaction(mario, 2012, 710),
            new Transaction(mario, 2012, 700),
            new Transaction(alan, 2012, 950));

    //找出2011年发生的所有交易，并按金额从低到高排序
    //先过滤出时间不是2011的
    Stream<Transaction> transactionStream = transactions.stream().filter((t) -> t.getYear() == 2011);
    // 从低到高价格排序  最后把流转换成集合
    List<Transaction> collect = transactionStream.sorted(Comparator.comparing(Transaction::getValue)).collect(Collectors.toList());
     
    //将集合转换成流来进行分组 会得到一个map集合。
    Map<Integer, Long> collect2 = transactions.stream().collect(Collectors.groupingBy(Transaction::getYear, Collectors.counting()));


    //查看交易员在哪些城市
    //先从集合中映射出交易员 再映射出城市名 再去重 再转成集合
    List<String> collect3 = transactions.stream().map(Transaction::getTrader).map(Trader::getCity).distinct().collect(Collectors.toList());
    collect.forEach(System.out::println);

    //查找出所有来自剑桥的员工 并按姓名排序
    //先映射出交易员 再映射出城市名 再过滤 再排序 再转换
    List<Trader> collect4 = transactions.stream().map(Transaction::getTrader).filter((t) -> t.getCity().equals("Cambridge")).distinct().sorted(Comparator.comparing(Trader::getName)).collect(Collectors.toList());

    //返回所有交易员的姓名字符串 并按姓名排序
    // a一开始变量为 "" 使用一个字符串相加  最后结果一定是字符串。
    //一个集合里求和的常用逻辑为 ""为list[0]  list[0]+list[1]+list[2]+....list[n-1]
    String reduce = transactions.stream().map((t) -> t.getTrader().getName()).sorted().reduce("", (a, b) -> a + b);
    System.out.println(reduce);

    //有没有交易员在米兰工作过
    //先映射出交易员 再匹配有没有城市是milan
    boolean milan = transactions.stream().map(Transaction::getTrader).anyMatch(t -> t.getCity().equals("Milan"));
    System.out.println("有没有员工在米兰工作过:" + milan);

    //打印所有在剑桥的交易员的所有交易额 2650
    //先过滤掉城市不是剑桥的 然后映射出Value 最后取和
    transactions.stream().filter(t->t.getTrader().getCity().equals("Cambridge")).map(Transaction::getValue).reduce(0,(a,b)->a+b);

    //所有得交易额中 最高的交易额
    //先对交易额进行排序（reversed()降序） 然后映射出交易额 取第一个
    List<Integer> collect1 = transactions.stream().sorted(Comparator.comparing(Transaction::getValue).reversed()).map(Transaction::getValue).limit(1).collect(Collectors.toList());
    //升级
    transactions.stream().map(Transaction::getValue).reduce(Integer::max);
    //升级
    transactions.stream().max(Comparator.comparing(Transaction::getValue));

    //找到最小的交易额
    transactions.stream().map(Transaction::getValue).reduce(Integer::min);
    //升级
    transactions.stream().min(Comparator.comparing(Transaction::getValue));
}