java 接口 函数_Java常用的函数式接口

Supplier接口

java.util.function.Supplier接口仅包含一个无参的方法：

T get()：用来获取一个泛型参数指定类型的对象数据。

Supplier接口被称之为生产型接口，指定接口的泛型是什么类型，那么接口中的 get方法就会产生什么类型的数据。

示例

package cn.last.demo;

/*

Supplier接口的使用

*/

import java.util.function.Supplier;

public class Test {

// 定义一个方法，方法的参数传递Supplier接口，泛型指定为String，get方法就返回一个String

public static String getString(Supplier sup) {

return sup.get();

}

public static void main(String[] args) {

// 调用getString方法，方法的参数是一个Supplier接口,即函数式接口，可以使用Lambda表达式

// 重写其中的 get方法

String s1 = getString(() -> {

return "hello";

});

System.out.println(s1);

// 优化Lambda表达式

String s2 = getString(() -> "hello");

System.out.println(s2);

}

}

Consumer接口

java.util.function.Consumer接口则正好与 Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。

Comsumer接口中包含抽象方法：void accept(T t)，意为消费一个指定泛型的数据。

Comsumer接口是一个消费型接口，泛型指定什么类型，就可以使用 accept方法消费什么类型的数据，至于具体怎么消费(使用)，需要自定义(输出，计算……)

示例

package cn.last.demo;

import java.util.function.Consumer;

public class Test {

/*

定义一个方法，参数：字符串和 Consumer接口，泛型指定 String

用来使用 Consumer接口消费字符串

*/

public static void consume(String name, Consumer con) {

con.accept(name);

}

public static void main(String[] args) {

consume("hello", (String name) -> {

// 消费方式 打印输出

System.out.println(name);

// 消费方法 反转

/*

StringBuilder是一个字符串缓冲区，里面有一个方法

reverse方法可以将此字符序列反转，再使用 toString方法转换成String类

*/

String rename = new StringBuilder(name).reverse().toString();

System.out.println(rename);

});

}

}

默认方法：andThen

如果一个方法参数和返回值都是Consumer类型，那么就可以实现效果：消费数据的时候，首先做一个操作，然后再做一个操作，实现组合(连接)，而这个方法就是Consumer接口中的 default方法andThen方法，下面式 JDK源码：

default Consumer andThen(Consumer super T> after) {

Objects.requireNonNull(after);

return (T t) -> { accept(t); after.accept(t); };

}

备注：java.util.Objects的requireNonNull静态方法将会在参数为 null 时主动抛出 NullPointerException异常。这省去了重复编写 if语句和抛出空指针异常的麻烦。

示例：

package cn.last.demo;

import java.util.function.Consumer;

/*

Consumer接口的默认方法：andThen

作用：需要两个 Consumer接口，可以把两个Consumer接口组合到一起,对数据进行消费

注：谁写前边，谁先消费

*/

public class Test {

/*

定义一个方法，参数传递一个字符串和两个 Consumer接口，泛型都使用 String

*/

public static void method(String s, Consumer con1, Consumer con2) {

con1.andThen(con2).accept(s);

}

public static void main(String[] args) {

String s = "Hello";

method(s,

(t) -> {

// 消费方式：把字符串变成大写

System.out.println(s.toUpperCase());

},

(t) -> {

// 消费方式：把字符串变成小写

System.out.println(s.toLowerCase());

}

);

}

}

Predicate接口

java.util.function.Predicate接口

作用：对某种数据类型的数据进行判断，结果返回一个 boolean值

Predicate接口中包含一个抽象方法：

boolean test(T t)：用来对指定的数据类型进行判断

结果：

符合条件，返回 true

不符合条件，返回 false

示例：

package cn.last.demo;

import java.util.function.Predicate;

public class Test {

/*

定义一个方法，参数传递一个字符串

和一个Predicate接口，泛型使用String

使用Predicate中的方法 test对字符串进行判断，并把判断的结果返回

*/

public static boolean checkString(String s, Predicate pre) {

return pre.test(s);

}

public static void main(String[] args) {

String s = new String("abcdef");

// 调用checkString方法，函数式接口，使用Lambda表达式

boolean b = checkString(s, str -> str.length() > 5);

System.out.println(b);

}

}

默认方法：and

JDK源码:

copydefault Predicate and(Predicate super T> other) {

Objects.requireNonNull(other);

return (t) -> test(t) && other.test(t);

}

示例：

package cn.last.demo;

import java.util.function.Predicate;

/*

需求：

判断一个字符串，有两个判断条件

1. 字符串的长度是否大于5

2. 字符串中是否包含a

两个条件必须同时满足，我们就可以使用 && 运算符连接

*/

public class Test {

public static boolean checkString(String s, Predicate pre1, Predicate pre2) {

return pre1.and(pre2).test(s);

// 等价于 return pre1.test(s) && pre2.test(s);

}

public static void main(String[] args) {

String s = "I Love Java!";

boolean b = checkString(s, (String str) -> {

// 对字符串长度是否大于5进行判断

return str.length() > 5;

}, (String str) -> {

// 对字符串中是否包含a进行判断

return str.contains("a");

});

System.out.println(b);

}

}

默认方法：or

JDK源码：

copydefault Predicate or(Predicate super T> other) {

Objects.requireNonNull(other);

return (t) -> test(t) || other.test(t);

}

默认方法：negate

JDK源码：

copy default Predicate negate() {

return (t) -> !test(t);

}

Function接口

java.util.function.Function接口用来根据一个类型的数据，得到另一个类型的数据。前者称为前置条件，后者称为后置条件。

Function接口中最主要的抽象方法为：R apply(T t)，根据类型T的参数获取类型R的结果。

使用场景例如：将String类型转换为Integer类型。

注意事项：

Function的前置条件泛型和后置条件泛型可以相同。

示例：

package cn.last.demo;

import java.util.function.Function;

public class Test {

/*

定义一个方法，

方法的参数传递一个字符串类型的整数

方法的参数传递一个Function类型的接口

使用Function接口中的方法apply，把字符串类型的整数转换为Integer类型

*/

public static Integer change(String s, Function fun) {

// 自动拆箱 Integer --> int

return fun.apply(s);

}

public static void main(String[] args) {

int in = change("123", Integer::parseInt);

System.out.println(in + 1);

}

}

默认方法：andThen

Function接口中的默认方法andThen：用来进行组合操作。

示例

package cn.last.demo;

import java.util.function.Function;

/*

需求：

把String类型的"123"转换为Integer类型，再加上10

把Integer类型转换为String类型

分析：

转换了两次

1. String --> Integer

Function fun1

Integer in = fun1.apply("123") + 10;

2. Integer --> String

Function fun2

String s = fun2.apply(in);

使用andThen方法，把两次转换组合在一起使用

*/

public class Test {

public static void change(String s, Function fun1, Function fun2) {

String str = fun1.andThen(fun2).apply(s);

System.out.println(str);

}

public static void main(String[] args) {

change("1234", s -> Integer.parseInt(s) + 100, String::valueOf);

}

}