作者：陳昌浩
1 導讀
if…else…在代碼中經常使用，聽說可以通過Java 8的Function介面來消滅if…else…！Function介面是什么？如果通過Function介面介面消滅if…else…呢？讓我們一起來探索一下吧，
2 Function介面
Function介面就是一個有且僅有一個抽象方法，但是可以有多個非抽象方法的介面,Function介面可以被隱式轉換為 lambda 運算式，可以通過FunctionalInterface注解來校驗Function介面的正確性，Java 8允許在介面中加入具體方法，介面中的具體方法有兩種，default方法和static方法，
@FunctionalInterface
interface TestFunctionService
{
void addHttp(String url);
}
那么就可以使用Lambda運算式來表示該介面的一個實作，
TestFunctionService testFunctionService = url -> System.out.println("http:" + url);
2.1 FunctionalInterface
2.1.1 原始碼
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}
2.1.2 說明
上圖是FunctionalInterface的注解說明，通過上面的注解說明，可以知道FunctionalInterface是一個注解，用來說明一個介面是函式式介面， 函式式介面只有一個抽象方法， 可以有默認方法，因為默認方法有一個實作，所以不是抽象的，函式介面的實體可以用lambda運算式、方法參考或建構式參考創建，
FunctionalInterface會校驗介面是否滿足函式式介面：
- 型別必須是介面型別，不能是注釋型別、列舉或類，
- 只能有一個抽象方法，
- 可以有多個默認方法和靜態方法，
- 可以顯示覆寫java.lang.Object中的抽象方法，
編譯器會將滿足函式式介面定義的任何介面視為函式式介面，而不管該介面宣告中是否使用FunctionalInterface注解，
3 Function介面主要分類
Function介面主要分類:
- Function：Function函式的表現形式為接收一個引數，并回傳一個值，
- Supplier：Supplier的表現形式為不接受引數、只回傳資料，
- Consumer：Consumer接收一個引數，沒有回傳值，
- Runnable：Runnable的表現形式為即沒有引數也沒有回傳值，
3.1 Function
Function函式的表現形式為接收一個引數，并回傳一個值，
3.1.1 原始碼
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
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;
}
}
3.1.2 方法說明
- apply：抽象方法，將此函式應用于給定的引數，引數t通過具體的實作回傳R，
- compose：default方法，回傳一個復合函式，首先執行fefore函式應用于輸入，然后將該函式應用于結果，如果任意一個函式的求值引發例外，則將其傳遞給組合函式的呼叫者，
- andThen：default方法，回傳一個復合函式，該復合函式首先對其應用此函式它的輸入，然后對結果應用after函式，如果任意一個函式的求值引發例外，則將其傳遞給組合函式的呼叫者，
- identity：static方法，回傳一個始侄訓傳其輸入引數的函式，
3.1.3 方法舉例
1）apply
測驗代碼：
public String upString(String str){
Function<String, String> function1 = s -> s.toUpperCase();
return function1.apply(str);
}
public static void main(String[] args) {
System.out.println(upString("hello!"));
}
通過apply呼叫具體的實作，執行結果：
2）compose
測驗代碼：
public static void main(String[] args) {
Function<String, String> function1 = s -> s.toUpperCase();
Function<String, String> function2 = s -> "my name is "+s;
String result = function1.compose(function2).apply("zhangSan");
System.out.println(result);
}
執行結果
如結果所示：compose 先執行function2 后執行function1，
3）andThen
測驗代碼：
public static void main(String[] args) {
Function<String, String> function1 = s -> s.toUpperCase();
Function<String, String> function2 = s -> "my name is "+s;
String result = function1.andThen(function2).apply("zhangSan");
System.out.println(result);
}
執行結果：
如結果所示：
andThen先執行function1 后執行function2，
- identity
測驗代碼：
public static void main(String[] args) {
Stream<String> stream = Stream.of("order", "good", "lab", "warehouse");
Map<String, Integer> map = stream.collect(Collectors.toMap(Function.identity(), String::length));
System.out.println(map);
}
執行結果:
3.2 Supplier
Supplier的表現形式為不接受引數、只回傳資料，
3.2.1 原始碼
@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
*
* @return a result
*/
T get();
}
3.2.2 方法說明
get：抽象方法，通過實作回傳T，
3.2.3 方法舉例
public class SupplierTest {
SupplierTest(){
System.out.println(Math.random());
System.out.println(this.toString());
}
}
public static void main(String[] args) {
Supplier<SupplierTest> sup = SupplierTest::new;
System.out.println("呼叫一次");
sup.get();
System.out.println("呼叫二次");
sup.get();
}
執行結果:
如結果所示：Supplier建立時并沒有創建新類，每次呼叫get回傳的值不是同一個，
3.3 Consumer
Consumer接收一個引數，沒有回傳值，
3.3.1 原始碼
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}
3.3.2 方法說明
- accept：對給定引數T執行一些操作，
- andThen：按順序執行Consumer -> after ,如果執行操作引發例外，該例外被傳遞給呼叫者，
3.3.3 方法舉例
public static void main(String[] args) {
Consumer<String> consumer = s -> System.out.println("consumer_"+s);
Consumer<String> after = s -> System.out.println("after_"+s);
consumer.accept("isReady");
System.out.println("========================");
consumer.andThen(after).accept("is coming");
}
執行結果：
如結果所示：對同一個引數T，通過andThen 方法，先執行consumer，再執行fater，
3.4 Runnable
Runnable：Runnable的表現形式為即沒有引數也沒有回傳值，
3.4.1 原始碼
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
3.4.2 方法說明
run：抽象方法，run方法實作具體的內容，需要將Runnale放入到Thread中，通過Thread類中的start()方法啟動執行緒，執行run中的內容，
3.4.3 方法舉例
public class TestRun implements Runnable {
@Override
public void run() {
System.out.println("TestRun is running!");
}
}
public static void main(String[] args) {
Thread thread = new Thread(new TestRun());
thread.start();
}
執行結果：
如結果所示：當執行緒實行start方法時，執行Runnable 的run方法中的內容，
4 Function介面用法
Function的主要用途是可以通過lambda 運算式實作方法的內容，
4.1 差異處理
原代碼：
@Data
public class User {
/**
* 姓名
*/
private String name;
/**
* 年齡
*/
private int age;
/**
* 組員
*/
private List<User> parters;
}
public static void main(String[] args) {
User user =new User();
if(user ==null ||user.getAge() <18 ){
throw new RuntimeException("未成年！");
}
}
執行結果：
使用Function介面后的代碼：
@FunctionalInterface
public interface testFunctionInfe {
/**
* 輸入例外資訊
* @param message
*/
void showExceptionMessage(String message);
}
public static testFunctionInfe doException(boolean flag){
return (message -> {
if (flag){
throw new RuntimeException(message);
}
});
}
public static void main(String[] args) {
User user =new User();
doException(user ==null ||user.getAge() <18).showExceptionMessage("未成年！");
}
執行結果：
使用function介面前后都拋出了指定的例外資訊，
4.2 處理if…else…
原代碼:
public static void main(String[] args) {
User user =new User();
if(user==null){
System.out.println("新增用戶");
}else {
System.out.println("更新用戶");
}
}
使用Function介面后的代碼：
public static void main(String[] args) {
User user =new User();
Consumer trueConsumer = o -> {
System.out.println("新增用戶");
};
Consumer falseConsumer= o -> {
System.out.println("更新用戶");
};
trueOrFalseMethdo(user).showExceptionMessage(trueConsumer,falseConsumer);
}
public static testFunctionInfe trueOrFalseMethdo(User user){
return ((trueConsumer, falseConsumer) -> {
if(user==null){
trueConsumer.accept(user);
}else {
falseConsumer.accept(user);
}
});
}
@FunctionalInterface
public interface testFunctionInfe {
/**
* 不同分處理不同的事情
* @param trueConsumer
* @param falseConsumer
*/
void showExceptionMessage(Consumer trueConsumer,Consumer falseConsumer);
}
執行結果：
4.3 處理多個if
原代碼：
public static void main(String[] args) {
String flag="";
if("A".equals(flag)){
System.out.println("我是A");
}else if ("B".equals(flag)) {
System.out.println("我是B");
}else if ("C".equals(flag)) {
System.out.println("我是C");
}else {
System.out.println("沒有對應的指令");
}
}
使用Function介面后的代碼：
public static void main(String[] args) {
String flag="B";
Map<String, Runnable> map =initFunctionMap();
trueOrFalseMethdo(map.get(flag)==null).showExceptionMessage(()->{
System.out.println("沒有相應指令");
},map.get(flag));
}
public static Map<String, Runnable> initFunctionMap(){
Map<String,Runnable> result = Maps.newHashMap();
result.put("A",()->{System.out.println("我是A");});
result.put("B",()->{System.out.println("我是B");});
result.put("C",()->{System.out.println("我是C");});
return result;
}
public static testFunctionInfe trueOrFalseMethdo(boolean flag){
return ((runnable, falseConsumer) -> {
if(flag){
runnable.run();
}else {
falseConsumer.run();
}
});
}
執行結果:
5 總結
Function函式式介面是java 8新加入的特性，可以和lambda運算式完美結合，是非常重要的特性,可以極大的簡化代碼，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/538696.html
標籤：其他