Stream+ lambda

创建list的时候很好用

noneMatch()判断是否全部不符合条件

collect

简单实例 Payment payment6 = payments                .stream()                .max(Comparator.comparing(Payment::getAmount)).get();

但是flatMap可以

font color=\"#ff0000\

定义冲突函数

key冲突的时候 会报错

limit(n)保留前n个元素

收集且去重

重排序 取前几

简单实例        Stream.of(\"a\

anyMatch()判断是否存在符合条件的相当于 if return true/false

终止操作

数组流 Arrays.stream(对象数组)

多层嵌套的实例:        companies.stream()                .flatMap(company4->company4.getDepartments().stream())                .flatMap(d -> d.getEmployees().stream())                .map(e-> e.getId())                .forEach(System.out::println);

引入Stream之后匿名内部类的实现

iterator创建迭代器

3: 步骤

按照序列号分组

summaringInt/Long/Double

引入Stream之前匿名内部类的实现

另外一种在并行流的情况下 保持顺序的方法

findFirst()返回第一个元素相当于 if break

实例:Set<String> collect = Stream.of(\"a\

本质和形式都是对类的实现以类为单位传递

无参数 + 无返回

时间线

Stream.of()

有foreach了为什么还需要迭代器? foreach的底层也是迭代器

中间操作(只有终止操作时才执行)

foreach执行遍历

引入Lambda解决的问题

收集为list

判断list里面有没有含有n的人名

订单数量大于50的有几个

收集操作

partitioningBy

将方法的书写形式简化成了 参数列表 -> 方法体 

count计数

处理多层嵌套的实体可以结合递归形成树

返回指定类型实例        String[] strings = Stream.of(\"a\

通用

2. 自带的函数式接口能满足多数情况

无限流Stream.iterate/generate

本质上: 对函数式接口的实现形式上:对方法的实现以方法为单位传递

简单的实例:        payments2.stream()                .flatMap(source->Stream.of(source.getAmount()))                 .forEach(System.out::println);

实例        Set<String> collect = Stream.of(\"a\

简单实例        Optional<Payment> fun = payments.stream() .map(source -> { if (source.getAmount() > 50L) { source.setSerial(\"幸运订单\"); } return source; }) .findFirst();

简单实例        Object[] objects = Stream.of(\"a\

2:组成和运作原理

比如取某时段订单列表的订单数量的最大/最小值 

join

简单的实例:        payments2.stream()                //正向排序写法//                .sorted(Comparator.comparing(payment -> payment.getAmount()))                //反向排序写法                .sorted(Comparator.comparing(Payment::getAmount).reversed())                .limit(3)                .map(payment -> payment.getSerial())                .forEach(System.out::println);

forEachOrdered有序遍历

有参数 + 有返回

创建流

reduce累计(迭代)计算器

1: 解决的痛点

        TreeSet<Integer> lambdaIntegers = new TreeSet<>(              font color=\"#00994d\

filter 过滤掉不符合元素

简单实例    @Test    public void testFindAnyAndFind(){        List<String> list = Arrays.asList(\"sunhcer\

toSet

简单实例        boolean n = list.stream() .anyMatch(source -> source.contains(\"n\"));

toMap

比如将某个前端穿过来的VO转换成数据实体

sorted重排序

优化

代替for循环求和等等

类中的方法结构

3. 新api的组合在 数据量大的情况下性能优异

简单实例        long count = payments.stream() .filter(source -> source.getAmount() > 50L) .count();

结果:单线程------fiadAny:sunhcer === findFirst:sunhcer多线程------findAny:nick === findFirst:sunhcer

groupingBy

toList

那匿名内部类又是对什么的优化

() -> sout();

中途停止

实例        List<String> list = Arrays.asList(\"aaa\

toArray收集成object数组

收集为数组

在50万个名字(并行流)中返回一个含有n的名字

1. 语法糖(让程序更加简洁，有更高的可读性的语法)

public void print(){  sout();  }

       实例 List<Company> collect = payments2.stream()                .map(source -> {                    Company company = new Company();                    company.setId(source.getSerial());                    return company;                }).collect(Collectors.toList());// 元素 payment类型转换成 Company类型        collect.stream().forEach(System.out::println);

传统的策略模式:策略接口:AreaStrategy实现类:1.  AreaStrategy44032.  AreaStrategy4403

min/max取最小/大

集合流 list.stream (如左例)

lambda中的对应的方法结构

anyMatch()判断是否全部符合条件