From: https://lingcoder.gitee.io/onjava8/#/book/13-Functional-Programming
函數(shù)式編程語言操縱代碼片段就像操作數(shù)據(jù)一樣容易窥岩。 雖然 Java 不是函數(shù)式語言甲献，但 Java 8 Lambda 表達(dá)式和方法引用 (Method References) 允許你以函數(shù)式編程。
Lambda表達(dá)式
Lambda 表達(dá)式是使用最小可能語法編寫的函數(shù)定義：
Lambda 表達(dá)式產(chǎn)生函數(shù)颂翼，而不是類晃洒。 在 JVM（Java Virtual Machine，Java 虛擬機(jī)）上朦乏，一切都是一個(gè)類球及，因此在幕后執(zhí)行各種操作使 Lambda 看起來像函數(shù) —— 但作為程序員，你可以高興地假裝它們“只是函數(shù)”呻疹。
Lambda 語法盡可能少莽鸭，這正是為了使 Lambda 易于編寫和使用。
方法引用
Java 8 方法引用沒有歷史包袱闯参。方法引用組成：類名或?qū)ο竺竺娓?:: [^4]朦佩，然后跟方法名稱。
// functional/MethodReferences.java
import java.util.*;
interface Callable { // [1]
void call(String s);
}
class Describe {
void show(String msg) { // [2]
System.out.println(msg);
}
}
public class MethodReferences {
static void hello(String name) { // [3]
System.out.println("Hello, " + name);
}
static class Description {
String about;
Description(String desc) { about = desc; }
void help(String msg) { // [4]
System.out.println(about + " " + msg);
}
}
static class Helper {
static void assist(String msg) { // [5]
System.out.println(msg);
}
}
public static void main(String[] args) {
Describe d = new Describe();
Callable c = d::show; // [6]
c.call("call()"); // [7]
c = MethodReferences::hello; // [8]
c.call("Bob");
c = new Description("valuable")::help; // [9]
c.call("information");
c = Helper::assist; // [10]
c.call("Help!");
}
}
函數(shù)式接口
方法引用和 Lambda 表達(dá)式必須被賦值庐氮，同時(shí)編譯器需要識別類型信息以確保類型正確语稠。
Java 8 引入了 java.util.function 包。它包含一組接口弄砍，這些接口是 Lambda 表達(dá)式和方法引用的目標(biāo)類型仙畦。 每個(gè)接口只包含一個(gè)抽象方法，稱為函數(shù)式方法音婶。
在編寫接口時(shí)慨畸，可以使用 @FunctionalInterface 注解強(qiáng)制執(zhí)行此“函數(shù)式方法”模式：
// functional/FunctionalAnnotation.java
@FunctionalInterface
interface Functional {
String goodbye(String arg);
}
interface FunctionalNoAnn {
String goodbye(String arg);
}
/*
@FunctionalInterface
interface NotFunctional {
String goodbye(String arg);
String hello(String arg);
}
產(chǎn)生錯(cuò)誤信息:
NotFunctional is not a functional interface
multiple non-overriding abstract methods
found in interface NotFunctional
*/
public class FunctionalAnnotation {
public String goodbye(String arg) {
return "Goodbye, " + arg;
}
public static void main(String[] args) {
FunctionalAnnotation fa =
new FunctionalAnnotation();
Functional f = fa::goodbye;
FunctionalNoAnn fna = fa::goodbye;
// Functional fac = fa; // Incompatible
Functional fl = a -> "Goodbye, " + a;
FunctionalNoAnn fnal = a -> "Goodbye, " + a;
}
}
@FunctionalInterface 注解是可選的; Java 在 main() 中把 Functional 和 FunctionalNoAnn 都當(dāng)作函數(shù)式接口。 在 NotFunctional 的定義中可看到@FunctionalInterface 的作用：接口中如果有多個(gè)方法則會產(chǎn)生編譯期錯(cuò)誤衣式。
Function源碼：
/*
* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.util.function;
import java.util.Objects;
/**
* Represents a function that accepts one argument and produces a result.
*
* <p>This is a <a href="package-summary.html">functional interface</a>
* whose functional method is {@link #apply(Object)}.
*
* @param <T> the type of the input to the function
* @param <R> the type of the result of the function
*
* @since 1.8
*/
@FunctionalInterface
public interface Function<T, R> {
/**
* Applies this function to the given argument.
*
* @param t the function argument
* @return the function result
*/
R apply(T t);
/**
* Returns a composed function that first applies the {@code before}
* function to its input, and then applies this function to the result.
* If evaluation of either function throws an exception, it is relayed to
* the caller of the composed function.
*
* @param <V> the type of input to the {@code before} function, and to the
* composed function
* @param before the function to apply before this function is applied
* @return a composed function that first applies the {@code before}
* function and then applies this function
* @throws NullPointerException if before is null
*
* @see #andThen(Function)
*/
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
/**
* Returns a composed function that first applies this function to
* its input, and then applies the {@code after} function to the result.
* If evaluation of either function throws an exception, it is relayed to
* the caller of the composed function.
*
* @param <V> the type of output of the {@code after} function, and of the
* composed function
* @param after the function to apply after this function is applied
* @return a composed function that first applies this function and then
* applies the {@code after} function
* @throws NullPointerException if after is null
*
* @see #compose(Function)
*/
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
/**
* Returns a function that always returns its input argument.
*
* @param <T> the type of the input and output objects to the function
* @return a function that always returns its input argument
*/
static <T> Function<T, T> identity() {
return t -> t;
}
}
