目录
扫描二维码关注公众号，回复：
2433511 查看本文章
函数式接口:Functional Interface
-
定义：
就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口
-
JDK 1.8之前已有的函数式接口:
java.lang.Runnable
java.util.concurrent.Callable
java.security.PrivilegedAction
java.util.Comparator
java.io.FileFilter
java.nio.file.PathMatcher
java.lang.reflect.InvocationHandler
java.beans.PropertyChangeListener
java.awt.event.ActionListener
javax.swing.event.ChangeListener
-
JDK 1.8 新增加的函数接口：
java.util.function
常用函数式接口：
| Predicate<T> | 接收T对象并返回boolean |
| BiConsumer<T, U> | 接收T、U对象，无返回值 |
| Consumer<T> | 接收T对象，无返回值 |
| Comparator<T> | 接收T对象 返回int |
| Function<T, R> | 接收T对象，返回R对象 |
| Supplier<T> | 提供T对象（例如工厂），不接收值 |
| UnaryOperator<T> | 接收T对象，返回T对象 |
| BinaryOperator<T> | 接收两个T对象，返回T对象 |
常用函数式接口示例：
package com.java.demo;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import com.java.domain.User;
/**
* 常用函数式接口示例
* @author: li
* @date: 2018年7月27日
*/
public class FIDemo {
public static void main(String[] args) {
//Predicate<T> 接收T对象并返回boolean
Predicate<String> predicate = (s) -> s.length()>0;
//返回结果为boolean类型
boolean b = predicate.test("hello");
System.out.println(b);//结果：true
String s = "test";
Predicate<String> isEmpty = String::isEmpty;
System.out.println(isEmpty.test(s));//结果：false
//Function<T, R> 接收T对象，返回R对象
Function<String, Integer> toInteger = Integer::valueOf;
//先执行toInteger 然后执行String::valueOf(即先转为Integer 然后转为String)
Function<String, String> backToString = toInteger.andThen(String::valueOf);
//返回结果为R类型
String str = backToString.apply("123");
System.out.println(str); //结果：123
//Supplier<T> 提供T对象,不接收参数
Supplier<User> personSupplier = User::new;//方法引用 User构造器
User user = personSupplier.get(); // new User
System.out.println(user); //结果：User [id=0, age=0, name=null]
//Consumer<T> 接收T对象，无返回值
List<String> list = Arrays.asList("peter", "anna", "mike", "xenia");
Consumer<String> consumer = name -> System.out.print(name+"==");
//Lambda表达式对list集合进行遍历
list.forEach(consumer); //结果：peter==anna==mike==xenia==
//Comparator<T> 接收T对象 返回int
List<String> names = Arrays.asList("jack", "mary", "tom", "bruce");
Comparator<String> comparator = (m,n) -> n.compareTo(m);
//Lambda表达式对list集合进行排序
Collections.sort(names, comparator);
//遍历list集合
for (String name : names) { //结果tom mary jack bruce
System.out.print(name+" ");
}
//BiConsumer<T, U> 接收T、U对象，无返回值
Map<Integer, String> map = new HashMap<Integer,String>();
map.put(1, "peter");
map.put(2, "anna");
map.put(3, "mike");
map.put(4, "xenia");
BiConsumer<Integer,String> biConsumer = (k,v) ->{
System.out.print("key:" + k + " ");
System.out.print("value:" + v + "===");
//结果：key:1 value:peter===key:2 value:anna===key:3 value:mike===key:4 value:xenia===
};
//Lambda表达式对map集合进行遍历
map.forEach(biConsumer);
}
}自定义函数式接口：
-
定义自定义函数式接口：
package com.java.demo;
/**
* 自定义函数式接口
* @author: li
* @date: 2018年7月27日
*/
@FunctionalInterface
public interface MyFI<T> {
void test(T t);
}
-
User实体类：
package com.java.domain;
public class User {
private int id;
private int age;
private String name;
public User() {
super();
}
public User(int id, int age, String name) {
super();
this.id = id;
this.age = age;
this.name = name;
}
//省略Getters/Setters/toString...
}
-
使用自定义函数式接口：
package com.java.demo;
import java.util.function.Supplier;
import com.java.domain.User;
/**
* 自定义函数式接口使用
* @author: li
* @date: 2018年7月27日
*/
public class diyFI {
public static void main(String[] args) {
MyFI<User> fi = u -> System.out.println("user's age is: " + u.getAge());
Supplier<User> personSupplier = User::new;
User user = personSupplier.get();
user.setAge(5);
testMyFI(user, fi);//结果：user's age is: 5
}
public static void testMyFI(User user,MyFI<User> myFI) {
myFI.test(user);
}
}