Functional Programming With Java 简明教程

Functional Programming - Terminal Methods

当在流上调用终结方法时，对流和任何其他链接流启动迭代。迭代结束后，会返回终结方法的结果。终结方法不返回 Stream，因此一旦在流上调用终结方法，那么其对非终结方法或中间方法的链接就会停止/终止。

When a terminal method in invoked on a stream, iteration starts on stream and any other chained stream. Once the iteration is over then the result of terminal method is returned. A terminal method does not return a Stream thus once a terminal method is invoked over a stream then its chaining of non-terminal methods or intermediate methods stops/terminates.

通常，终结方法返回一个值并针对流中的每个元素调用它们。以下是流接口的一些重要终结方法。每个终结函数都会获取一个谓词函数，启动元素的迭代，在每个元素上应用谓词。

Generally, terminal methods returns a single value and are invoked on each element of the stream. Following are some of the important terminal methods of Stream interface. Each terminal function takes a predicate function, initiates the iterations of elements, apply the predicate on each element.

anyMatch − If predicate returns true for any of the element, it returns true. If no element matches, false is returned.
allMatch − If predicate returns false for any of the element, it returns false. If all element matches, true is returned.
noneMatch − If no element matches, true is returned otherwise false is returned.
collect − each element is stored into the collection passed.
count − returns count of elements passed through intermediate methods.
findAny − returns Optional instance containing any element or empty instance is returned.
findFirst − returns first element under Optional instance. For empty stream, empty instance is returned.
forEach − apply the consumer function on each element. Used to print all elements of a stream.
min − returns the smallest element of the stream. Compares elements based on comparator predicate passed.
max − returns the largest element of the stream. Compares elements based on comparator predicate passed.
reduce − reduces all elements to a single element using the predicate passed.
toArray − returns arrays of elements of stream.

Example - Terminal Methods

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class FunctionTester {
   public static void main(String[] args) {
      List<String> stringList
         = Arrays.asList("One", "Two", "Three", "Four", "Five", "One");

      System.out.println("Example - anyMatch\n");
      //anyMatch - check if Two is present?
      System.out.println("Two is present: "
         + stringList
         .stream()
         .anyMatch(s -> {return s.contains("Two");}));

      System.out.println("\nExample - allMatch\n");
      //allMatch - check if length of each string is greater than 2.
      System.out.println("Length > 2: "
         + stringList
         .stream()
         .allMatch(s -> {return s.length() > 2;}));

      System.out.println("\nExample - noneMatch\n");
      //noneMatch - check if length of each string is greater than 6.
      System.out.println("Length > 6: "
         + stringList
         .stream()
         .noneMatch(s -> {return s.length() > 6;}));

      System.out.println("\nExample - collect\n");
      System.out.println("List: "
         + stringList
         .stream()
         .filter(s -> {return s.length() > 3;})
         .collect(Collectors.toList()));

      System.out.println("\nExample - count\n");
      System.out.println("Count: "
         + stringList
         .stream()
         .filter(s -> {return s.length() > 3;})
         .count());

      System.out.println("\nExample - findAny\n");
      System.out.println("findAny: "
         + stringList
         .stream()
         .findAny().get());

      System.out.println("\nExample - findFirst\n");
      System.out.println("findFirst: "
         + stringList
         .stream()
         .findFirst().get());

      System.out.println("\nExample - forEach\n");
      stringList
         .stream()
         .forEach(System.out::println);

      System.out.println("\nExample - min\n");
      System.out.println("min: "
         + stringList
         .stream()
         .min((s1, s2) -> { return s1.compareTo(s2);}));

      System.out.println("\nExample - max\n");
      System.out.println("min: "
         + stringList
         .stream()
         .max((s1, s2) -> { return s1.compareTo(s2);}));

      System.out.println("\nExample - reduce\n");
      System.out.println("reduced: "
         + stringList
         .stream()
         .reduce((s1, s2) -> { return s1 + ", "+ s2;})
         .get());
   }
}

Output

Example - anyMatch

Two is present: true

Example - allMatch

Length > 2: true

Example - noneMatch

Length > 6: true

Example - collect

List: [Three, Four, Five]

Example - count

Count: 3

Example - findAny

findAny: One

Example - findFirst

findFirst: One

Example - forEach

One
Two
Three
Four
Five
One

Example - min

min: Optional[Five]

Example - max

min: Optional[Two]

Example - reduce

reduced: One, Two, Three, Four, Five, One