Java函數式編程原理以及應用

  • 2019 年 10 月 3 日
  • 筆記

一. 函數式編程

Java8所有的新特性基本基於函數式編程的思想，函數式編程的帶來，給Java注入了新鮮的活力。

下面來近距離觀察一下函數式編程的幾個特點：

  • 函數可以作為變量、參數、返回值和數據類型。
  • 基於表達式來替代方法的調用
  • 函數無狀態，可以並發和獨立使用
  • 函數無副作用，不會修改外部的變量
  • 函數結果確定性；同樣的輸入，必然會有同樣的結果。

下面jdk1.8裏面對函數式編程的定義。只是一個  FunctionalInterface 接口。特別的簡單。

1 @Documented  2 @Retention(RetentionPolicy.RUNTIME)  3 @Target(ElementType.TYPE)  4 public @interface FunctionalInterface {}

這個函數式接口有幾點以下的限制：

  • 唯一的抽象方法，有且僅有一個 (即所有的函數式接口，有且只能有一個抽象方法)
  • 加上標註,則會觸發JavaCompiler的檢查。對於符合函數接口的接口，加不加都無關緊要，但是加上則會提供一層編譯檢查的保障。如果不符合，則會報錯。 
  • 不能被覆蓋之後，再聲明為抽象方法，則不算抽象方法。例如接口實現了Object中的方法。 
  • 可用於lambda類型的使用方式 

 

二. Java8新增函數式接口

Stream的操作是建立在函數式接口的組合之上的。Java8中新增的函數式接口都在java.util.function包下。這些函數式接口可以有多種分類方式。

2.1 Function

Function是從T到R的一元映射函數。將參數T傳遞給一個函數，返回R。即R = Function(T)

Function最常用的應該是  <R> Stream<R> map(Function<? super T, ? extends R> mapper);

比如List<Person> person裏面有age，name…. 我傳入age，他就會返回age的集合給我。

 1 @FunctionalInterface   2 public interface Function<T, R> {   3   4     R apply(T t);   5   6     default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {   7         Objects.requireNonNull(before);   8         return (V v) -> apply(before.apply(v));   9     }  10  11     default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {  12         Objects.requireNonNull(after);  13         return (T t) -> after.apply(apply(t));  14     }  15  16     static <T> Function<T, T> identity() {  17         return t -> t;  18     }  19 }

 

2.2 Predicate

Predicate是一個謂詞函數，主要作為一個謂詞演算推導真假值存在，返回布爾值的函數。Predicate等價於一個Function的boolean型返回值的子集。

predicate最常用的莫過於  Stream<T> filter(Predicate<? super T> predicate);  

比如我要過濾年齡 > 18 的人，我傳入age，判斷是否為true。為true則保留，false丟棄。

 1 @FunctionalInterface   2 public interface Predicate<T> {   3   4     boolean test(T t);   5   6     default Predicate<T> and(Predicate<? super T> other) {   7         Objects.requireNonNull(other);   8         return (t) -> test(t) && other.test(t);   9     }  10  11     default Predicate<T> negate() {  12         return (t) -> !test(t);  13     }  14  15     default Predicate<T> or(Predicate<? super T> other) {  16         Objects.requireNonNull(other);  17         return (t) -> test(t) || other.test(t);  18     }  19  20     static <T> Predicate<T> isEqual(Object targetRef) {  21         return (null == targetRef)  22                 ? Objects::isNull  23                 : object -> targetRef.equals(object);  24     }  25 }

 

2.3 Consumer

Consumer是從T到void的一元函數，接受一個入參但不返回任何結果的操作。

Consumer最常用的肯定是   default void forEach(Consumer<? super T> action) {}

這是一段forEach循環的代碼，傳入實現的方法，並不返回任何值。只是循環。

 1 @FunctionalInterface   2 public interface Consumer<T> {   3   4     void accept(T t);   5   6     default Consumer<T> andThen(Consumer<? super T> after) {   7         Objects.requireNonNull(after);   8         return (T t) -> { accept(t); after.accept(t); };   9     }  10 }

 

三. Lambda表達式

3.1 基本語法

Lambda 的基本結構為 (arguments) -> body，有如下幾種情況：

  • 參數類型可推導時，不需要指定類型，如 (a) -> System.out.println(a)
  • 當只有一個參數且類型可推導時，不強制寫 (), 如 a -> System.out.println(a)
  • 參數指定類型時，必須有括號，如 (int a) -> System.out.println(a)
  • 參數可以為空，如 () -> System.out.println(“hello”)
  • body 需要用 {} 包含語句，當只有一條語句時 {} 可省略

 

3.2 Lambda原理

比如如下代碼：

 1 List<Integer> list = new ArrayList<>();   2   3 list.stream().filter((x) -> x >= 18)   4   5 Stream<T> filter(Predicate<? super T> predicate);   6   7 @FunctionalInterface   8 public interface Predicate<T> {   9  10     boolean test(T t);  11  12 }

比如List裏面存個個人的年齡，現在篩選出年齡大於等於18的人。

此時我們就可以用  list.stream().filter((x) -> x >= 18)   這就是一個典型的lambda表達式

(x) -> x >= 18 傳給  Predicate 函數式接口。

原理其實是：

JVM幫我們動態生成了一個內部類，然後這個內部類實現了 Predicate 這個函數式接口。

重寫了裏面的test方法。生成的類似如下：

1 static final class Main$$Lambda$1 implements Predicate<Integer> {  2     private Main$$Lambda$1() {  3     }  4  5     @Override  6     public boolean test(Integer x) {  7         return x >= 18;  8     }  9 }

 

3.3 Lambda用法

 1 public class Main {   2     public static void main(String[] args) {   3   4         List<Integer> list = new ArrayList<>();   5         list.add(40);   6         list.add(50);   7         list.add(20);   8         list.add(30);   9         List<Integer> collect = list.stream().filter(x -> x >= 30)  10                 .map((x) -> x + 10).sorted((x, y) -> -x.compareTo(y))  11                 .collect(Collectors.toList());  12         System.out.println(collect);  13     }  14 }

 

這個一段很典型的Lambda + Stream的用法。

  • list.stream()獲取list的stream的流
  • filter篩選出年齡大於30的人 (裏面是一個Predicate接口，返回真假)
  • map做一個function映射
  • sort排序，裏面是compartor

 

四. 總結

Lambda 表達式可以減少很多代碼，能提高生產力。但也要理解其原理。比如3.3中的代碼，為什麼filter裏面是斷言表達式，map裏面是function表達式。

這都要從lambda的原理入手，也就是JVM動態生成一個內部類，並繼承其中的抽象方法。

本次主要介紹了Java函數式編程的原理以及應用，主要從Stream和lambda入手。通過一些簡單的概念，以及代碼，更好的理解Java的函數式編程。

掌握Java的函數式編程，對平時我們開發代碼，看其他人的代碼，都有很大的幫助。

且行且珍惜，加油！

 

VirMach 便宜 VPS

QNews

QNews