Java8中的Stream流式运算大全实战
package com.stu;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import javax.persistence.criteria.CriteriaBuilder;
import java.lang.reflect.Array;
import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
@SpringBootTest
class DemoApplicationTests {
@Test
void contextLoads() {
}
@Test
void test(){
List collect = Stream.of(601,
701).collect(Collectors.toList());
collect.add(501);
// System.out.println(collect);
List integers = Arrays.asList(601, 701);
/*
* 流式运算
* 1. 获取数据集
* 2. 数据集处理
* 3. 返回处理后的数据集合
* */
List intList = Arrays.asList(1, 3, 5);
//获取数据集
Stream stream = intList.stream();
//数据集处理
Stream doubleStream = stream.filter(num->num <= 3);
//获取处理后得数据集合
List collect1 = doubleStream.collect(Collectors.toList());
System.out.println("collect1:"+collect1);
//流式流式运算中的filter数据集过滤
List collect2 = Arrays.asList("wp", "wwp", "wwpp","wwpptt","wwppdd").stream()
.filter(str -> str.length() >= 3)
.filter(str -> str.contains("pp"))
.collect(Collectors.toList());
System.out.println("collect2:"+collect2);
//流式运算中的and 、or 源码：Stream filter(Predicate predicate);
//构造Predicate对象
Predicate predicate = str -> str.length() >= 3;
Predicate predicate1 = str -> str.contains("pp");
Predicate predicate2 = str -> str.contains("dd");
List collect3 = Arrays.asList("wp", "wwp", "wwpp","wwpptt","wwppdd").stream()
.filter(predicate.and(predicate1).or(predicate2))
.collect(Collectors.toList());
System.out.println("collect3:"+collect3);
//流式运算中的foreach遍历
Arrays.asList("wp", "wwp", "wwpp","wwpptt","wwppdd").stream()
.filter(str->str.length()>=3)
.forEach(list-> System.out.println("hello:"+list));
//流式运算中的排序 sorted()默认升序 , 改变排序要求选择有参 sorted(Comparator comparator)
System.out.println("----------------默认排序：升序---------------------");
Arrays.asList(1,5,4,7,3,9,6).stream()
.filter(num->num!=1)
.sorted()
.forEach(num-> System.out.println(num));
System.out.println("----------------降序---------------------");
Arrays.asList(1,5,4,7,3,9,6).stream()
.filter(num->num!=1)
.sorted(Comparator.reverseOrder())
.forEach(num-> System.out.println(num));
System.out.println("----------------升序---------------------");
Arrays.asList(1,5,4,7,3,9,6).stream()
.filter(num->num!=1)
.sorted(Comparator.naturalOrder())
.forEach(num-> System.out.println(num));
System.out.println("----------------将空元素认为小于非空元素后降序---------------------");
Arrays.asList("wp", "wwp", "pp","wwpptt","wwppdd","w",null).stream()
.sorted(Comparator.nullsFirst(Comparator.naturalOrder()))
.forEach(num-> System.out.println(num));
System.out.println("----------------按指定的对象的某个属性排序:按字符串长度排序---------------------");
Arrays.asList("wp", "wwp", "pp","wwpptt","wwppdd","w").stream()
.sorted(Comparator.comparing(String::length))
.forEach(num-> System.out.println(num));
System.out.println("-------------distinct:剔除重复值------------------------");
Arrays.asList("wp", "wp", "pp","pp","tt","w").stream()
.sorted(Comparator.comparing(String::length))
.distinct()
.forEach(num-> System.out.println(num));
System.out.println("-------------limit:截取前3（maxSize）个元素，如果流中元素数量小于maxSize，那就取实际数量的元素放到新流中返回------------------------");
Arrays.asList("wp", "wp", "pp","pp","tt","w").stream()
.sorted(Comparator.comparing(String::length))
.limit(3)
.forEach(num-> System.out.println(num));
System.out.println("--------------max、min返回最大值最小值-----------------------");
String max = Arrays.asList("wpp", "wp", "pp", "pp", "tt", "w").stream()
.max(Comparator.comparing(String::length)).get();
System.out.println(max);
/// map理解(重点)
// stream()优点
// 无存储。stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。
// 为函数式编程而生。对stream的任何修改都不会修改背后的数据源，比如对stream执行过滤操作并不会删除被过滤的元素，而是会产生一个不包含被过滤元素的新stream。
// 惰式执行。stream上的操作并不会立即执行，只有等到用户真正需要结果的时候才会执行。
// 可消费性。stream只能被“消费”一次，一旦遍历过就会失效，就像容器的迭代器那样，想要再次遍历必须重新生成。
System.out.println("--------------map()-----------------------");
Arrays.asList("wp", "wp", "pp","pp","tt","w").stream()
.map(x->x+"wwww"
)
.limit(3)
.forEach(num-> System.out.println(num));
//flatMap()简单来说就是将多个stream流合并成一个stream，当然你也可以在合并的时候结合其他的API做一些过滤或者转换之类的，如filter
System.out.println("--------------flatMap()-----------------------");
List> lists = new ArrayList<>();
List arrayList = new ArrayList<>();
arrayList.add(1);
arrayList.add(3);
arrayList.add(22);
arrayList.add(11);
arrayList.add(44);
arrayList.add(null);
arrayList.add(4);
lists.add(arrayList);
// List arrayList2 = JSON.parseArray(JSON.toJSONString(arrayList), Integer.class);
List arrayList2 = new ArrayList<>();
arrayList2.add(55);
lists.add(arrayList2);
// List arrayList3 = JSON.parseArray(JSON.toJSONString(arrayList), Integer.class);
List arrayList3 = new ArrayList<>();
arrayList3.add(99);
arrayList3.add(-2);
lists.add(arrayList3);
//将子集合抽上来形成一个大集合
List collectList = lists.stream().flatMap(item -> item.stream().filter(Objects::nonNull))
.collect(Collectors.toList());
System.out.println(collectList);
}
}
运行结果
collect1:[1, 3]
collect2:[wwpp, wwpptt, wwppdd]
collect3:[wwpp, wwpptt, wwppdd]
hello:wwp
hello:wwpp
hello:wwpptt
hello:wwppdd
----------------默认排序：升序---------------------
3
4
5
6
7
9
----------------降序---------------------
9
7
6
5
4
3
----------------升序---------------------
3
4
5
6
7
9
----------------将空元素认为小于非空元素后降序---------------------
null
pp
w
wp
wwp
wwppdd
wwpptt
----------------按指定的对象的某个属性排序:按字符串长度排序---------------------
w
wp
pp
wwp
wwpptt
wwppdd
-------------distinct:剔除重复值------------------------
w
wp
pp
tt
-------------limit:截取前3（maxSize）个元素，如果流中元素数量小于maxSize，那就取实际数量的元素放到新流中返回------------------------
w
wp
wp
--------------max、min返回最大值最小值-----------------------
wpp
-------------forEach以后不可以再对数据集进行操作，因此需要map------------------------
hellow
hellowp
hellowp