歡迎來到Linux教程網
Linux教程網
Linux教程網
Linux教程網
您现在的位置: Linux教程網 >> UnixLinux >  >> Linux編程 >> Linux編程

Java 8中一些常用的全新的函數式接口

這一篇屬於菜鳥級博客,只是介紹了一些在Java 8中新出現的一些很有用的接口,通過一些簡單的例子加以說明,沒有深入地闡述。

函數式接口

什麼是函數式接口?

  函數式接口,@FunctionalInterface,簡稱FI,簡單的說,FI就是指僅含有一個抽象方法的接口,以@Functionalnterface標注,注意⚠️,這裡的抽象方法指的是該接口自己特有的抽象方法,而不包含它從其上級繼承過來的抽象方法,例如:

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

    上面這個接口盡管含有兩個抽象方法,但是它仍然是一個FI,因為equals抽象方法是其從超類Object中繼承的(當然這裡的“接口繼承超類Object”的說法很有爭議,但是不妨礙咱們這裡拿來理解FI這個概念),若是對於函數借口還有什麼不明白的,個人推薦一個博客:http://lucida.me/blog/java-8-lambdas-insideout-language-features/這篇博客對java8中的一些新特性講解的非常好!!

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"

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表達式的一種支持。

Lambda表達式之進化  http://www.linuxidc.com/Linux/2015-08/121630.htm

 個人推薦對於這些全新的學習方法:從官方文檔出發,最好從java.util.stream裡開始看,因為這裡的大多數接口都會在流的操作中使用的到,官方文檔裡面給出了一些簡短但有效的例子,結合文檔的解釋,能很好的理解這些全新的接口。

 

Copyright © Linux教程網 All Rights Reserved