原文：http://zetcode.com/java/streamfilter/

Java 流过滤器教程展示了如何使用过滤操作过滤 Java 流。

Java 流

Java 流是来自源的支持聚合操作的一系列元素。 流不存储元素。 元素是按需计算的。 元素是从数据源（如集合，数组或 I/O 资源）中消耗的。

流聚合操作类似于 SQL 操作。 我们可以对流应用过滤，映射，缩小，匹配，搜索或排序操作。 流允许链接多个流操作。 与使用外部迭代的集合不同，流在内部进行迭代。

Java 流过滤器

Java 流过滤器方法是一个中间操作，它返回与给定谓词匹配的流元素。 谓词是一个返回布尔值的函数。

Java 流过滤器字符串长度

下面的示例过滤字符串列表。

JavaStreamFilterStringLength.java

  1. package com.zetcode;
  3. import java.util.Arrays;
  4. import java.util.List;
  5. import java.util.stream.Collectors;
  7. public class JavaStreamFilterStringLength {
  9.     public static void main(String[] args) {
  11.         List<String> words = Arrays.asList("pen", "custom", "orphanage",
  12.                 "forest", "bubble", "butterfly");
  14.         List<String> result = words.stream().filter(word -> word.length() > 5)
  15.                 .collect(Collectors.toList());
  17.         result.forEach(word -> System.out.println(word));
  18.     }
  19. }

我们有一个单词表。 我们过滤列表以仅包括长度大于 5 的字符串。

  1. List<String> result = words.stream().filter(word -> word.length() > 5)
  2.         .collect(Collectors.toList());

使用stream()方法，我们从字符串列表创建 Java 流。 在此流上，我们应用filter()方法。 filter()方法接受匿名函数，该函数对长度大于 5 的流的所有元素返回布尔值true。 我们使用collect()方法从流中创建一个列表。

  1. result.forEach(word -> System.out.println(word));

我们使用forEach()方法遍历结果并将其所有元素打印到控制台。

  1. custom
  2. orphanage
  3. forest
  4. bubble
  5. butterfly

这些单词有五个以上的字符。

Java 流过滤器空值

下一个示例过滤掉null值。

JavaStreamFilterRemoveNulls.java

  1. package com.zetcode;
  3. import java.util.Arrays;
  4. import java.util.List;
  5. import java.util.stream.Collectors;
  7. public class JavaStreamFilterRemoveNulls {
  9.     public static void main(String[] args) {
  11.         List<String> words = Arrays.asList("cup", null, "forest",
  12.                 "sky", "book", null, "theatre");
  14.         List<String> result = words.stream().filter(w -> w != null)
  15.                 .collect(Collectors.toList());
  17.         System.out.println(result);
  18.     }
  19. }

我们有一个单词表。 通过流过滤操作，我们创建了一个新列表，其中删除了null值。

  1. List<String> result = words.stream().filter(w -> w != null)
  2.         .collect(Collectors.toList());

在 lambda 表达式的主体中，我们检查值是否不是null。 collect()方法是一种终端操作，可从过滤后的流中创建列表。

  1. [cup, forest, sky, book, theatre]

最终输出中没有null值。

Java 流多个过滤器操作

可以对流应用多个过滤器操作。

JavaStreamMultipleFilters.java

  1. package com.zetcode;
  3. import java.util.Arrays;
  4. import java.util.function.IntConsumer;
  6. public class JavaStreamMultipleFilters {
  8.     public static void main(String[] args) {
  10.         int[] inums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
  12.         IntConsumer icons = i -> System.out.print(i + " ");
  14.         Arrays.stream(inums).filter(e -> e < 6 || e > 10)
  15.                 .filter(e -> e % 2 == 0).forEach(icons);
  16.     }
  17. }

在示例中，我们对整数流应用了多个过滤操作。

  1. int[] inums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };

我们有一个整数值数组。

  1. IntConsumer icons = i -> System.out.print(i + " ");

IntConsumer是一个接受单个整数值参数且不返回结果的操作。

  1. Arrays.stream(inums).filter(e -> e < 6 || e > 10)
  2.         .filter(e -> e % 2 == 0).forEach(icons);

使用Arrays.stream()方法从数组创建流。 执行多个过滤操作。

  1. 2 4 12 14

这些整数满足所有过滤条件。

Java 流过滤器对象

下一个示例显示了如何过滤对象。

User.java

  1. package com.zetcode;
  3. public class User {
  5.     private String name;
  6.     private String email;
  8.     public User(String name, String email) {
  9.         this.name = name;
  10.         this.email = email;
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  21.     public String getEmail() {
  22.         return email;
  23.     }
  25.     public void setEmail(String email) {
  26.         this.email = email;
  27.     }
  28. }

在示例中，我们使用此User类。

JavaStreamFilterObjects.java

  1. package com.zetcode;
  3. import java.util.Arrays;
  4. import java.util.List;
  5. import java.util.stream.Collectors;
  7. public class JavaStreamFilterObjects {
  9.     public static void main(String[] args) {
  11.         List<User> persons = Arrays.asList(
  12.                 new User("Jack", "jack234@gmail.com"),
  13.                 new User("Peter", "pete2@post.com"),
  14.                 new User("Lucy", "lucy17@gmail.com"),
  15.                 new User("Robert", "bob56@post.com"),
  16.                 new User("Martin", "mato4@imail.com")
  17.         );
  19.         List<User> result = persons.stream()
  20.                 .filter(person -> person.getEmail().matches(".*post\\.com"))
  21.                 .collect(Collectors.toList());
  23.         result.forEach(p -> System.out.println(p.getName()));
  24.     }
  25. }

该示例创建User对象的流。 它过滤与特定正则表达式匹配的那些。

  1. List<User> result = persons.stream()
  2.         .filter(person -> person.getEmail().matches(".*post\\.com"))
  3.         .collect(Collectors.toList());

在过滤谓词中，我们选择与.*post\\.com模式匹配的电子邮件。

  1. Peter
  2. Robert

这两个用户的电子邮件与常规模式匹配。

Java 流过滤器按键映射

在以下示例中，我们通过映射的键过滤映射。

JavaStreamFilterMapByValues.java

  1. package com.zetcode;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. public class JavaStreamFilterMapByKeys {
  8.     public static void main(String[] args) {
  10.         Map<String, String> hmap = new HashMap<>();
  12.         hmap.put("de", "Germany");
  13.         hmap.put("hu", "Hungary");
  14.         hmap.put("sk", "Slovakia");
  15.         hmap.put("si", "Slovenia");
  16.         hmap.put("so", "Somalia");
  17.         hmap.put("us", "United States");
  18.         hmap.put("ru", "Russia");
  20.         hmap.entrySet().stream().filter(map -> map.getKey().startsWith("s"))
  21.                 .forEach(m -> System.out.println(m));
  22.     }
  23. }

该示例过滤以s字母开头的域名。

  1. si=Slovenia
  2. sk=Slovakia
  3. so=Somalia

这是示例的输出。

Java 流过滤器按值映射

在以下示例中，我们根据映射的值过滤映射。

JavaStreamFilterMapByValues.java

  1. package com.zetcode;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. public class JavaStreamFilterMapByValues {
  8.     public static void main(String[] args) {
  10.         Map<String, String> hmap = new HashMap<>();
  12.         hmap.put("de", "Germany");
  13.         hmap.put("hu", "Hungary");
  14.         hmap.put("sk", "Slovakia");
  15.         hmap.put("si", "Slovenia");
  16.         hmap.put("so", "Somalia");
  17.         hmap.put("us", "United States");
  18.         hmap.put("ru", "Russia");
  20.         hmap.entrySet().stream().filter(map -> map.getValue().equals("Slovakia")
  21.                 || map.getValue().equals("Slovenia"))
  22.                 .forEach(m -> System.out.println(m));
  23.     }
  24. }

在示例中，我们从映射中过滤出两个国家。

  1. si=Slovenia
  2. sk=Slovakia

这是输出。

在本教程中，我们已经处理过 Java 流过滤操作。 您可能也对相关教程感兴趣： Java 流，Java 流归约，Java 流映射，Java8 forEach教程，和用 Java 过滤列表。