詳解如何熟練使用java函數式接口
一、函數式接口的由來
我們知道使用Lambda表達式的前提是需要有函數式接口，而Lambda表達式使用時不關心接口名，抽象方法名。隻關心抽象方法的參數列表和返回值類型。因此為瞭讓我們使用Lambda表達式更加的方法，在JDK中提供瞭大量常用的函數式接口
package com.bobo.jdk.fun;
public class Demo01Fun {
public static void main(String[] args) {
fun1((arr)->{
int sum = 0 ;
for (int i : arr) {
sum += i;
}
return sum;
});
}
public static void fun1(Operator operator){
int[] arr = {1,2,3,4};
int sum = operator.getSum(arr);
System.out.println("sum = " + sum);
}
}
/**
* 函數式接口
*/
@FunctionalInterface
interface Operator{
int getSum(int[] arr);
}
二、函數式接口介紹
在JDK中幫我們提供的有函數式接口，主要是在 java.util.function 包中。
2.1 Supplier
無參有返回值的接口，對於的Lambda表達式需要提供一個返回數據的類型。
@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
*
* @return a result
*/
T get();
}
使用：
/**
* Supplier 函數式接口的使用
*/
public class SupplierTest {
public static void main(String[] args) {
fun1(()->{
int arr[] = {22,33,55,66,44,99,10};
// 計算出數組中的最大值
Arrays.sort(arr);
return arr[arr.length-1];
});
}
private static void fun1(Supplier<Integer> supplier){
// get() 是一個無參的有返回值的 抽象方法
Integer max = supplier.get();
System.out.println("max = " + max);
}
}
2.2 Consumer
有參無返回值得接口,前面介紹的Supplier接口是用來生產數據的，而Consumer接口是用來消費數據的，使用的時候需要指定一個泛型來定義參數類型
@FunctionalInterface
public interface Consumer<T> {
/**
* Performs this operation on the given argument.
*
* @param t the input argument
*/
void accept(T t);
}
使用：將輸入的數據統一轉換為小寫輸出
public class ConsumerTest {
public static void main(String[] args) {
test(msg -> {
System.out.println(msg + "-> 轉換為小寫：" + msg.toLowerCase());
});
}
public static void test(Consumer<String> consumer){
consumer.accept("Hello World");
}
}
默認方法:andThen
如果一個方法的參數和返回值全部是Consumer類型，那麼就可以實現效果，消費一個數據的時候，首先做一個操作，然後再做一個操作，實現組合，而這個方法就是Consumer接口中的default方法 andThen方法
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
具體的操作
public class ConsumerAndThenTest {
public static void main(String[] args) {
test2(msg1->{
System.out.println(msg1 + "-> 轉換為小寫：" + msg1.toLowerCase());
},msg2->{
System.out.println(msg2 + "-> 轉換為大寫：" + msg2.toUpperCase());
});
}
public static void test2(Consumer<String> c1,Consumer<String> c2){
String str = "Hello World";
//c1.accept(str); // 轉小寫
//c2.accept(str); // 轉大寫
//c1.andThen(c2).accept(str);
c2.andThen(c1).accept(str);
}
}
2.3 Function
有參有返回值的接口，Function接口是根據一個類型的數據得到另一個類型的數據，前者稱為前置條件，後者稱為後置條件。有參數有返回值。
@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);
}
使用：傳遞進入一個字符串返回一個數字
public class FunctionTest {
public static void main(String[] args) {
test(msg ->{
return Integer.parseInt(msg);
});
}
public static void test(Function<String,Integer> function){
Integer apply = function.apply("666");
System.out.println("apply = " + apply);
}
}
默認方法：andThen，也是用來進行組合操作，
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
public class FunctionAndThenTest {
public static void main(String[] args) {
test(msg ->{
return Integer.parseInt(msg);
},msg2->{
return msg2 * 10;
});
}
public static void test(Function<String,Integer> f1,Function<Integer,Integer> f2){
/*Integer i1 = f1.apply("666");
Integer i2 = f2.apply(i1);*/
Integer i2 = f1.andThen(f2).apply("666");
System.out.println("i2:" + i2);
}
}
默認的compose方法的作用順序和andThen方法剛好相反
而靜態方法identity則是，輸入什麼參數就返回什麼參數
2.4 Predicate
有參且返回值為Boolean的接口
@FunctionalInterface
public interface Predicate<T> {
/**
* Evaluates this predicate on the given argument.
*
* @param t the input argument
* @return {@code true} if the input argument matches the predicate,
* otherwise {@code false}
*/
boolean test(T t);
}
使用：
public class PredicateTest {
public static void main(String[] args) {
test(msg -> {
return msg.length() > 3;
},"HelloWorld");
}
private static void test(Predicate<String> predicate,String msg){
boolean b = predicate.test(msg);
System.out.println("b:" + b);
}
}
在Predicate中的默認方法提供瞭邏輯關系操作 and or negate isEquals方法
package com.bobo.jdk.fun;
import java.util.function.Predicate;
public class PredicateDefaultTest {
public static void main(String[] args) {
test(msg1 -> {
return msg1.contains("H");
},msg2 -> {
return msg2.contains("W");
});
}
private static void test(Predicate<String> p1,Predicate<String> p2){
/*boolean b1 = predicate.test(msg);
boolean b2 = predicate.test("Hello");*/
// b1 包含H b2 包含W
// p1 包含H 同時 p2 包含W
boolean bb1 = p1.and(p2).test("Hello");
// p1 包含H 或者 p2 包含W
boolean bb2 = p1.or(p2).test("Hello");
// p1 不包含H
boolean bb3 = p1.negate().test("Hello");
System.out.println(bb1); // FALSE
System.out.println(bb2); // TRUE
System.out.println(bb3); // FALSE
}
}
到此這篇關於詳解如何熟練使用java函數式接口的文章就介紹到這瞭,更多相關java函數式接口內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！