java stream流操作记录
1、把List转换为id字符串
例：
List contractIds = new ArrayList<>(Arrays.asList("1-5H4SR6", "1-5UFLJ0", "1-644HEY"));
String ids = "'"+contractIds.stream().collect(Collectors.joining("','"))+"'";
结果：‘1-5H4SR6’, ‘1-5UFLJ0’, ‘1-644HEY’
可以直接在mybatis中使用in（）进行查询
2、从List中获取name组成List类型
例：
List list = new ArrayList<>();
List names = list.stream().map(Student::getName).collect(Collectors.toList());
3、过滤集合数据（两种方式）
1、filter 例：
List manageSiteList = list.stream().filter(j -> BigDecimal.ZERO.compareTo(j.getBudgetAmount())!=0)
.collect(Collectors.toList());
2、removeif 例：
List list = new ArrayList<>();
List ids = new ArrayList<>();
list.removeIf(i->!ids.contains(i.getId()));
区别：
1.filter是对数组的过滤过滤之后返回一个对象本身用于聚合生成新的对象，并且它的判定方式是 false过滤。
2.removeIf和原先数组的remove如出一辙，都是直接对数组本身下手，对数组里的对象进行移除。参数为 true移除。
4、两个list根据某个字段取交集
例：
List list = new ArrayList<>();
for(int i=0;i<10;i++){
Student student = new Student(String.valueOf(i),"张"+i);
list.add(student);
}
List ids = Arrays.asList("1","2","3");
//交集list
List studentList = list.stream().filter(j->ids.contains(j.getAge())).collect(Collectors.toList());
5、计算list对象中某个值得和
例：
1、BigDecimal类型：
BigDecimal evSum = forecastOutsourceList.stream().map(CosFutureForecastOutsource::getEv).reduce(BigDecimal.ZERO,BigDecimal::add);
2、int类型：
IntStream id = list.stream().mapToInt(Student::getId);
int sum = id.sum();
3、其他double，long类似
6、下面是在网上找到的关于流的操作
一. 一般方法
首先我们先创建一个 Person 泛型的 List
List list = new ArrayList<>();
list.add(new Person("jack", 20));
list.add(new Person("mike", 25));
list.add(new Person("tom", 30));
Person 类包含年龄和姓名两个成员变量
private String name;
private int age;
1. stream() / parallelStream()
最常用到的方法，将集合转换为流
List list = new ArrayList();
// return Stream
list.stream();
而 parallelStream() 是并行流方法，能够让数据集执行并行操作，后面会更详细地讲解
2. filter(T -> boolean)
保留 boolean 为 true 的元素
保留年龄为 20 的 person 元素
list = list.stream()
.filter(person -> person.getAge() == 20)
.collect(toList());
打印输出 [Person{name='jack', age=20}]
collect(toList()) 可以把流转换为 List 类型，这个以后会讲解
3. distinct()
去除重复元素，这个方法是通过类的 equals 方法来判断两个元素是否相等的
如例子中的 Person 类，需要先定义好 equals 方法，不然类似[Person{name=‘jack’, age=20}, Person{name=‘jack’, age=20}] 这样的情况是不会处理的
4. sorted() / sorted((T, T) -> int)
如果流中的元素的类实现了 Comparable 接口，即有自己的排序规则，那么可以直接调用 sorted() 方法对元素进行排序，如 Stream
反之, 需要调用 sorted((T, T) -> int) 实现 Comparator 接口
根据年龄大小来比较：
list = list.stream()
.sorted((p1, p2) -> p1.getAge() - p2.getAge())
.collect(toList());
当然这个可以简化为
list = list.stream()
.sorted(Comparator.comparingInt(Person::getAge))
.collect(toList());
5. limit(long n)
返回前 n 个元素
list = list.stream()
.limit(2)
.collect(toList());
打印输出 [Person{name='jack', age=20}, Person{name='mike', age=25}]
6. skip(long n)
去除前 n 个元素
list = list.stream()
.skip(2)
.collect(toList());
打印输出 [Person{name='tom', age=30}]
tips:
用在 limit(n) 前面时，先去除前 m 个元素再返回剩余元素的前 n 个元素
limit(n) 用在 skip(m) 前面时，先返回前 n 个元素再在剩余的 n 个元素中去除 m 个元素
list = list.stream()
.limit(2)
.skip(1)
.collect(toList());
打印输出 [Person{name='mike', age=25}]
7. map(T -> R)
将流中的每一个元素 T 映射为 R（类似类型转换）
List newlist = list.stream().map(Person::getName).collect(toList());
newlist 里面的元素为 list 中每一个 Person 对象的 name 变量
8. flatMap(T -> Stream
将流中的每一个元素 T 映射为一个流，再把每一个流连接成为一个流
List list = new ArrayList<>();
list.add("aaa bbb ccc");
list.add("ddd eee fff");
list.add("ggg hhh iii");
list = list.stream().map(s -> s.split(" ")).flatMap(Arrays::stream).collect(toList());
上面例子中，我们的目的是把 List 中每个字符串元素以" "分割开，变成一个新的 List
9. anyMatch(T -> boolean)
流中是否有一个元素匹配给定的 T -> boolean 条件
是否存在一个 person 对象的 age 等于 20：
boolean b = list.stream().anyMatch(person -> person.getAge() == 20);
10. allMatch(T -> boolean)
流中是否所有元素都匹配给定的 T -> boolean 条件
11. noneMatch(T -> boolean)
流中是否没有元素匹配给定的 T -> boolean 条件
12. findAny() 和 findFirst()
findAny()：找到其中一个元素 （使用 stream() 时找到的是第一个元素；使用 parallelStream() 并行时找到的是其中一个元素）
findFirst()：找到第一个元素
值得注意的是，这两个方法返回的是一个 Optional，它是一个容器类，能代表一个值存在或不存在，这个后面会讲到
13. reduce((T, T) -> T) 和 reduce(T, (T, T) -> T)
用于组合流中的元素，如求和，求积，求最大值等
计算年龄总和：
int sum = list.stream().map(Person::getAge).reduce(0, (a, b) -> a + b);
与之相同:
int sum = list.stream().map(Person::getAge).reduce(0, Integer::sum);
其中，reduce 第一个参数 0 代表起始值为 0，lambda (a, b) -> a + b 即将两值相加产生一个新值
同样地：
计算年龄总乘积：
int sum = list.stream().map(Person::getAge).reduce(1, (a, b) -> a * b);
当然也可以
Optional sum = list.stream().map(Person::getAge).reduce(Integer::sum);
即不接受任何起始值，但因为没有初始值，需要考虑结果可能不存在的情况，因此返回的是 Optional 类型
14. count()
返回流中元素个数，结果为 long 类型
15. collect()
收集方法，我们很常用的是 collect(toList())，当然还有 collect(toSet()) 等，参数是一个收集器接口，这个后面会另外讲
16. forEach()
返回结果为 void，很明显我们可以通过它来干什么了，比方说：
### 16. unordered()
还有这个比较不起眼的方法，返回一个等效的无序流，当然如果流本身就是无序的话，那可能就会直接返回其本身
打印各个元素：
list.stream().forEach(System.out::println);
再比如说 MyBatis 里面访问数据库的 mapper 方法：
向数据库插入新元素：
list.stream().forEach(PersonMapper::insertPerson);
二. 数值流
前面介绍的如
int sum = list.stream().map(Person::getAge).reduce(0, Integer::sum);
计算元素总和的方法其中暗含了装箱成本，map(Person::getAge) 方法过后流变成了 Stream
针对这个问题 Java 8 有良心地引入了数值流 IntStream, DoubleStream, LongStream，这种流中的元素都是原始数据类型，分别是 int，double，long
1. 流与数值流的转换
流转换为数值流
mapToInt(T -> int) : return IntStream
mapToDouble(T -> double) : return DoubleStream
mapToLong(T -> long) : return LongStream
IntStream intStream = list.stream().mapToInt(Person::getAge)
;
当然如果是下面这样便会出错
LongStream longStream = list.stream().mapToInt(Person::getAge);
因为 getAge 方法返回的是 int 类型（返回的如果是 Integer，一样可以转换为 IntStream）
数值流转换为流
很简单，就一个 boxed
Stream stream = intStream.boxed();
2. 数值流方法
下面这些方法作用不用多说，看名字就知道：
sum()
max()
min()
average() 等...
3. 数值范围
IntStream 与 LongStream 拥有 range 和 rangeClosed 方法用于数值范围处理
IntStream ： rangeClosed(int, int) / range(int, int)
LongStream ： rangeClosed(long, long) / range(long, long)
这两个方法的区别在于一个是闭区间，一个是半开半闭区间：
rangeClosed(1, 100) ：[1, 100]
range(1, 100) ：[1, 100)
我们可以利用 IntStream.rangeClosed(1, 100) 生成 1 到 100 的数值流
求 1 到 10 的数值总和：
IntStream intStream = IntStream.rangeClosed(1, 10);
int sum = intStream.sum();
三. Optional 类
NullPointerException 可以说是每一个 Java 程序员都非常讨厌看到的一个词，针对这个问题， Java 8 引入了一个新的容器类 Optional，可以代表一个值存在或不存在，这样就不用返回容易出问题的 null。之前文章的代码中就经常出现这个类，也是针对这个问题进行的改进。
Optional 类比较常用的几个方法有：
isPresent() ：值存在时返回 true，反之 flase
get() ：返回当前值，若值不存在会抛出异常
orElse(T) ：值存在时返回该值，否则返回 T 的值
Optional 类还有三个特化版本 OptionalInt，OptionalLong，OptionalDouble，刚刚讲到的数值流中的 max 方法返回的类型便是这个
四.collect 收集数据
coollect 方法作为终端操作，接受的是一个 Collector 接口参数，能对数据进行一些收集归总操作
1. 收集
最常用的方法，把流中所有元素收集到一个 List, Set 或 Collection 中
toList
toSet
toCollection
List newlist = list.stream.collect(toList());
2. 汇总
（1）counting
用于计算总和：
long l = list.stream().collect(counting());
没错，你应该想到了，下面这样也可以：
long l = list.stream().count();
推荐第二种
（2）summingInt ，summingLong ，summingDouble
summing，没错，也是计算总和，不过这里需要一个函数参数
计算 Person 年龄总和：
int sum = list.stream().collect(summingInt(Person::getAge));
当然，这个可以也简化为：
int sum = list.stream().mapToInt(Person::getAge).sum();
除了上面两种，其实还可以：
int sum = list.stream().map(Person::getAge).reduce(Interger::sum).get();
推荐第二种
由此可见，函数式编程通常提供了多种方式来完成同一种操作
（3）averagingInt，averagingLong，averagingDouble
看名字就知道，求平均数
Double average = list.stream().collect(averagingInt(Person::getAge));
当然也可以这样写
OptionalDouble average = list.stream().mapToInt(Person::getAge).average();
不过要注意的是，这两种返回的值是不同类型的
（4）summarizingInt，summarizingLong，summarizingDouble
这三个方法比较特殊，比如 summarizingInt 会返回 IntSummaryStatistics 类型
IntSummaryStatistics l = list.stream().collect(summarizingInt(Person::getAge));
IntSummaryStatistics 包含了计算出来的平均值，总数，总和，最值，可以通过下面这些方法获得相应的数据
3. 取最值
maxBy，minBy 两个方法，需要一个 Comparator 接口作为参数
Optional optional = list.stream().collect(maxBy(comparing(Person::getAge)));
我们也可以直接使用 max 方法获得同样的结果
Optional optional = list.stream().max(comparing(Person::getAge));
4. joining 连接字符串
也是一个比较常用的方法，对流里面的字符串元素进行连接，其底层实现用的是专门用于字符串连接的 StringBuilder
String s = list.stream().map(Person::getName).collect(joining());
结果：jackmiketom
String s = list.stream().map(Person::getName).collect(joining(","));
结果：jack,mike,tom
joining 还有一个比较特别的重载方法：
String s = list.stream().map(Person::getName).collect(joining(" and ", "Today ", " play games."));
结果：Today jack and mike and tom play games.
即 Today 放开头，play games. 放结尾，and 在中间连接各个字符串
5. groupingBy 分组
groupingBy 用于将数据分组，最终返回一个 Map 类型
Map> map = list.stream().collect(groupingBy(Person::getAge));
例子中我们按照年龄 age 分组，每一个 Person 对象中年龄相同的归为一组
另外可以看出，Person::getAge 决定 Map 的键（Integer 类型），list 类型决定 Map 的值（List
多级分组
groupingBy 可以接受一个第二参数实现多级分组：
Map>> map = list.stream().collect(groupingBy(Person::getAge, groupBy(...)));
其中返回的 Map 键为 Integer 类型，值为 Map 按组收集数据 该例子中，我们通过年龄进行分组，然后 summingInt(Person::getAge)) 分别计算每一组的年龄总和（Integer），最终返回一个 Map 根据这个方法，我们可以知道，前面我们写的： 6. partitioningBy 分区 同样地 partitioningBy 也可以添加一个收集器作为第二参数，进行类似 groupBy 的多重分区等等操作。MapgroupingBy(Person::getAge)
其实等同于：
groupingBy(Person::getAge, toList())
分区与分组的区别在于，分区是按照 true 和 false 来分的，因此partitioningBy 接受的参数的 lambda 也是 T -> boolean根据年龄是否小于等于20来分区
Map