本篇文章参考云深i不知处的文章
原文链接：https://blog.csdn.net/mu_wind/article/details/109516995
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。
Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。
特点：
Stream 流可以通过集合和数组进行创建！
1、通过 java.util.Collection.stream() 方法用集合创建流
List<String> list = Arrays.asList("a", "b", "c");
//创建一个顺序流
Stream<String> stream = list.stream();
//创建一个并行流
Stream<String> stringStream = list.parallelStream();
2、使用 java.util.Arrays.stream(T[] array) 方法用数组创建流
int[] arra = {1, 3, 5, 6, 8};
IntStream stream = Arrays.stream(arra);
3、使用Stream的静态方法：of()、iterate()、generate()
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
Stream<Integer> limit = Stream.iterate(0, (x) -> x + 3).limit(4);
limit.forEach(System.out::println);
Stream<Double> limit1 = Stream.generate(Math::random).limit(3);
limit1.forEach(System.out::println);
结果：
0
3
6
9
0.8997037806521349
0.4208955236355437
0.5905370762238087
第一种创建方式：stream和parallelStream的简单区分： stream是顺序流，由主线程按顺序对流执行操作，而parallelStream是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。例如筛选集合中的奇数，两者的处理不同之处：
如果流中的数据量足够大，并行流可以加快处速度。
除了直接创建并行流，还可以通过parallel()把顺序流转换成并行流：
Optional<Integer> findFirst = list.stream()
.parallel().filter(x->x>6).findFirst();
在使用stream之前，先理解一个概念：Optional 。
Optional类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
Stream也是支持类似集合的遍历和匹配元素的，只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。
List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
//便利符合条件的字符串
list.stream().filter(x -> x > 6).forEach(System.out::println);
//匹配到第一个
Optional<Integer> first = list.stream().filter(x -> x > 6).findFirst();
//匹配任意（适用于并行流）
Optional<Integer> any = list.parallelStream().filter(x -> x > 6).findAny();
//是否包含特殊条件元素
boolean b = list.stream().anyMatch(x -> x > 6);
System.out.println("匹配到第一个 ==> " + first.get());
System.out.println("匹配任意（适用于并行流） ==> " + any.get());
System.out.println("是否包含特殊条件元素 ==> " + b);
运行结果：
7
9
8
匹配到第一个 ==> 7
匹配任意（适用于并行流） ==> 7
是否包含特殊条件元素 ==> true
筛选，是按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作。
案例一：筛选出Integer集合中大于6的元素，并打印出来
List<Integer> list = Arrays.asList(6,7,3,8,1,2,9);
Stream<Integer> stream = list.stream();
stream.filter(x -> x > 7).forEach(System.out::println);
结果：
8
9
案例二： 筛选员工中工资高于8000的人，并形成新的集合。 形成新集合依赖collect（收集）
private static List<Person> personList = new ArrayList<Person>();
static {
personList.add(new Person("Tom", 8900, 28, "male", "New York"));
personList.add(new Person("Jack", 7000, 18, "male", "Washington"));
personList.add(new Person("Lily", 7800, 8, "female", "Washington"));
personList.add(new Person("Anni", 8200, 38, "female", "New York"));
personList.add(new Person("Owen", 9500, 48, "male", "New York"));
personList.add(new Person("Alisa", 7900, 68, "female", "New York"));
}
@Test
public void getSalary() {
List<String> collect = personList.stream()
.filter(x -> x.getSalary() > 8000)
.map(Person::getName)
.collect(Collectors.toList());
System.out.println("高于8000薪资到人员信息 ==> " + collect);
}
}
结果：
高于8000薪资到人员信息 ==> [Tom, Anni, Owen]
max、min、count这些字眼你一定不陌生，没错，在mysql中我们常用它们进行数据统计。Java stream中也引入了这些概念和用法，极大地方便了我们对集合、数组的数据统计工作。
案例一：获取String集合中最长的元素。
@Test
public void listString() {
List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");
Optional<String> max = list.stream()
.max(Comparator.comparing(String::length));
System.out.println("最长的字符串 ==> " + max.get());
}
结果：
最长的字符串 ==> weoujgsd
案例二：获取Integer集合中的最大值。
@Test
public void listInteger() {
List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);
Optional<Integer> max = list.stream().max(Integer::compareTo);
Optional<Integer> max1 = list.stream().max(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
});
System.out.println("自然排序的最大值 ==> " + max.get());
System.out.println("自定义排序的最大值 ==> " + max1.get());
}
结果：
自然排序的最大值 ==> 11
自定义排序的最大值 ==> 11
案例三：获取员工工资最高的人。
private static List<Person> personList = new ArrayList<Person>();
static {
personList.add(new Person("Tom", 8900, 28, "male", "New York"));
personList.add(new Person("Jack", 7000, 18, "male", "Washington"));
personList.add(new Person("Lily", 7800, 8, "female", "Washington"));
personList.add(new Person("Anni", 8200, 38, "female", "New York"));
personList.add(new Person("Owen", 9500, 48, "male", "New York"));
personList.add(new Person("Alisa", 7900, 68, "female", "New York"));
}
@Test
public void getMaxSalary() {
Optional<Person> max = personList.stream()
.max(Comparator.comparingInt(Person::getSalary));
System.out.println("最高薪资到人员信息 ==> " + max.get());
}
结果：
最高薪资到人员信息 ==> Person(name=Owen, salary=9500, age=48, sex=male, area=New York)
案例四：计算Integer集合中大于6的元素的个数。
@Test
public void listIntegerCount() {
List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);
long count = list.stream().filter(x -> x > 6).count();
System.out.println("list中大于6的元素个数 ==> " + count);
}
结果：
list中大于6的元素个数 ==> 3
映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap：
map:接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。flatMap:接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
@Test
public void map() {
String[] strArr = { "abcd", "bcdd", "defde", "fTr" };
List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);
List<String> collect = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());
List<Integer> collect1 = intList.stream().map(x -> x + 3).collect(Collectors.toList());
System.out.println("每个元素大写：" + collect);
System.out.println("每个元素+3：" + collect1);
}
结果：
每个元素大写：[ABCD, BCDD, DEFDE, FTR]
每个元素+3：[4, 6, 8, 10, 12, 14]
案例二：将员工的薪资全部增加1000。
private static List<Person> personList = new ArrayList<Person>();
static {
personList.add(new Person("Tom", 8900, 28, "male", "New York"));
personList.add(new Person("Jack", 7000, 18, "male", "Washington"));
personList.add(new Person("Lily", 7800, 8, "female", "Washington"));
personList.add(new Person("Anni", 8200, 38, "female", "New York"));
personList.add(new Person("Owen", 9500, 48, "male", "New York"));
personList.add(new Person("Alisa", 7900, 68, "female", "New York"));
}
@Test
public void saveSalary() {
List<Person> collect = personList.stream().map(person -> {
person.setSalary(person.getSalary() + 1000);
return person;
}).collect(Collectors.toList());
collect.forEach(System.out::println);
}
结果：
Person(name=Tom, salary=9900, age=28, sex=male, area=New York)
Person(name=Jack, salary=8000, age=18, sex=male, area=Washington)
Person(name=Lily, salary=8800, age=8, sex=female, area=Washington)
Person(name=Anni, salary=9200, age=38, sex=female, area=New York)
Person(name=Owen, salary=10500, age=48, sex=male, area=New York)
Person(name=Alisa, salary=8900, age=68, sex=female, area=New York)
案例三：将两个字符数组合并成一个新的字符数组。
@Test
public void str() {
List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");
List<String> collect = list.stream().flatMap(s -> {
String[] split = s.split(",");
Stream<String> stream = Arrays.stream(split);
return stream;
}).collect(Collectors.toList());
System.out.println("处理前的集合：" + list);
System.out.println("处理后的集合：" + collect);
}
结果：
处理前的集合：[m,k,l,a, 1,3,5,7]
处理后的集合：[m, k, l, a, 1, 3, 5, 7]