- 一、自定义函数式接口
- 1、自定义一个函数式接口
- 2、定义一个函数式接口实现类
- 3、实践和理解
- 二、java内置的函数式接口
- 1、JDK 1.8 之前已有的函数式接口
- 2、JDK 1.8 新增加的函数接口:
- 2.1 函数式接口Function
- 2.2 断言接口Predicate
- 2.3消费型接口Consumer
- 2.4 供给型接口Supplier
- 3、其他相关接口及其描述:
一、自定义函数式接口
函数式接口 (Functional Interface) 就是一个有且仅有一个抽象方法,但是可以有多个非抽象方法的接口。
函数式接口是为了lambda 表达式服务,函数式接口的存在是 lambda 表达式出现的前提,接下来我们先介绍下函数式接口。
首先我们来看一下,如何定义一个函数式接口:
- 这个接口具有唯一的一个抽像方法
sayMessage()
- 不能在函数式接口中定义多个抽象方法,但可以定义默认方法、静态方法、定义java.lang.Object里的public方法。
1、自定义一个函数式接口
package com._520xuzai.lambda;
//可以使用@FunctionalInterface注解修饰,对该接口做检查;如果接口里,有多个抽象方法,使用该注解,会有语法错误。
@FunctionalInterface
public interface IFunctionTest<T> {
void sayMessage(T x);
// void sayMessage2(T x); //这个接口必须具有唯一的一个抽像方法
default void doSomeWork1(){
// Method body
}
default void doSomeWork2(){
// Method body
}
static void printHello(){
System.out.println("Hello");
}
static void printHello2(){
System.out.println("Hello2");
}
@Override
boolean equals(Object obj);
}
2、定义一个函数式接口实现类
为便于更好的理解,我们同时定义一个接口实现类作为演示
package com._520xuzai.lambda.impl;
import com._520xuzai.lambda.IFunctionTest;
public class FunctionTestImpl<T> implements IFunctionTest<T> {
@Override
public void sayMessage(T x) {
System.out.println(x);
}
}
3、实践和理解
package com._520xuzai.lambda;
import com._520xuzai.lambda.impl.FunctionTestImpl;
public class FunctionTestMain {
public static void main(String[] args) {
//使用匿名内部类的方式
IFunctionTest<String> functionTest2 = new IFunctionTest<String>() {
@Override
public void sayMessage(String x) {
System.out.println(x);
}
};
functionTest2.sayMessage("自定义函数式接口2");
//定义实现类方式
IFunctionTest<String> functionTest3 = new FunctionTestImpl<>();
functionTest3.sayMessage("自定义函数式接口3");
//使用lambda表达式的方式
IFunctionTest<String> functionTest = str -> System.out.println(str);
functionTest.sayMessage("自定义函数式接口");
}
}
二、java内置的函数式接口
1、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
2、JDK 1.8 新增加的函数接口:
java.util.function包含了很多类,用来支持Java的函数式编程,该包中的函数式接口 43 个,最主要的是这四个:
- 功能性接口:Function<T,R>
- 断言性接口:Predicate
- 供给性接口:Supplier
- 消费性接口:Consumer
函数式接口 | 参数类型 | 返回类型 | 用途 |
Function | T | R | 对类型T参数操作,返回R类型参数,包含方法 R apply(T t) |
Predicate | T | boolean | 断言型接口,对类型T进行条件筛选操作,返回boolean,包含方法 boolean test(T t) |
Supplier | 无 | T | 返回T类型参数,方法是T get() |
Consumer | T | void | 对类型T参数操作,无返回结果,包含方法 void accept(T t) |
2.1 函数式接口Function
Function中没有具体的操作,具体的操作需要我们去为它指定,apply具体返回的结果取决于传入的lambda表达式。
源码查看:
// T 是传入参数
// R 是返回参数
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
/**
* 先做传入的Function类型的参数的apply操作,再做当前这个接口的apply操作
* V表示这个Function类型的参数的传入参数类型,也就是本接口的T类型
* @param before
* @param <V>
* @return
*/
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
/**
* 先做本接口的apply操作,再做传入的Function类型的参数的apply操作
* @param after
* @param <V>
* @return
*/
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
/**
* 静态方法表示,这个传入的泛型参数T的本身
* @param <T>
* @return
*/
static <T> Function<T, T> identity() {
return t -> t;
}
}
测试方法
public String strHandle(String str, Function<String,String> fun){
return fun.apply(str);
}
//功能性接口
@Test
public void testFunction(){
Function<Integer,Integer> A=i->i+1;
Function<Integer,Integer> B=i->i*i;
System.out.println("F1:"+B.apply(A.apply(5)));
System.out.println("F1:"+B.compose(A).apply(5));
System.out.println("F2:"+A.apply(B.apply(5)));
System.out.println("F2:"+B.andThen(A).apply(5));
String newStr=strHandle("\t\t\t woshi nide ",(str)->str.trim());
System.out.println("功能性接口:"+ newStr);
}
//输出结果
// F1:36
// F1:36
// F2:26
// F2:26
// 功能性接口:woshi nide
2.2 断言接口Predicate
Predicate适合在工具类和条件筛选的条件下使用,减少if…else的使用,并且使用灵活
源码查看:
@FunctionalInterface
public interface Predicate<T> {
/**
* 该方法是接受一个传入类型,返回一个布尔值.此方法应用于判断
* @param t
* @return
*/
boolean test(T t);
/**
* 该些方法接收的是一个Predicate类型参数,返回的也是一个Predicate类型.
* and方法用于两个判断是否都成立,与关系型运算符"&&"相似
* @param other
* @return
*/
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
/**
* 该方法没有传入参数,返回一个Predicate类型.此方法用于对判断进行取反.与关系型云算法"!"相似
* @return
*/
default Predicate<T> negate() {
return (t) -> !test(t);
}
/**
* or方法则用于两个判断是否有一个成立.与关系型运算符"||"相似
* @param other
* @return
*/
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
/**
* 该方法接收一个Object对象,返回一个Predicate类型.此方法用于判断第一个test的方法与第二个test方法相同(equal)
* @param targetRef
* @param <T>
* @return
*/
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}
编写一个工具类示例:
package com._520xuzai.lambda.util;
import java.util.function.Predicate;
public class PredicateUtil {
public static boolean judgeString(String str, Predicate<String> p){
if(null == str){
return false;
}
return p.test(str);
}
public static boolean judgeNoString(String str, Predicate<String> p){
if(null == str){
return false;
}
return p.negate().test(str);
}
public static boolean judgeAndDoubleString(String str, Predicate<String> p1, Predicate<String> p2){
if(null == str){
return false;
}
return p1.and(p2).test(str);
}
public static boolean judgeOrDoubleString(String str, Predicate<String> p1, Predicate<String> p2){
if(null == str){
return false;
}
return p1.or(p2).test(str);
}
}
测试:
//断言型接口
@Test
public void testPredicate(){
String testString = "abcde";
// 判断字符串长度是否大于4
System.out.println(PredicateUtil.judgeString(testString, p->p.length()>4));
// 判断字符串长度是否大于4再取反
System.out.println(PredicateUtil.judgeNoString(testString,p->p.length()>4));
// 判断字符串长度是否大于4并且小于8
System.out.println(PredicateUtil.judgeAndDoubleString(testString,p->p.length()>4,p->p.length()<8));
// 判断字符串长度是否小于4并且大于8
System.out.println(PredicateUtil.judgeOrDoubleString(testString,p->p.length()<4,p->p.length()>8));
// 判断当前方法是否是"test"方法.
System.out.println(Predicate.isEqual("test").test("test"));
System.out.println(Predicate.isEqual("test").test("test1"));
}
// 输出结果
// true
// false
// true
// false
// true
// false
2.3消费型接口Consumer
源码查看:
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
/**
* 先做本接口的accept操作,
* 然后在做传入的Consumer类型的参数的accept操作
* @param after
* @return
*/
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}
简单示例:
//消费性接口
@Test
public void testConsumer(){
happy(10000,(m)-> System.out.println("这次消费了"+m+"元"));
JDKBuiltInFunctionTest consumerTest = new JDKBuiltInFunctionTest();
Consumer<Integer> consumer = i->System.out.println(i);
IntConsumer intConsumer = i-> System.out.println(i);
consumerTest.test(consumer);//面向对象式的对象传递
consumerTest.test(intConsumer::accept);//函数时方式,传递行为--等价于下面
consumerTest.test(i -> System.out.println(i));
}
public void test(Consumer<Integer> consumer){
consumer.accept(100);
}
public void happy(double money, Consumer<Double> con){
con.accept(money);
}
2.4 供给型接口Supplier
源码查看
@FunctionalInterface
public interface Supplier<T> {
/**
* 这个接口,只是为我们提供了一个创建好的对象
* @return
*/
T get();
}
示例
//供给性接口
@Test
public void testSupplier(){
Supplier<String> supplier = String::new;
System.out.println(supplier.get());//""
Supplier<Map> supplierEmp = HashMap::new;
Map map = supplierEmp.get();
map.put("name","名字");
System.out.println(map.get("name"));//名字
}
3、其他相关接口及其描述:
序号 | 接口 & 描述 |
1 | BiConsumer<T,U> 代表了一个接受两个输入参数的操作,并且不返回任何结果 |
2 | BiFunction<T,U,R> 代表了一个接受两个输入参数的方法,并且返回一个结果 |
3 | BinaryOperator<T> 代表了一个作用于于两个同类型操作符的操作,并且返回了操作符同类型的结果 |
4 | BiPredicate<T,U> 代表了一个两个参数的boolean值方法 |
5 | BooleanSupplier 代表了boolean值结果的提供方 |
6 | Consumer<T> 代表了接受一个输入参数并且无返回的操作 |
7 | DoubleBinaryOperator 代表了作用于两个double值操作符的操作,并且返回了一个double值的结果。 |
8 | DoubleConsumer 代表一个接受double值参数的操作,并且不返回结果。 |
9 | DoubleFunction<R> 代表接受一个double值参数的方法,并且返回结果 |
10 | DoublePredicate 代表一个拥有double值参数的boolean值方法 |
11 | DoubleSupplier 代表一个double值结构的提供方 |
12 | DoubleToIntFunction 接受一个double类型输入,返回一个int类型结果。 |
13 | DoubleToLongFunction 接受一个double类型输入,返回一个long类型结果 |
14 | DoubleUnaryOperator 接受一个参数同为类型double,返回值类型也为double 。 |
15 | Function<T,R> 接受一个输入参数,返回一个结果。 |
16 | IntBinaryOperator 接受两个参数同为类型int,返回值类型也为int 。 |
17 | IntConsumer 接受一个int类型的输入参数,无返回值 。 |
18 | IntFunction<R> 接受一个int类型输入参数,返回一个结果 。 |
19 | IntPredicate 接受一个int输入参数,返回一个布尔值的结果。 |
20 | IntSupplier 无参数,返回一个int类型结果。 |
21 | IntToDoubleFunction 接受一个int类型输入,返回一个double类型结果 。 |
22 | IntToLongFunction 接受一个int类型输入,返回一个long类型结果。 |
23 | IntUnaryOperator 接受一个参数同为类型int,返回值类型也为int 。 |
24 | LongBinaryOperator 接受两个参数同为类型long,返回值类型也为long。 |
25 | LongConsumer 接受一个long类型的输入参数,无返回值。 |
26 | LongFunction<R> 接受一个long类型输入参数,返回一个结果。 |
27 | LongPredicate R接受一个long输入参数,返回一个布尔值类型结果。 |
28 | LongSupplier 无参数,返回一个结果long类型的值。 |
29 | LongToDoubleFunction 接受一个long类型输入,返回一个double类型结果。 |
30 | LongToIntFunction 接受一个long类型输入,返回一个int类型结果。 |
31 | LongUnaryOperator 接受一个参数同为类型long,返回值类型也为long。 |
32 | ObjDoubleConsumer<T> 接受一个object类型和一个double类型的输入参数,无返回值。 |
33 | ObjIntConsumer<T> 接受一个object类型和一个int类型的输入参数,无返回值。 |
34 | ObjLongConsumer<T> 接受一个object类型和一个long类型的输入参数,无返回值。 |
35 | Predicate<T> 接受一个输入参数,返回一个布尔值结果。 |
36 | Supplier<T> 无参数,返回一个结果。 |
37 | ToDoubleBiFunction<T,U> 接受两个输入参数,返回一个double类型结果 |
38 | ToDoubleFunction<T> 接受一个输入参数,返回一个double类型结果 |
39 | ToIntBiFunction<T,U> 接受两个输入参数,返回一个int类型结果。 |
40 | ToIntFunction<T> 接受一个输入参数,返回一个int类型结果。 |
41 | ToLongBiFunction<T,U> 接受两个输入参数,返回一个long类型结果。 |
42 | ToLongFunction<T> 接受一个输入参数,返回一个long类型结果。 |
43 | UnaryOperator<T> 接受一个参数为类型T,返回值类型也为T。 |