使用流，第 3 部分

1.检查

我认为您可能已经厌倦了学习如何将数据流链接在一起。您想最终对数据做些什么。

该类Stream具有三个标准方法，它们不构造流，而是检查其中的数据类型。这些方法是：anyMatch()、allMatch()和noneMatch()。

boolean anyMatch(rule)方法

此方法检查流是否至少有一个元素满足传递给该方法的规则。如果存在这样的元素，则该方法返回true，否则返回false。

例子

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
boolean result = stream.anyMatch(x -> x > 0);

true

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.anyMatch(x -> x > 0);

true

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.filter(x -> x < 0).anyMatch(x -> x > 0);

false

在最后一个示例中，我们首先只保留小于零的元素，然后检查结果以查看是否有任何过滤元素大于零。当然，这样的元素已经不存在了。

布尔 allMatch(rule) 方法

此方法检查流中的所有元素是否都匹配规则（也称为谓词）。规则作为参数传递给方法：

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
boolean result = stream.allMatch(x -> x > 0);

true

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.allMatch(x -> x > 0);

false

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.filter(x -> x < 0).allMatch(x -> x < 0);

true

在最后一个例子中，我们首先只允许小于零的元素通过过滤器，然后我们检查是否所有保留的元素都小于零。检查产生了积极的结果。

boolean noneMatch(rule) 方法

该noneMatch()方法检查流是否没有与传递的规则匹配的元素。这就像方法的反面anyMatch()。

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
boolean result = stream.noneMatch(x -> x > 0);

false

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.noneMatch(x -> x > 0);

false

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.filter(x -> x < 0).noneMatch(x -> x > 0);

true

2.实用类：Optionalclass

有时程序员使用null引用是很不方便的。例如，假设您正在比较两个字符串。如果两个变量都不是null，那么您只需调用s1.equals(s2)，一切都会正常进行。但如果s1可能null，那么您必须编写处理这种情况的代码以避免NullPointerException.

这就是程序员想出Optional<T>实用程序类的原因。它的代码大概是这样的：

class Optional<Type>
{
   private final Type value;
   private Optional() { this.value = null;}
   private Optional(value) { this.value = value;}
   public static <Type> Optional<Type> of(Type value)
   {
      return new Optional<Type>(value);
   }

   public boolean isPresent()
   {
      return value != null;
   }

   public boolean isEmpty()
   {
      return value == null;
   }

   public Type get()
   {
      if (value == null)
      {
         throw new NoSuchElementException();
      }
      return value;
   }

   public Type orElse(Type other)
   {
      return value != null ? value : other;
   }

   public Type orElseThrow()
   {
      if (value == null)
      {
         throw new NoSuchElementException();
      }
      return value;
   }
}

这个类的目的只是为了存储一个 T 对象（对类型为 T 的对象的引用）。对象内部的对象引用Optional<T>可以是null.

这个类可以让程序员编写更漂亮的代码。让我们比较一下：

public void printString(String s)
{
   Optional<String> str = Optional.ofNullable(s);
   System.out.println(str.orElse(""));
}

public void printString(String s)
{
   String str = s != null ? s : "";
   System.out.println(str)
}

始终可以使用该方法将一个Optional对象与另一个对象进行比较，即使它们存储引用也是如此。Optionalequalsnull

简单地说，该类允许您在对象存储值的情况下Optional编写“漂亮”的检查和“漂亮”的操作。nullOptionalnull

3.寻找元素

让我们回到Stream课堂上。该类Stream还有 4 个方法可以让您在流中搜索元素。这些方法是findFirst()、findAny()、min()和max()。

Optional<T> findFirst()方法

该findFirst()方法只返回流中的第一个元素。这就是它所做的一切。

这里需要注意的更有趣的事情是该方法不返回对象T，而是一个Optional<T>包装器对象。这确保该方法null在找不到对象后永远不会返回。

例子：

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String str = list.stream().findFirst().get(); // Hello

为了更清楚地说明，让我们将最后一行分成几行：

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");

Stream<String> stream = list.stream();
Optional<String> result = stream.findFirst();
String str = result.get(); // Hello

最后一个get()方法只是检索存储在对象中的值Optional。

Optional<T> findAny()方法

该findAny()方法返回流中的任何元素并在那里结束。此方法类似于findFirst()，但它非常适用于并行操作中使用的流。

并行处理流时，可能在流的某个部分已经找到了一个元素，但尚不清楚它是否是第一个。

如果许多元素都匹配了所有过滤器，并且程序员准确地获取其中的第一个元素很重要，那么findFirst()应该调用该方法。如果程序员知道实际上 0 或 1 个元素将匹配所有过滤器，那么只需调用就足够了findAny()——这样会更快。

Optional<T> min(Comparator<T>)方法

该min()方法使用一个comparator对象来比较流中的所有元素并返回最小的元素。定义比较器对象最方便的方法是使用 lambda 函数。

搜索最短字符串的示例：

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String min = list.stream().min( (s1, s2)-> s1.length()-s2.length() ).get();

Optional<T> max(Comparator<T>)方法

该max()方法使用一个comparator对象来比较流中的所有元素并返回最大元素。定义比较器对象最方便的方法是使用 lambda 函数。

搜索最长字符串的示例：

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String max = list.stream().max( (s1, s2)-> s1.length()-s2.length() ).get();