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

一. 函數式編程

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

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

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

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

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
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的集合給我。

@FunctionalInterface
public interface Function<T, R> {

 R apply(T t);  5 
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

 

2.2 Predicate

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

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

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

@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);  5 
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

 

2.3 Consumer

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

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

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

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);  5 
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

 

三. 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原理

比如如下代碼：

List<Integer> list = new ArrayList<>();

list.stream().filter((x) -> x >= 18)

Stream<T> filter(Predicate<? super T> predicate);

@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);

}

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

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

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

原理其實是：

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

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

static final class Main$$Lambda$1 implements Predicate<Integer> {
    private Main$$Lambda$1() {
    }

    @Override
    public boolean test(Integer x) {
        return x >= 18;
    }
}

 

3.3 Lambda用法

public class Main {
    public static void main(String[] args) {

        List<Integer> list = new ArrayList<>();
        list.add(40);
        list.add(50);
        list.add(20);
        list.add(30);
        List<Integer> collect = list.stream().filter(x -> x >= 30)
                .map((x) -> x + 10).sorted((x, y) -> -x.compareTo(y))
                .collect(Collectors.toList());
        System.out.println(collect);
    }
}

 

這個一段很典型的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的函數式編程，對平時我們開發代碼，看其他人的代碼，都有很大的幫助。

且行且珍惜，加油！