jdk1.8 新特性_Steam1
2.1 创建流
// 集合创建流
List
// 获取一个顺序流
Stream
// 获取一个并行流
Stream
// 数组创建流
Integer[] nums = new Integer[] { 1, 2, 3, 4, 5 };
Stream<Integer> arrStream = Arrays.stream(nums);
arrStream.forEach(System.out::println);// 1 2 3 4 5
// 静态方法of创建流
Stream<Integer> ofStream = Stream.of(1, 2, 3, 4, 5);
ofStream.forEach(System.out::println);// 1 2 3 4 5
// 静态方法iterate 创建流
Stream<Integer> iterateStream = Stream.iterate(1, (x) -> x + 10).limit(4);
iterateStream.forEach(System.out::println); // 1 11 21 31
// 静态方法generate 创建流
Stream<Double> generateStream = Stream.generate(Math::random).limit(2);
generateStream.forEach(System.out::println);
2.2 操作流
1.过滤
filter：过滤流中的某些元素(可以做一些基本的判空、替换、判断逻辑操作)
limit(n)：获取n个元素，结果获取几个元素
skip(n)：跳过n元素，配合limit(n)可实现分页
distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素
//filter 判空
Stream<Integer> notNullStreamObj = Stream.of(1, 2, null, 4, 5, 6, 7, null, 2);
Stream<Integer> notNullStream = notNullStreamObj.filter(i -> (null != i));
notNullStream.forEach(System.out::println);//1 2 4 5 6 7 2
//filter 逻辑判断
Stream<Integer> logicStreamObj = Stream.of(1, 2, null, 4, 5, 6, 7, null, 2);
Stream<Integer> logicStream = logicStreamObj.filter(i -> (i != null && i > 5));
logicStream.forEach(System.out::println); // 6 7
//filter 替换
Stream<String> strStreamObj = Stream.of("aa", "ab", null, "ac", "bd", "ee");
Stream<String> strStream = strStreamObj.filter(str -> (null != str && str.contains("a")));
strStream.forEach(System.out::println); // aa ab ac
//skip 跳过
Stream<String> skipStreamObj = Stream.of("aa", "ab", null, "ac", "bd", "ee");
Stream<String> skipStream = skipStreamObj.skip(2);
skipStream.forEach(System.out::println); // null ac bd ee
//distinct 去重
Stream<String> disStreamObj = Stream.of("aa", "ab", null, "ac", "aa", "ab", null, "ee");
Stream<String> disStream = disStreamObj.distinct();
disStream.forEach(System.out::println); // aa ab null ac ee
4.流匹配
allMatch：接收一个 Predicate 函数，当流中每个元素都符合该断言时才返回true，否则返回false
noneMatch：接收一个 Predicate 函数，当流中每个元素都不符合该断言时才返回true，否则返回false
anyMatch：接收一个 Predicate 函数，只要流中有一个元素满足该断言则返回true，否则返回false
findFirst：返回流中第一个元素
findAny：返回流中的任意元素
count：返回流中元素的总个数
max：返回流中元素最大值
min：返回流中元素最小值
List<Integer> numLists = Arrays.asList(3, 4, 5, 6, 10);
// 全部匹配 - true
boolean allMatch1 = numLists.stream().allMatch(e -> e > 2); //true
System.out.println("allMatch1：" + allMatch1);
// 全部匹配 - true
boolean allMatch2 = numLists.stream().allMatch(e -> e > 5); //false
System.out.println("allMatch2：" + allMatch2);
// 全部都不符合 - true
boolean noneMatch = numLists.stream().noneMatch(e -> e > 20); //true
System.out.println("noneMatch：" + noneMatch);
// 任一元素符合 - true
boolean anyMatch = numLists.stream().anyMatch(e -> e > 4); //true
System.out.println("anyMatch：" + anyMatch);
//返回第一个
Integer findFirst = numLists.stream().findFirst().get(); //3
System.out.println("findFirst：" + findFirst);
//返回任一个
Integer findAny = numLists.stream().findAny().get();
System.out.println("findAny：" + findAny);
//返回 count
long count = numLists.stream().count(); //5
System.out.println("count：" + count);
//返回max
Integer max = numLists.stream().max(Integer::compareTo).get(); //10
System.out.println("max：" + max);
//返回min
Integer min = numLists.stream().min(Integer::compareTo).get();//3
System.out.println("min：" + min);
5.组合操作
Reduce 就是组合操作
Reduce（BinaryOperator accumulator） 没有起始值，按照运算规则进行运算操作
解释：第一次执行时，accumulator函数的第一个参数为流中的第一个元素，第二个参数为流中元素的第二个元素，按照函数进行操作；
第二次执行时，第一个参数为第一次函数执行操作的结果，第二个参数为流中的第三个元素；往下依次类推，返回Optinal 通过get()方法获取结果
Reduce（T identity, BinaryOperator accumulator）含有初始值，第二个是第一个的变形，跟第一个方法对比，不同的是此次这个会接受一个identity参数，用来指定Stream循环的初始值。如果Stream为空，就直接返回该值，特殊：该方法不会返回 Optional
Optional sumResult = Stream.of(1, 2, 3, 4)
.reduce((sum, item) -> {
System.out.println("sum : " + sum);
sum += item;
System.out.println("item: " + item);
System.out.println("sum+ : " + sum);
System.out.println("-----——---");
return sum;
});
System.out.println("========sumResult: " + sumResult.get());
Integer sumDefineResult = Stream.of(1, 2, 3, 4)
.reduce(100, (sum, item) -> {
System.out.println("sum : " + sum);
sum += item;
System.out.println("item: " + item);
System.out.println("sum+ : " + sum);
System.out.println("---——-----");
return sum;
});
System.out.println("========sumDefineResult: " + sumDefineResult);
- 收集转换操作
这是个最最最最最基本的操作，10个流操作 9个都会使用到当前操作
collect(Collectors.toList()) 转换List
collect(Collectors.toSet()) 转换Set
Collectors.toMap(key, value) 转换Map ，如果key重复，！！！报错
Collectors.joining() join进行拼接
Collectors.groupingBy(key) 以Key为map的 key分组
Collectors.partitioningBy(规则) 以规则分区 比如 >5 ，map key为true，false
User s1 = new User("aa", 1);
User s2 = new User("bb", 2);
User s3 = new User("cc", 3);
User s4 = new User("dd", 2);
List<User> list = Arrays.asList(s1, s2, s3, s4);
//转换list
List<Integer> ageList = list.stream().map(User::getAge).collect(Collectors.toList()); // [1, 2, 3]
System.out.println(ageList.toString());
//转成set
Set<Integer> ageSet = list.stream().map(User::getAge).collect(Collectors.toSet()); // [1, 2, 3]
System.out.println(ageSet);
//转成map,注:key不能相同，否则报错
Map<String, Integer> userMap = list.stream().collect(Collectors.toMap(User::getName, User::getAge)); // {cc=10, bb=20, aa=10}
System.out.println(userMap);
//字符串分隔符连接
String joinName = list.stream().map(User::getName).collect(Collectors.joining(",", "(", ")")); // (aa,bb,cc)
System.out.println(joinName);
//分组
Map<Integer, List<User>> ageMap = list.stream().collect(Collectors.groupingBy(User::getAge));
System.out.println(ageMap);
//多重分组,先根据类型分再根据年龄分
Map<Integer, Map<Integer, List<User>>> typeAgeMap = list.stream().collect(Collectors.groupingBy(User::getAge, Collectors.groupingBy(User::getAge)));
System.out.println(typeAgeMap);
//分区
//分成两部分，true 一部分age大于2岁， false 一部分age小于等于2岁
Map<Boolean, List<User>> partMap = list.stream().collect(Collectors.partitioningBy(v -> v.getAge() > 2));
System.out.println(partMap);
