Java學習：常用函數接口

常用函數接口

什么是函數式接口？

　　函數式接口，@FunctionalInterface，簡稱FI，簡單的說，FI就是指僅含有一個抽象方法的接口，以@Functionalnterface標注

注意：這里的抽象方法指的是該接口自己特有的抽象方法，而不包含它從其上級繼承過來的抽象方法，例如：

@FunctionalInterface
Interface FI{
   abstract judge(int a);
   abstract equals();      
}

上面這個接口盡管含有兩個抽象方法，但是它仍然是一個FI，因為equals抽象方法是其從超類Object中繼承的（當然這里的“接口繼承超類Object”的說法很有爭議，但是不妨礙咱們這里拿來理解FI這個概念）

Java8中常用的全新的接口

Predicate接口

Predicate 接口只有一個參數，返回boolean類型。該接口包含多種默認方法來將Predicate組合成其他復雜的邏輯（比如：與，或，非）：

代碼如下：

Predicate<String> predicate = (s) -> s.length() > 0;
 
predicate.test("foo");              // true
predicate.negate().test("foo");     // false

Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;

Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();

 

Function 接口

Function 接口有一個參數並且返回一個結果，並附帶了一些可以和其他函數組合的默認方法（compose, andThen）：

代碼如下:

Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
backToString.apply("123"); // "123"

Supplier 接口

Supplier 接口返回一個任意范型的值，和Function接口不同的是該接口沒有任何參數

代碼如下:

Supplier<Person> personSupplier = Person::new;
personSupplier.get(); // new Person

Consumer 接口

Consumer 接口表示執行在單個參數上的操作。

代碼如下:

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));

Comparator 接口

Comparator 是老Java中的經典接口， Java 8在此之上添加了多種默認方法：

代碼如下:

Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");

comparator.compare(p1, p2); // > 0
comparator.reversed().compare(p1, p2); // < 0

Optional 接口

Optional 不是函數是接口，這是個用來防止NullPointerException異常的輔助類型，這是下一屆中將要用到的重要概念，現在先簡單的看看這個接口能干什么：

Optional 被定義為一個簡單的容器，其值可能是null或者不是null。在Java 8之前一般某個函數應該返回非空對象但是偶爾卻可能返回了null，而在Java 8中，不推薦你返回null而是返回Optional。

代碼如下:

Optional<String> optional = Optional.of("bam");

optional.isPresent(); // true
optional.get(); // "bam"
optional.orElse("fallback"); // "bam"

5 optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b"

 

Stream 接口

java.util.Stream 表示能應用在一組元素上一次執行的操作序列。Stream 操作分為中間操作或者最終操作兩種，最終操作返回一特定類型的計算結果，而中間操作返回Stream本身，這樣你就可以將多個操作依次串起來。Stream 的創建需要指定一個數據源，比如 java.util.Collection的子類，List或者Set， Map不支持。Stream的操作可以串行執行或者並行執行。

首先看看Stream是怎么用，首先創建實例代碼的用到的數據List：

代碼如下:

List<String> stringCollection = new ArrayList<>();
stringCollection.add("ddd2");
stringCollection.add("aaa2");
stringCollection.add("bbb1");
stringCollection.add("aaa1");
stringCollection.add("bbb3");
stringCollection.add("ccc");
stringCollection.add("bbb2");
stringCollection.add("ddd1");

Java 8擴展了集合類，可以通過 Collection.stream() 或者 Collection.parallelStream() 來創建一個Stream。

Filter 過濾

過濾通過一個predicate接口來過濾並只保留符合條件的元素，該操作屬於中間操作，所以我們可以在過濾后的結果來應用其他Stream操作（比如forEach）。forEach需要一個函數來對過濾后的元素依次執行。forEach是一個最終操作，所以我們不能在forEach之后來執行其他Stream操作。

代碼如下:

stringCollection
    .stream()
    .filter((s) -> s.startsWith("a"))
    .forEach(System.out::println);
// "aaa2", "aaa1"

Sort 排序

排序是一個中間操作，返回的是排序好后的Stream。如果你不指定一個自定義的Comparator則會使用默認排序。

代碼如下:

stringCollection
    .stream()
    .sorted()
    .filter((s) -> s.startsWith("a"))
    .forEach(System.out::println);
 

// "aaa1", "aaa2" 

需要注意的是，排序只創建了一個排列好后的Stream，而不會影響原有的數據源，排序之后原數據stringCollection是不會被修改的：

代碼如下:

System.out.println(stringCollection);
// ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1

注意： 其實這也是函數式編程的一個好處：不會改變對象狀態，每次都會創建一個新對象。

Map 映射

中間操作map會將元素根據指定的Function接口來依次將元素轉成另外的對象，下面的示例展示了將字符串轉換為大寫字符串。你也可以通過map來講對象轉換成其他類型，map返回的Stream類型是根據你map傳遞進去的函數的返回值決定的。

代碼如下:

stringCollection
    .stream()
    .map(String::toUpperCase)
    .sorted((a, b) -> b.compareTo(a))
    .forEach(System.out::println);
 

// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1" 

Match 匹配

Stream提供了多種匹配操作，允許檢測指定的Predicate是否匹配整個Stream。所有的匹配操作都是最終操作，並返回一個boolean類型的值。

代碼如下:

boolean anyStartsWithA = 
    stringCollection
        .stream()
        .anyMatch((s) -> s.startsWith("a"));
 

System.out.println(anyStartsWithA);      // true

boolean allStartsWithA = 
    stringCollection
        .stream()
        .allMatch((s) -> s.startsWith("a"));

System.out.println(allStartsWithA);      // false

boolean noneStartsWithZ = 
    stringCollection
        .stream()
        .noneMatch((s) -> s.startsWith("z"));

System.out.println(noneStartsWithZ);      // true 

Count 計數

計數是一個最終操作，返回Stream中元素的個數，返回值類型是long。

代碼如下:

long startsWithB = 
    stringCollection
        .stream()
        .filter((s) -> s.startsWith("b"))
        .count();
 

System.out.println(startsWithB);    // 3 

Reduce 規約

這是一個最終操作，允許通過指定的函數來講stream中的多個元素規約為一個元素，規越后的結果是通過Optional接口表示的：

代碼如下:

Optional<String> reduced =
    stringCollection
        .stream()
        .sorted()
        .reduce((s1, s2) -> s1 + "#" + s2);
 

reduced.ifPresent(System.out::println);
// "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2" 

並行Streams

前面提到過Stream有串行和並行兩種，串行Stream上的操作是在一個線程中依次完成，而並行Stream則是在多個線程上同時執行。

下面的例子展示了是如何通過並行Stream來提升性能：

首先我們創建一個沒有重復元素的大表：

代碼如下:

int max = 1000000;
List<String> values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
    UUID uuid = UUID.randomUUID();
    values.add(uuid.toString());
}

然后我們計算一下排序這個Stream要耗時多久，

串行排序：

代碼如下:

long t0 = System.nanoTime();
 
long count = values.stream().sorted().count();
System.out.println(count);

long t1 = System.nanoTime();

long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("sequential sort took: %d ms", millis));

 

// 串行耗時: 899 ms

並行排序：

代碼如下:

long t0 = System.nanoTime();
 

long count = values.parallelStream().sorted().count();
System.out.println(count);

long t1 = System.nanoTime();

long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("parallel sort took: %d ms", millis)); 

// 並行排序耗時: 472 ms
上面兩個代碼幾乎是一樣的，但是並行版的快了50%之多，唯一需要做的改動就是將stream()改為parallelStream()。

Map

前面提到過，Map類型不支持stream，不過Map提供了一些新的有用的方法來處理一些日常任務。

代碼如下:

Map<Integer, String> map = new HashMap<>();
 

for (int i = 0; i < 10; i++) {
    map.putIfAbsent(i, "val" + i);
}

map.forEach((id, val) -> System.out.println(val)); 

以上代碼很容易理解， putIfAbsent 不需要我們做額外的存在性檢查，而forEach則接收一個Consumer接口來對map里的每一個鍵值對進行操作。

下面的例子展示了map上的其他有用的函數：

代碼如下:

map.computeIfPresent(3, (num, val) -> val + num);
map.get(3);             // val33
 
map.computeIfPresent(9, (num, val) -> null);
map.containsKey(9);     // false

map.computeIfAbsent(23, num -> "val" + num);
map.containsKey(23);    // true

map.computeIfAbsent(3, num -> "bam");
map.get(3);             // val33 

接下來展示如何在Map里刪除一個鍵值全都匹配的項：

代碼如下：

map.remove(3, "val3");
map.get(3); // val33

map.remove(3, "val33");
map.get(3); // null

另外一個有用的方法：

代碼如下:

map.getOrDefault(42, "not found"); // not found

對Map的元素做合並也變得很容易了：

代碼如下:

map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
map.get(9); // val9

map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
map.get(9); // val9concat

Merge做的事情是如果鍵名不存在則插入，否則則對原鍵對應的值做合並操作並重新插入到map中。

函數式接口的出現，是Java8對於Lambda表達式的一種支持。