强大的Stream API
了解Stream
Java8中有两个最为重要的改变。第一个是Lambda表达式;另外一个则是Stream API(java.util.stream.*)。
Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行数据库查询，也可以使用Stream API来并行执行操作。简而言之，Stream API提供了一种高效且易于使用的处理数据的方式。
什么是Stream
Stream操作的三个步骤：
创建流四种方式：
@Test
public void test1() {
//1.可以通过Collection系列集合提供的Stream()或parallelStream()
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
//2.通过Arrays中的静态方法Stream()可以来获取一个数组流
Employee[] emps = new Employee[10];
Stream<Employee> stream2 = Arrays.stream(emps);
//3.通过Stream类里面的静态方法of()来创建流
Stream<String> stream3 = Stream.of("aa", "bb", "cc");
//4.创建无限流
//4.1迭代
Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2);
//我们可以来个终止的操作来看一下效果
stream4.limit(10).forEach(System.out::println);
//4.2生成
Stream<Double> stream5 = Stream.generate(() -> (double) Math.random());
stream5.limit(5)
.forEach(System.out::println);
}
Stream_筛选与切片
筛选与切片
- filter——接收 Lambda ， 从流中排除某些元素。
- limit——截断流，使其元素不超过给定数量。
- skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
- distinct——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
我们需要注意的是：
- 多个中间操作可以连接起来形成一个流水线，除非流水线上触发了终止操作，否则中间操作不会执行任何的处理！而是在终止操作时一次性全部处理，称为惰性求值。
- 内部迭代：迭代操作是由Stream API来进行操作
(一）filter:接收 Lambda ， 从流中排除某些元素
上面的写法就是一个内部的迭代，它是由Stream API来进行完成;
而我们的外部迭代可以这样来写：
@Test
public void test2() {
Iterator<Employee> it = employees.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
（二）limit——截断流，使其元素不超过给定数量
limit有一个短路的特性：只要找到了符合我们的数据结果，就不再进行迭代的操作，可以提高执行的效率
代码如下：
@Test
public void test3() {
employees.stream()
.filter((e)->e.getSalary()>5000)
.limit(2)
.forEach(System.out::println);
}
执行结果如下图：
（三）skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
代码如下：
//中间操作
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66),
new Employee(101, "张三", 18, 9999.99),
new Employee(103, "王五", 28, 3333.33),
new Employee(104, "赵六", 8, 7777.77),
new Employee(104, "赵六", 8, 7777.77),
new Employee(104, "赵六", 8, 7777.77),
new Employee(105, "田七", 38, 5555.55));
@Test
public void test4() {
employees.stream()
.filter((e) -> e.getSalary() > 5000)
.skip(2)
.forEach(System.out::println);
}
效果如下图：
（四）distinct——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
需要注意的地方：要是想要去重，所去重的对象必须要重写hashCode() 和 equals() ：
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee employee = (Employee) o;
return id == employee.id &&
age == employee.age &&
Double.compare(employee.salary, salary) == 0 &&
Objects.equals(name, employee.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name, age, salary);
}
如下图：
Stream_映射
映射
- map——接收 Lambda ， 将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
- flatMap——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
map映射的初体验：
@Test
public void test7() {
List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
list.stream()
.map((str)-> str.toUpperCase())
.forEach(System.out::println);
}
效果如下：
我们经常会遇到的一个需求：提取员工的名字
效果如下图：
现在我们写上一个方法：传入一个字符串，把它转为字符数组，并把它放入到集合当中：这个方法返回的是一个Stream流，这个时候，如果我们想要对其进行遍历 ，那么我们要进行两次的Stream的遍历，非常的麻烦：
//中间操作
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66),
new Employee(101, "张三", 18, 9999.99),
new Employee(103, "王五", 28, 3333.33),
new Employee(104, "赵六", 8, 7777.77),
new Employee(104, "赵六", 8, 7777.77),
new Employee(104, "赵六", 8, 7777.77),
new Employee(105, "田七", 38, 5555.55)
);
//flatMap-接受一个新的函数作为参数，接流中的每一个值都作为另外一个流，然后把所有的流连接为一个流
@Test
public void test9() {
List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
Stream<Stream<Character>> stream = list.stream()
.map(TestStreamAPI2::filterCharacher);
stream.forEach((sm)->{
sm.forEach(System.out::println);
});
}
//这个就是传入一个字符串，转为字符数组，并存入到一个集合中
public static Stream<Character> filterCharacher(String str) {
List<Character> list = new ArrayList<>();
for (Character ch : str.toCharArray()) {
list.add(ch);
}
return list.stream();
}
这个时候，我们就是可以用到flatMap来进行操作：
这个时候，我们就是可以这样来写：
//中间操作
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66),
new Employee(101, "张三", 18, 9999.99),
new Employee(103, "王五", 28, 3333.33),
new Employee(104, "赵六", 8, 7777.77),
new Employee(104, "赵六", 8, 7777.77),
new Employee(104, "赵六", 8, 7777.77),
new Employee(105, "田七", 38, 5555.55)
);
@Test
public void test10() {
List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
list.stream()
.flatMap(TestStreamAPI2::filterCharacher)
.forEach(System.out::println);
}
//这个就是传入一个字符串，转为字符数组，并存入到一个集合中
public static Stream<Character> filterCharacher(String str) {
List<Character> list = new ArrayList<>();
for (Character ch : str.toCharArray()) {
list.add(ch);
}
return list.stream();
}
map和flatMap就类似于集合当中的add()方法和addAll()，如果add(List list),那么这个时候，是把list当作一个元素添加进去，而addAll(List list)是把这个list集合里面的所有元素添加进去;
map就是相当于把一个一个的流添加的流中，而flatMap是把流中的一个一个的元素添加到流中;
Stream_排序
排序
- sorted()——自然排序（Comprable）
- sorted(Comparator com)——定制排序（Comparator）
@Test
public void test12() {
List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
list.stream()
.sorted()
.forEach(System.out::println);
/** 先按年龄排，如果年龄一样，再按姓名排 */
employees.stream()
.sorted((x, y) -> {
if(x.getAge() == y.getAge()){
/**年龄一样，就按照姓名排*/
return x.getName().compareTo(y.getName());
}else{
/** 年龄不一样，这个时候，就按照年龄排*/
return Integer.compare(x.getAge(), y.getAge());
}
}).forEach(System.out::println);
}
排序结果如下：
Stream_查找与匹配
终止操作
- allMatch——检查是否匹配所有元素
- anyMatch——检查是否至少匹配一个元素
- noneMatch——检查是否没有匹配的元素
- findFirst——返回第一个元素
- findAny——返回当前流中的任意元素
- count——返回流中元素的总个数
- max——返回流中最大值
- min——返回流中最小值
- allMatch——检查是否匹配所有元素
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
@Test
public void test1() {
boolean b1 = employees.stream()
//allMatch-检查是否匹配到所有的元素
.allMatch((e) -> e.getStatus().equals(Status.BUSY));
System.out.println(b1);//没有匹配到所有的元素，这个时候，返回的就是一个false
}
- anyMatch——检查是否至少匹配一个元素
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
@Test
public void test2() {
boolean b1 = employees.stream()
//anyMatch-检查是否至少匹配一个元素
.anyMatch((e) -> e.getStatus().equals(Status.BUSY));
System.out.println(b1);//这个就是返回true的,检查是否至少有一个匹配到元素
}
- noneMatch——检查是否没有匹配的元素
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
@Test
public void test3() {
boolean b1 = employees.stream()
//noneMatch——检查是否没有匹配的元素
.noneMatch((e) -> e.getStatus().equals(Status.BUSY));
System.out.println(b1);//检查是否没有匹配的元素，这里返回的是false，因为有3个匹配到了
}
- findFirst——返回第一个元素
代码如下：
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
@Test
public void test4() {
Optional<Employee> op = employees.stream()
.sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
.findFirst();
//op.orElse()--如果这个对象为空的话，那么我们就考虑用新的值来进行代替
System.out.println(op.get());//我们可以利用这个get方法来进行获取里面的值
}
- findAny——返回当前流中的任意元素
我们可以举一个例子：从当前的公司找出一个程序员加入到当前的开发团队当中：
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
/**找出一个处于空闲状态的员工添加到开发团队当中*/
@Test
public void test5() {
Optional<Employee> optional = employees.stream()
.filter((e) -> e.getStatus().equals(Status.FREE))
.findAny();
System.out.println(optional.get());
}
运行结果如下图：
- count——返回流中元素的总个数
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
@Test
public void test6() {
long count = employees.stream()
.count();
System.out.println(count);
}
- max——返回流中最大值
下面的代码是获取按照员工的工资来比最大的员工的信息：
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
@Test
public void test7() {
Optional<Employee> op = employees.stream()
.max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
System.out.println(op.get());
}
- min——返回流中最小值
现在我想要获取所有员工里面工资最少的工资是多少?
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
@Test
public void test9() {
Optional<Double> op = employees.stream()
.map(Employee::getSalary)
.min(Double::compare);
System.out.println(op.get());
}
Stream_归约与收集
归约
reduce(T identity, BinaryOperator) / reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。
@Test
public void test1(){
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
Integer sum = list.stream()
.reduce(0, (x, y) -> x + y);
System.out.println(sum);//返回的是55
}
如图所示：
算出公司里面所有员工的薪资的总和：
把当前公司所有员工的名字给提取出来，然后再放到一个集合中
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
/**把当前公司所有员工的名字给提取出来，然后再放到一个集合中*/
@Test
public void test3() {
List<String> list = employees.stream()
.map(Employee::getName)
.collect(Collectors.toList());
list.forEach(System.out::println);
}
我们还可以收集到Set集合中：
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
@Test
public void test4() {
Set<String> list = employees.stream()
.map(Employee::getName)
.collect(Collectors.toSet());
list.forEach(System.out::println);
}
我们还可以获取到集合中的元素的个数：
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
@Test
public void test5() {
Long count = employees.stream()
.collect(Collectors.counting());
System.out.println(count);
}
我们也可以获取到工资的平均值：
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
@Test
public void test6() {
Double avg = employees.stream()
.collect(Collectors.averagingDouble(Employee::getSalary));
System.out.println(avg);
}
我们还可以获取到工资的总和：
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
@Test
public void test7() {
Double sum = employees.stream()
.collect(Collectors.summingDouble(Employee::getSalary));
System.out.println(sum);
}
我们还可以获取到工资最高的Employee：
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
@Test
public void test8() {
Optional<Employee> max = employees.stream()
.collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
System.out.println(max.get());
}
获取工资最低的员工的工资：
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
@Test
public void test9() {
Optional<Double> min = employees.stream()
.map(Employee::getSalary)
.collect(Collectors.minBy(Double::compare));
System.out.println(min.get());
}
我们还可以分组：这个就是按照状态来进行分组：
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
@Test
public void test10() {
Map<Status, List<Employee>> map = employees.stream()
.collect(Collectors.groupingBy(Employee::getStatus));
}
我们还可以进行多级分组：先按照状态分，状态一样，我们再按照年龄来进行分组：
List<Employee> employees = Arrays.asList(
new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "张三", 18, 9999.99, Status.FREE),
new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(104, "赵六", 8, 7777.77, Status.FREE),
new Employee(105, "田七", 38, 5555.55, Status.BUSY),
new Employee(105, "田七", 38, 5555.55, Status.BUSY)
);
@Test
public void test11() {
Map<Status, Map<String, List<Employee>>> map = employees.stream()
.collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {
if (((Employee) e).getAge() <= 35) {
return "青年";
} else if (((Employee) e).getAge() <= 50) {
return "中年";
} else {
return "老年";
}
})));
}
@Test
public void test10() {
Map<Status, List<Employee>> map = employees.stream()
.collect(Collectors.groupingBy(Employee::getStatus));
}
还可以进行分区：满足添加的一个区，不满足条件的一个区：
还有另外一种获取的方式：
@Test
public void test13() {
DoubleSummaryStatistics dss = employees.stream()
.collect(Collectors.summarizingDouble(Employee::getSalary));
System.out.println(dss.getMax());
System.out.println(dss.getAverage());
System.out.println(dss.getCount());
System.out.println(dss.getSum());
}
我们还可以连接字符串：
要是我们想要逗号来进行连接，我们就可以这样来写：
如果想要首尾也要连接，我们就是可以这样来写：
