正文

一个例子理解Predicate、Consumer和Stream

IP云
IP云V管理员/3 阅读
09/27
提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

一个需求：

把年龄大于20的学生的信息打印出来。

面向对象编程

public class Student { private String name; private int age; private int number; public Student(String name,int age,int number){
this.name = name;
this.age = age;
this.number = number;
} public String toString(){
return "name:"+name+" "+"age:"+age+" "+"number:"+number;
} public int getAge() {
return age;
}
//省略其他get set方法}

public class Test { public static void main(String[] args) {
Student student1 = new Student("ouym",21,1000);
if(student1.getAge()>20){
System.out.println(student1.toString());
}
} }

如果Test类中line5~7在多处使用，我们还可以将其封装成函数。在Student类中添加函数

public void printIfGTParam(Student student,int age){
if(student.getAge()>age){
System.out.println(student.toString());
}
}

Test改为如下：

public class Test { public static void main(String[] args) {
Student student1 = new Student("ouym",21,1000);
student1.printIfGTParam(student1, 20);
}
}

但是如果需求变了呢？现在我们需要把名字为ouym的学生信息打印出来。

两个方案：（1）修改printIfGTParam函数，加几个判定条件。但是这明显不符合开闭原则。

（2）添加一个新的函数，处理该需求。如果又有新的需求的话，一直添加代码显得不干净。

下面介绍一个更合理的方法，函数编程。

函数编程

import java.util.function.Consumer;
import java.util.function.Predicate;public class Student { private String name; private int age; private int number; public Student(String name,int age,int number){
this.name = name;
this.age = age;
this.number = number;
} public String toString(){
return "name:"+name+" "+"age:"+age+" "+"number:"+number;
} public void printIf(Predicate<Student> predicate,
Consumer<Student> consumer){
if ( predicate.test(this)){
consumer.accept(this);
}
} public int getAge() {
return age;
}
//省略其他set、get方法}

public class Test { public static void main(String[] args) {
Student student1 = new Student("ouym",21,1000);
student1.printIf(student -> student.getAge()>20,
student -> System.out.println(student.toString()));
}}

如果需求改为打印姓名为ouym的学生信息的时候，我们只需要在调用printIf方法的时候把student -> student.getAge()>20改为student -> student.getName()=="ouym"即可。好处不言而喻。这里只是处理一个学生，如果要处理多个学生呢？一个简单的方法是使用for循环，Student类不变，将Test改为如下：

public class Test { public static void main(String[] args) {
Student student1 = new Student("ouym1",19,1000);
Student student2 = new Student("ouym2",20,1001);
Student student3 = new Student("ouym3",21,1002);
Student student4 = new Student("ouym4",22,1003); List<Student> students = new ArrayList<>();
students.add(student1);
students.add(student2);
students.add(student3);
students.add(student4); for(Student one : students){
one.printIf(student -> student.getAge()>20,
student -> System.out.println(student.toString()));
}
}}

对于集合的情况，Java8的函数编程也提供了stream接口支持。

public class Test { public static void main(String[] args) {
Student student1 = new Student("ouym1",19,1000);
Student student2 = new Student("ouym2",20,1001);
Student student3 = new Student("ouym3",21,1002);
Student student4 = new Student("ouym4",22,1003); List<Student> students = new ArrayList<>();
students.add(student1);
students.add(student2);
students.add(student3);
students.add(student4); students.stream().filter(student -> student.getAge()>20)
.forEach(student -> System.out.println(student.toString())); }
}

这里只是stream一个简单的操作，更多详情介绍请看总结部分。

 总结

（1）Predicate

Represents a predicate (boolean-valued function) of one argument.

表示一个参数的谓词（布尔值函数）。源码如下（函数接口都有@FunctionalInterface注解修饰）：

@FunctionalInterface
public interface Predicate<T> { boolean test(T t); //提供的Predicate和本身的Predicate都为true，返回的Predicate才是true
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
} //同理，非操作
default Predicate<T> negate() {
return (t) -> !test(t);
} //同理，或
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
} static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}

所以Predicate的主要作用是调用test方法评估一个对象，评估方法是在调用的时候以函数作为参数传递进去，评估结果以boolean类型返回。具体看上述例子。

（2）Consumer接口

Represents an operation that accepts a single input argument and returns no result.
Unlike most other functional interfaces, {@code Consumer} is expected to operate via side-effects.

即接口表示一个接受单个输入参数并且没有返回值的操作。不像其他函数式接口，Consumer接口期望执行带有副作用的操作（Consumer的操作可能会更改输入参数的内部状态）。

@FunctionalInterface
public interface Consumer<T> { void accept(T t); default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}

accept方法接收一个对象，具体的操作在调用的时候以函数作为参数传递进去，没有返回值。

andThen方法是个defaul方法，表示先执行本身的 accept方法，紧接着再执行after的accept方法。

（3）Stream（来自）

Stream 是用函数式编程方式在集合类上进行复杂操作的工具，其集成了Java 8中的众多新特性之一的聚合操作。

对聚合操作的使用（创建流后）可以归结为2个部分：

  • Intermediate：一个流可以后面跟随零个或多个 intermediate 操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历。
  • Terminal：一个流只能有一个 terminal 操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。Terminal 操作的执行，才会真正开始流的遍历，并且会生成一个结果，或者一个 side effect。

还有一种操作被称为 short-circuiting。用以指：

  • 对于一个 intermediate 操作，如果它接受的是一个无限大（infinite/unbounded）的 Stream，但返回一个有限的新 Stream。
  • 对于一个 terminal 操作，如果它接受的是一个无限大的 Stream，但能在有限的时间计算出结果。

当操作一个无限大的 Stream，而又希望在有限时间内完成操作，则在管道内拥有一个 short-circuiting 操作是必要非充分条件。

构造流的几种常见方法：

// 1. Individual values
Stream stream = Stream.of("a", "b", "c");
// 2. Arrays
String [] strArray = new String[] {"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. Collections
List<String> list = Arrays.asList(strArray);
stream = list.stream();

对于基本数值型，目前有三种对应的包装类型 Stream：

IntStream、LongStream、DoubleStream。当然我们也可以用 Stream<Integer>、Stream<Long> >、Stream<Double>，但是 boxing 和 unboxing 会很耗时，所以特别为这三种基本数值型提供了对应的 Stream。

流转换为其它数据结构：

// 1. Array
String[] strArray1 = stream.toArray(String[]::new);
// 2. Collection
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
// 3. String
String str = stream.collect(Collectors.joining()).toString();

一个 Stream 只可以使用一次。

stream的操作：

Intermediate：map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unorderedTerminal：forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iteratorShort-circuiting：anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit

下面看一下 Stream 的比较典型用法：

map/flatMap

它的作用就是把 input Stream 的每一个元素，映射成 output Stream 的另外一个元素。

//转换大写
List<String> output = wordList.stream().
map(String::toUpperCase).
collect(Collectors.toList());//平方数
List<Integer> nums = Arrays.asList(1, 2, 3, 4);
List<Integer> squareNums = nums.stream().
map(n -> n * n).
collect(Collectors.toList());//一对多flatMap 把 input Stream 中的层级结构扁平化，就是将最底层元素抽出来放到一起，
//最终 output 的新 Stream 里面已经没有 List 了，都是直接的数字。
Stream<List<Integer>> inputStream = Stream.of(
Arrays.asList(1),
Arrays.asList(2, 3),
Arrays.asList(4, 5, 6)
);
Stream<Integer> outputStream = inputStream.
flatMap((childList) -> childList.stream());

filter

filter 对原始 Stream 进行某项测试，通过测试的元素被留下来生成一个新 Stream。

//留下偶数
Integer[] sixNums = {1, 2, 3, 4, 5, 6};
Integer[] evens =
Stream.of(sixNums).filter(n -> n%2 == 0).toArray(Integer[]::new);//首先把每行的单词用 flatMap 整理到新的 Stream，然后保留长度不为 0 的，
//就是整篇文章中的全部单词了。
List<String> output = reader.lines().
flatMap(line -> Stream.of(line.split(REGEXP))).
filter(word -> word.length() > 0).
collect(Collectors.toList());

forEach

forEach 方法接收一个 Lambda 表达式，然后在 Stream 的每一个元素上执行该表达式。

//打印姓名
// 1、stream
roster.stream()
.filter(p -> p.getGender() == Person.Sex.MALE)
.forEach(p -> System.out.println(p.getName()));
// 2、for循环
for (Person p : roster) {
if (p.getGender() == Person.Sex.MALE) {
System.out.println(p.getName());
}
}

一般认为，forEach 和常规 for 循环的差异不涉及到性能，它们仅仅是函数式风格与传统 Java 风格的差别。

另外一点需要注意，forEach 是 terminal 操作，因此它执行后，Stream 的元素就被“消费”掉了，你无法对一个 Stream 进行两次 terminal 运算。

还有一个具有相似功能的 intermediate 操作 peek 可以达到上述目的。（可以多次调用）

Stream.of("one", "two", "three", "four")
.filter(e -> e.length() > 3)
.peek(e -> System.out.println("Filtered value: " + e))
.map(String::toUpperCase)
.peek(e -> System.out.println("Mapped value: " + e))
.collect(Collectors.toList());

reduce

这个方法的主要作用是把 Stream 元素组合起来。它提供一个起始值（种子），然后依照运算规则（BinaryOperator），和前面 Stream 的第一个、第二个、第 n 个元素组合。从这个意义上说，字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。

// 字符串连接，concat = "ABCD"
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
// 求最小值，minValue = -3.0
double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
// 求和，sumValue = 10, 有起始值
int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
// 求和，sumValue = 10, 无起始值
sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
// 过滤，字符串连接，concat = "ace"
concat = Stream.of("a", "B", "c", "D", "e", "F").
filter(x -> x.compareTo("Z") > 0).
reduce("", String::concat);

上面代码例如第一个示例的 reduce()，第一个参数（空白字符）即为起始值，第二个参数（String::concat）为 BinaryOperator。这类有起始值的 reduce() 都返回具体的对象。而对于第四个示例没有起始值的 reduce()，由于可能没有足够的元素，返回的是 Optional，需要通过Optional的get方法获取对象，请留意这个区别。

Optional是Java8提供的为了解决null安全问题的一个API。

//一般写法
public static String getName(User u) {
if (u == null)
return "Unknown";
return u.name;
}//使用Optional
public static String getName(User u) {
return Optional.ofNullable(u)
.map(user->user.name)
.orElse("Unknown");
}

关于Optional的更多详情请自行查阅api

limit/skip

limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素。

public void testLimitAndSkip() {
List<Person> persons = new ArrayList();
for (int i = 1; i <= 10000; i++) {
Person person = new Person(i, "name" + i);
persons.add(person);
}
List<String> personList2 = persons.stream().map(Person::getName).limit(10).skip(3).collect(Collectors.toList());
System.out.println(personList2);
} private class Person {
public int no;
private String name; public Person(int no, String name) {
this.no = no;
this.name = name;
} public String getName() {
System.out.println(name);
return name;
}
}

输出结果为：

name1
name2
name3
name4
name5
name6
name7
name8
name9
name10
[name4, name5, name6, name7, name8, name9, name10]

这是一个有 10，000 个元素的 Stream，但在 short-circuiting 操作 limit 和 skip 的作用下，管道中 map 操作指定的 getName() 方法的执行次数为 limit 所限定的 10 次，而最终返回结果在跳过前 3 个元素后只有后面 7 个返回。

sorted

对 Stream 的排序通过 sorted 进行，它比数组的排序更强之处在于你可以首先对 Stream 进行各类 map、filter、limit、skip 甚至 distinct 来减少元素数量后，再排序，这能帮助程序明显缩短执行时间。

List<Person> persons = new ArrayList();
for (int i = 1; i <= 5; i++) {
Person person = new Person(i, "name" + i);
persons.add(person);
}
List<Person> personList2 = persons.stream().limit(2).sorted((p1, p2) -> p1.getName().compareTo(p2.getName()))
.collect(Collectors.toList());
System.out.println(personList2);

Match

Stream 有三个 match 方法，从语义上说：

  • allMatch：Stream 中全部元素符合传入的 predicate，返回 true
  • anyMatch：Stream 中只要有一个元素符合传入的 predicate，返回 true
  • noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true

它们都不是要遍历全部元素才能返回结果。例如 allMatch 只要一个元素不满足条件，就 skip 剩下的所有元素，返回 false。

对之前的 Person 类稍做修改，加入一个 age 属性和 getAge 方法。

List<Person> persons = new ArrayList();
persons.add(new Person(1, "name" + 1, 10));
persons.add(new Person(2, "name" + 2, 21));
persons.add(new Person(3, "name" + 3, 34));
persons.add(new Person(4, "name" + 4, 6));
persons.add(new Person(5, "name" + 5, 55));
boolean isAllAdult = persons.stream().
allMatch(p -> p.getAge() > 18);
System.out.println("All are adult? " + isAllAdult);

min/max/distinct

//找出最长一行的长度
BufferedReader br = new BufferedReader(new FileReader("c:\\SUService.log"));
int longest = br.lines().
mapToInt(String::length).
max().
getAsInt();
br.close();
System.out.println(longest);//找出不重复的单词，转小写，并排序
List<String> words = br.lines().
flatMap(line -> Stream.of(line.split(" "))).
filter(word -> word.length() > 0).
map(String::toLowerCase).
distinct().
sorted().
collect(Collectors.toList());
br.close();
System.out.println(words);

完