Stream 流是 Java 8 提供给开发者一套新的处理集合的API，他把我们将要处理的集合作为流，就像流水线一样，我们可以对其中的元素进行筛选，过滤，排序等中间操作，只不过这种操作更加简洁高效。
Stream的创建：
- 1.可以通过Collection系列的集合提供的stream()或者parallelStream()方法，集合的stream方法创建的是串行流，parallelStream方法创建的是并行流（并行流就是多线程进行操作，这个时候就要考虑线程安全问题了）
- 2.可以通过Arrays.stream()获取数组流
- 3.通过Stream类中的静态方法of()可以创建流对象
- 当创建一个无限流使用Stream.iterate()方法，是一个死循环
//Stream 的创建
//1.通过集合的stream()方法创建串行流
ArrayList<Object> list = new ArrayList<>();
Stream<Object> stream = list.stream();
//2.也可以通过集合的parallelStream创建并行流
Stream<Object> parallelStream = list.parallelStream();
//3.通过Arrays.stream(T[] t)，将数组转换成流
IntStream stream1 = Arrays.stream(new int[10]);
//4.通过Stream的静态方法of创建流
Stream<String> stringStream = Stream.of("aaa", "bbb", "ddd", "ccc");
//创建无限流 迭代
Stream<Integer> iterate = Stream.iterate(1, (x) -> x + 2);
iterate.limit(10).forEach(System.out::println);//生成奇数从一开始往后的10位
//生成
Stream.generate(()->(int)(Math.random()*100))//随机生成10个100以内的int类型数
.limit(10)
.forEach(System.out::println);
Stream的中间操作
多个中间操作可以连接起来形成一个流水线，除非流水线线上触发终止操作，否则中间操作就不会执行任何处理，并不会显示处理结果。而在终止操作时一次性全部处理，称为惰性求值。
- 筛选与切片
filter-接收Lambda，从流中排除某些元素
limit–截断流，使其元素不超过给定数量
skip(n) – 跳过元素，返回一个扔掉了前n个元素的流。若流中的元素个数小于n，则返回null，与limit()互补
distinct–筛选通过流所生成元素的hashCode(),equals()方法来去掉重复的元素
public class StreamAPITest {
List<Employee> employees = Arrays.asList(
new Employee("小明", 12000, 32),
new Employee("小红", 8000, 23),
new Employee("小刚", 5000, 19),
new Employee("小凉", 7000, 40),
new Employee("小凉", 7000, 40),
new Employee("小凉", 7000, 40)
);
@Test
public void test2() {
//filter是内部迭代，
//也就是StreamAPI内部实现的迭代不需要使用者再次手写迭代
employees.stream()
.filter((e) -> {
//System.out.println("进入过滤器");
return e.getSalary() > 7000.0;
})
.forEach((e) -> System.out.println(e.getSalary()));
System.out.println("-----------------------");
//测试limit(n)取前n个元素
employees.stream()
.limit(3)
.forEach((e) -> System.out.println(e));
System.out.println("-----------------------");
//skip(n)测试 舍掉前n个元素，去剩下后面的
employees.stream()
.skip(3)
.forEach((e) -> System.out.println(e));
System.out.println("=============================");
//distinct()去除重复，按照streamAPI中的hashCode和equals方法
employees.stream()
.distinct()
.forEach((e) -> System.out.println(e));
}
}
注意：distinct方法去除重复，需要实现pojo的hashCode()和equals().
控制台输出：
12000.0
8000.0
-----------------------
Employee{name='小明', salary=12000.0, age=32}
Employee{name='小红', salary=8000.0, age=23}
Employee{name='小刚', salary=5000.0, age=19}
-----------------------
Employee{name='小凉', salary=7000.0, age=40}
Employee{name='小凉', salary=7000.0, age=40}
Employee{name='小凉', salary=7000.0, age=40}
=============================
Employee{name='小明', salary=12000.0, age=32}
Employee{name='小红', salary=8000.0, age=23}
Employee{name='小刚', salary=5000.0, age=19}
Employee{name='小凉', salary=7000.0, age=40}
映射：
map——接收Lambda，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
flatMap——接收一个函数作为参数，将流中的每个值都转换成另一个流，然后把所有流连接成一个流。
public static Stream<Character> getCharacter(String str) {
List<Character> list = new ArrayList<>();
for (Character character : str.toCharArray()) {
list.add(character);
}
return list.stream();
}
@Test
public void test3() {
/**
* map,flapMap
*/
List<String> list = Arrays.asList("cvt", "aer", "ktv", "dbms");
//1.将list中的每个元素都转换成大写
list.stream()
.map((e) -> e.toUpperCase())
.forEach(System.out::println);
System.out.println("------水平分割线---------");
//2.取出employees中的每个员工姓名输出
employees.stream()
.map((e) -> e.getName())
.forEach(System.out::println);
System.out.println("------水平分割线---------");
Stream<Character> sm = list.stream()
.flatMap(StreamAPITest::getCharacter);
sm.forEach(System.out::println);
}
排序
这个默认的是从小到大，可以自定义排序
//排序
List<Integer> list = Arrays.asList(12, 32, 2, 45, 38, 29);
list.stream()
.sorted()
.forEach(System.out::println);//默认排序，从小到大
System.out.println("-------------------------");
//定制排序 employees 先按照月薪排序，如果月薪相等按照年龄排序
employees.stream()
.sorted((e1, e2) -> {
if (e1.getSalary() == e2.getSalary()) {
return e1.getAge().compareTo(e2.getAge()) ;
} else {
return e1.getSalary().compareTo( e2.getSalary());
}
})
.forEach(System.out::println);
运行结果：
12
29
32
38
45
-------------------------
Employee{name='小刚', salary=5000.0, age=19}
Employee{name='小凉', salary=7000.0, age=40}
Employee{name='小谷', salary=7000.0, age=20}
Employee{name='小红', salary=8000.0, age=23}
Employee{name='小明', salary=12000.0, age=32}
查找与匹配
allMatch ——检查是否匹配所有元素
anyMatch——检查是否至少匹配一个元素
noneMatch——检查是否没有匹配所有元素
findFirst——返回第一个元素
findAny——返回当前流中的任意元素
count——返回流中元素的总个数
max——返回流中最大值
min——返回流中最小值
private List<Employee> employees = Arrays.asList(
new Employee("小明", 12000.0, 32, Employee.Status.VOCATION),
new Employee("小红", 8000.0, 23, Employee.Status.FREE),
new Employee("小刚", 5000.0, 19, Employee.Status.BUSY),
new Employee("小凉", 7000.0, 40, Employee.Status.BUSY),
new Employee("小谷", 7000.0, 20, Employee.Status.FREE)
);
//匹配、查找、最大值、最小值、
@Test
public void test5() {
//allMatch,如果所有的元素都匹配返回true，否则返回false
boolean b1 = employees.stream()
.allMatch((e) -> {
return e.getStatus() == Employee.Status.BUSY;
});
System.out.println("b1 = " + b1);
//anyMatch 匹配中的任意元素满足条件返回true
boolean b2 = employees.stream()
.anyMatch((e) -> e.getStatus() == Employee.Status.VOCATION);
System.out.println("b2 = "+b2);
//noneMatch 如果所有元素都满足条件返回true，否则返回false
boolean b3 = employees.stream()
.noneMatch((e) -> e.getStatus() == Employee.Status.FREE);
//并不是所有的员工状态都是free所以返回false
System.out.println("b3 = "+b3);
//findFirst 查找第一个元素
Optional<Employee> employee1 = employees.stream()
.sorted((e1,e2)->-e1.getSalary().compareTo(e2.getSalary()))//salary 从高到低，返回最高工资的员工对象
.findFirst();
System.out.println("firstSalaryEmployee : "+employee1);
//findAny 返回当前流中任意一个元素
Optional<Employee> any = employees.parallelStream()//parallelStream 并行流
.findAny();
System.out.println("any : "+any);
//max
Optional<Employee> max = employees.stream()
.max((e1, e2) -> e1.getAge().compareTo(e2.getAge()));
System.out.println("max age employee "+max);
//min
Optional<Employee> min = employees.stream()
.min((e1, e2) -> e1.getAge().compareTo(e2.getAge()));
System.out.println("min age employee "+min);
//count
long count = employees.stream()
.count();
System.out.println("count: "+count);
}
运行结果输出：
b1 = false
b2 = true
b3 = false
firstSalaryEmployee : Optional[Employee{name='小明', salary=12000.0, age=32}]
any : Optional[Employee{name='小刚', salary=5000.0, age=19}]
max age employee Optional[Employee{name='小凉', salary=7000.0, age=40}]
min age employee Optional[Employee{name='小刚', salary=5000.0, age=19}]
count: 5
归约
reduce(T identity,BinaryOperator)
reduce(BinaryOperator)
作用：可以将流中元素反复结合起来，得到一个值。
List<Integer> list = Arrays.asList(23,12,3,45,67,29,98);
Integer sum = list.stream()
.reduce(0, (x, y) -> x + y);
System.out.println("sum = "+sum);
//先从employees中取出salary，然后reduce做处理，将员工工资求和
Optional<Double> optionalDouble = employees.stream()
.map(Employee::getSalary)
.reduce(Double::sum);
System.out.println(optionalDouble.get());
收集
collect——将流转成其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法。
public void test7(){
//收集员工名字返回集合
//返回List
List<String> names = employees.stream()
.map(Employee::getName)
.collect(Collectors.toList());
names.forEach(System.out::println);
//返回指定集合
HashSet<String> strings = employees.stream()
.map(Employee::getName)
.collect(Collectors.toCollection(HashSet::new));
System.out.println(strings);
}
结果：
小明
小红
小刚
小凉
小谷
[小刚, 小凉, 小谷, 小明, 小红]
使用collect从employees 中获取最大工资的人，最小工资，平均工资，员工工资总和，员工人数
@Test
public void test1() {
//count
Long count = employees.stream()
.collect(Collectors.counting());
System.out.println("count = " + count);
//max employee
Optional<Employee> maxSalary = employees.stream()
.collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
System.out.println(maxSalary.get());
//min
Optional<Employee> minSal = employees.stream()
.collect(Collectors.minBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
System.out.println(minSal.get());
//avg salary
Double avgSal = employees.stream()
.collect(Collectors.averagingDouble(Employee::getSalary));
System.out.println("avg salary = "+avgSal);
//sum salary
Double sumSal = employees.stream()
.collect(Collectors.summingDouble(Employee::getSalary));
System.out.println("sum salary = "+sumSal);
}
输出结果:
count = 5
Employee{name=‘小明’, salary=12000.0, age=32}
Employee{name=‘小刚’, salary=5000.0, age=19}
avg salary = 7800.0
sum salary = 39000.0
分组
@Test
public void test2(){
String collect = employees.stream()
.map(Employee::getName)
.collect(Collectors.joining(",","---","---"));//将取出的name连接在一起，中间用,隔开，前缀是‘---’,后缀也是'---'.
System.out.println(collect);
Map<Employee.Status, List<Employee>> collect1 = employees.stream()
.collect(Collectors.groupingBy(Employee::getStatus));
System.out.println("按状态分组："+collect1);
}
输出结果：
—小明,小红,小刚,小凉,小谷—
按状态分组：{BUSY=[Employee{name=‘小刚’, salary=5000.0, age=19}, Employee{name=‘小凉’, salary=7000.0, age=40}], VOCATION=[Employee{name=‘小明’, salary=12000.0, age=32}], FREE=[Employee{name=‘小红’, salary=8000.0, age=23}, Employee{name=‘小谷’, salary=7000.0, age=20}]}