接口 参数 返回 中文 示例 Supplier None T 提供者 工厂方法创建对象 Consumer T void 消费者 输出一个值 Predicate T boolean 谓语,顾名思义,中文中的‘是’与‘不是’是中文语法的谓语 Function T R 函数 获得某个对象的名字 BinaryOperator (T, T) T 二元操作符,二元(就是数学里二元一次方程那个二元,代表 2 个的意思),双重的。 即有两个操作数 例如求两个数的乘积(*) UnaryOperator T T 一元操作符,只有一个操作数 逻辑非(!)
Supplier 接口代表一个结果的提供者。 Supplier 接口是用来生成数据的,数据的类型通过泛型参数给定。 使用 get()方法获得返回值,不要求每次调用时都返回新的或不同的结果。
public interface Supplier { /** 得到一个结果,返回 T 对象 */ T get(); }
T get() 获得指定类型的数据
案例需求get()方法的基本使用,在 Supplier 接口中 get 方法返回一个字符串。 案例步骤:1) 使用 Lambda 创建 Supplier 对象,泛型类型为 String,方法体返回一个字符串,return 可以省略。2) 调用 Supplier 的 get()方法得到字符串,并打印输出
public class DemoSupplier { public static void main(String[] args) { //使用 Lambda 创建 Supplier 对象 Supplier supplier = () -> "Hello Java!"; //输出它的值 System.out.println(supplier.get()); } }
案例需求:
下面的例子演示了如何通过调用一个静态方法,生成一个员工对象返回。
使用构造方法做为 Supplier 参数的引用。
案例步骤:1) 在主类内部创建一个私有的静态 Employee 对象,重写 toString()方法,返回一个字符串:"我是员工"。
2) 在 main 函数中创建一个 Supplier 对象,泛型类型是 Employee。使用 Lambda 传入 Supplier 对象,方法体实例化员工对象,省略 return 方法。
3) 使用 supplier 对象的 get()方法得到员工对象
4) 打印输出员工对象
因为 Employee 对象是私有的,外部类无法直接实例化员工对象。
调用 Supplier 的 get()方法来生成员工对象,这样做的目的是可以控制员工对象的生成方式,类似于工厂模式。
//主类 public class DemoSupplier { //员工类 private static class Employee {//注意static public String toString() { return "我是员工"; } } public static void main(String[] args) { //使用 Lambda 传入 Supplier 对象,将生成一个员工对象//此时仅仅是实例化了接口并未执行里面代码 Supplier supplier = ()->new Employee(); //输出员工对象 System.out.println(supplier.get()); } }
需求说明求数组中的最大值,使用 Supplier 接口作为方法参数类型,通过 Lambda 表达式求出 int 数组中的最大值。 需求分析1) 定义整型数组 int[] arr = {12,68,10,2,99,313,46};2) 创建静态方法 getMax():返回 int 类型,将 Supplier 做为参数,泛型类型为 Integer,方法体调用 get()方法返回值。3) 在 main 函数中调用 getMax()方法,使用 Lambda 传入 Supplier 对象,并且实现查找最大值的功能。4) 在 Lambda 表达式相当于方法体:遍历每个元素,比较大小,找出最大值。
public class DemoSupplier { public static void main(String[] args) { int[] arr = {12, 68, 10, 2, 99, 313, 46}; // 调用 getMax 方法获得最大值,Lambda 相当于方法体 int num = getMax(() -> { int max = arr[0]; for (int i = 1; i < arr.length; i++) { if (max < arr[i]) { max = arr[i]; } } return max; }); //输出最大值 System.out.println("最大值是:" + num); } //使用 Supplier 做为参数 public static int getMax(Supplier<Integer> supplier) { return supplier.get(); } }
Consumer 接口代表接受单一的输入变量而且没有返回值的一类操作。 它的作用和 Supplier 相反,是消费一个数据的,消费的数据类型需要通过泛型指定。
它的源代码如下:
public interface Consumer<T>{ //接受 t 对象,无返回值 void accept(T t); //默认的组合方法,参数和返回值都是 Consumer 类型,先调用自己的 accept()方法,再调用参数的 accept()方法 default Consumer<T> andThen(Consumer<T> after) { Objects.requireNonNull(after); return (T t) -> { accept(t); after.accept(t); }; } }
void accept(T t) 接受对给定的参数进行操作。
Consumer 接口中的默认方法:
default Consumer<T> andThen(Consumer<T> after)然后 如果一个方法的参数和返回值全都是 Consumer<T> 类型,那么就可以实现效果: 消费一个数据的时候,首先做一个操作,然后再做另一个操作,两个操作依次执行,实现一种组合操作。 而这个方法就是 Consumer 接口中的默认方法 andThen。
实现步骤:1) 使用 Lambda 创建 Consumer 对象,直接打印传入的字符串数据。2) 调用 Consumer 的 accept()方法,在 accept()方法中传入一个字符串数据。
public class DemoConsumer { public static void main(String[] args) { //创建 Consumer 对象,打印传入的变量 t Consumer consumer = t -> System.out.println(t); //调用 Consumer 中的方法 consumer.accept("Hello Lambda"); } }
List 和 Set 集合中遍历的 forEach 方法它的参数就是 Consumer,
请看下面的代码: 案例需求:1) 创建一个数组,使用 Arrays.asList("孙悟空", "猪八戒", "白骨精", "嫦娥") 转成 List 对象。2) 使用 forEach 方法打印每一个元素,forEach 中使用 Lamba 表达式输出传入的字符串
public class DemoForEach { public static void main(String[] args) { //将数组转成 List 对象 List names = Arrays.asList("孙悟空", "猪八戒", "白骨精", "嫦娥"); //打印每一个字符串,forEach 的参数就是 Consumer names.forEach(t -> System.out.println(t)); } }
default void forEach(Consumer<T> action) { Objects.requireNonNull(action);//判断某一对象是否不为null for (T t : this) { action.accept(t); } } 这是定义在 java.lang.Iterable 接口中的默认方法, 参数就是 Consumer 对象,方法体内对当前集合使用 for遍历,this 就是集合对象。 每次对一个元素调用 accept()方法。 而我们外部调用的代码中对 accept()方法进行了实现,输出了每个元素。 public static T requireNonNull(T obj) 静态方法,JDK7 中新增的方法,判断传入的对象是否为 NULL, 如果是 NULL 则抛出异常,不为 NULL 则返回对象本身。常用于方法或构造方法中传入对象参数的校验。
default Consumer<T> andThen(Consumer super T> after) {
Objects.requireNonNull(after); //判断 after 是否为 null
//先调用自己的 accept()方法,再调用参数的 accept()方法
return (T t) -> { accept(t); after.accept(t); };
}
要想实现组合,需要两个或多个 Lambda 表达式,而 andThen 的语义正是执行“一步接一步”操作。
andThen 方法演示示例 案例需求:将字符串 Hello 首先打印大写的 HELLO,然后打印小写的 hello 实现步骤:1) 创建 Consumer 对象 c1,使用 Lambda 打印 s 对象的大写2) 创建 Consumer 对象 c2,使用 Lambda 打印 s 对象的小写3) c1 调用 andThen(c2)方法,再调用 accept("字符串"),完成依次的操作。
public class DemoConsumer { public static void main(String[] args) { //打印大写 Consumer<String> c1 = s -> System.out.println(s.toUpperCase()); //打印小写 Consumer<String> c2 = s-> System.out.println(s.toLowerCase()); //调用方法 c1.andThen(c2).accept("Hello Consumer"); } }
需求说明格式化打印信息,下面的字符串数组当中存有多条信息,
请按照格式“姓名:XX。性别:XX。”的格式将信息打印出来。
要求将打印姓名的动作作为第一个 Consumer 接口的 Lambda 实例,
将打印性别的动作作为第二个Consumer 接口的 Lambda 实例,将两个 Consumer 接口按照顺序“拼接”到一起。以下数组共 5 个元素,每个元素包含 2 项信息用逗号分隔。String[] arr = { "张飞,男", "貂蝉,女", "曹操,男","孙尚香,女","小乔,女" };
实现步骤1) 创建静态方法 printInfo(),有 3 个参数,
第 1 个是需要打印的字符串数组,
第 2 个是 Consumer用于打印姓名 name,
第 3 个是 Consumer用于打印性别 gender。
2) 在 printInfo 方法中遍历数组中每个元素,再调用 name.andThen(gender).accept(单个元素)
3) 每调用一次 andThen()方法,在下面输出一行横线
4) 在 main 函数中创建上面要遍历的数组
5) 调用 printInfo 方法,传入 3 个参数,
第 1 个参数是数组,
第 2 个参数使用 Lambda 打印姓名,参数 s 表示数组中的每个元素。
第 3 个参数使用 Lambda 打印性别。
public class DemoConsumerPrint { public static void main(String[] args) { String[] arr = { "张飞,男", "貂蝉,女", "曹操,男","孙尚香,女"}; //这里的 s 表示数组中的每个元素 printInfo(arr, s ->{ System.out.println("姓名:" + s.split(",")[0]); },s ->{ System.out.println("性别:" + s.split(",")[1]); }); } public static void printInfo(String[] arr, Consumer<String> name, Consumer<String> gender) { for (String s : arr) { name.andThen(gender).accept(s); System.out.println("------------------"); } } }
Predicate 中文意思为谓语,"我是一个程序员","是"或"不是"就是谓语。 它代表只有一个变量的函数,返回 boolean 类型。 有时候我们需要进行某种判断,从而得到一个 boolean 值的结果。 可以使用 java.util.function.Predicate接口。
public interface Predicate<T> { boolean test(T t); //抽象方法,对 t 进行测试,返回 boolean 类型 /** - 组合方法,将当前的谓语与另一个谓语进行短路的与操作,返回一个谓语对象 */ default Predicate<T> and(Predicate super T> other) { Objects.requireNonNull(other); //判断 other 是否为空 return (t) -> test(t) && other.test(t); } /** - 对当前的谓语进行逻辑非操作,返回一个谓语对象 */ default Predicate<T> negate() { return (t) -> !test(t); } /** - 组合方法,将当前的谓语与另一个谓语进行短路的或操作,返回一个谓语对象 */ default Predicate<T> or(Predicate super T> other) { Objects.requireNonNull(other); return (t) -> test(t) || other.test(t); } /** - 静态方法,判断 test(object)方法传入的对象是否与参数 targetRef 对象相等 */ static Predicate<T> isEqual(Object targetRef) { return (null == targetRef) ? Objects::isNull : object -> targetRef.equals(object); / } }
boolean test(T t) 对 t 进行指定条件的测试,返回 boolean 类型
案例需求:判断 test("字符串")方法给定的参数长度是否大于 5 案例步骤:1) 创建一个 Predicate 谓语对象,使用 Lambda 实现 boolean test(T t)方法2) 方法体的参数是 s,返回字符串的长度大于 5,省略 return 关键字。3) 两次调用 test()方法看运行结果,第 1 次使用字符串 Hello,第 2 次使用字符串 Predicate
public class DemoPredicateTest { public static void main(String[] args) { //创建一个 Predicate 谓语对象,boolean test(T t)方法接收字符串类型,返回 boolean 类型 Predicate<String> predicate = s -> s.length() > 5; //两次调用 test 方法看运行结果 System.out.println("Hello 的长度是否大于 5:" + predicate.test("Hello")); System.out.println("Predicate 的长度是否大于 5:" + predicate.test("Predicate")); } }
既然是条件判断,就会存在与、或、非三种常见的逻辑关系。 其中将两个 Predicate 条件使用“与”逻辑连接起来实现“并且”的效果时,可以使用 default 方法 and。 这个默认方法接收一个 Predicate 参数,返回一个 Predicate参数。
其 JDK 源码为:
/** 组合方法,将当前的谓语与另一个谓语进行短路的与操作,返回一个谓语对象 */ default Predicate<T> and(Predicate super T> other) { Objects.requireNonNull(other); return (t) -> test(t) && other.test(t); }
案例需求:判断一个字符串是否包含指定的字符串:既包含大写“H”,又要包含大写“W” 案例步骤:1) 创建 2 个需要判断的字符串:s1="Hello world"和 s2="Hello World"2) 使用 Lambda 表达式,创建两个 Predicate 对象3) 判断字符串 s 是否包含 H4) 判断字符串 s 是否包含 W5) 调用 and 方法和 test 方法,分别输出 s1 和 s2 的结果
public class DemoPredicateAnd { public static void main(String[] args){ //创建 2 个需要判断的字符串 String s1 = "Hello world"; String s2 = "Hello World"; // 使用 Lambda 表达式,创建两个 Predicate 对象 //判断 s 是否包含 H Predicate<String> p1 = s -> s.contains("H"); //判断 s 是否包含 W Predicate<String> p2 = s -> s.contains("W"); //调用 and 方法 System.out.println(s1 + "是否包含 H 和 W:" + p1.and(p2).test(s1)); System.out.println(s2 + "是否包含 H 和 W:" + p1.and(p2).test(s2)); } }
与 and 的“与”类似,默认方法 or 实现逻辑关系中的“或”操作。 这个默认方法接收一个 Predicate 参数,返回一个 Predicate 参数。
JDK 源码为:
/** *组合方法,将当前的谓语与另一个谓语进行短路的或操作,返回一个谓语对象 */ default Predicate<T> or(Predicate super T> other) { Objects.requireNonNull(other); return (t) -> test(t) || other.test(t); }
案例需求:判断一个字符串的长度大于 10 或者小于 5 案例步骤:1) 创建三个字符串 s1,s2,s3 内容如下图2) 使用 Lambda 创建 2 个 Predicate 接口对象,第 1 个判断长度是否大于 10,每 2 个判断长度是否小于 53) 调用 or 和 test 方法输出每个字符串的测试结果
public class DemoPredicateOr { public static void main(String[] args) { //创建三个字符串 String s1 = "Hello World"; //大于 10 String s2 = "Java"; //小于 5 String s3 = "I am boy"; //既不大于 10,又不小于 5 //使用 Lambda 创建 2 个 Predicate 接口对象 Predicate<String> p1 = s -> s.length() > 10; Predicate<String> p2 = s -> s.length() < 5; //输出每个字符串的测试结果 System.out.println(s1 + "=" + p1.or(p2).test(s1)); System.out.println(s2 + "=" + p1.or(p2).test(s2)); System.out.println(s3 + "=" + p1.or(p2).test(s3)); } }
“与”、“或”已经了解了,剩下的“非”(取反)也会简单。方法没有参数,返回值为 Predicate。
默认方法 negate的 JDK 源代码为:
/** *对当前的谓语进行逻辑非操作,返回一个谓语对象 */ default Predicate<T> negate() { return (t) -> !test(t); } 从实现中很容易看出,它是执行了 test 方法之后,对结果 boolean 值进行“!”取反而已。 要在 test 方法调用之前调用 negate 方法,正如 and 和 or 方法一样。
案例需求:判断年龄是否小于 18 岁,将判断的结果取反。 案例步骤1) 创建 2 个整数类型的年龄,一个 25,一个 15 岁。2) 使用 Lambda 创建 1 个 Predicate,判断年龄小于 18 岁。3) 使用 nagate()取反以后再调用 test()方法,输出两个年龄的结果
public class DemoPredicateNegate { public static void main(String[] args) { int age1 = 25; //25 岁 int age2 = 15; //15 岁 Predicate<Integer> predicate = (a) -> a < 18; //判断是否小于 18 岁 System.out.println(age1 + "小于 18 岁,取反:" + predicate.negate().test(age1)); System.out.println(age2 + "小于 18 岁,取反:" + predicate.negate().test(age2)); } }
Predicate 中唯一的静态方法,方法的参数是两个 Object 类型,返回一个 Predicate 类型。 作用:根据 Objects.equals(Object, Object)方法比较两个参数是否相等, 一个对象通过 isEqual()传入,另一个对象通过 test()传入。 java.util.Objects 类中的方法 说明 public static boolean equals(Object a,Object b) 作用:用于比较两个对象是否相等 参数:a 和 b 是要比较的两个对象 返回:如果两个对象相等,则返回 true,否则返回 false
JDK 源代码为:
/** *静态方法,判断 test(object)方法传入的对象是否与参数 targetRef 对象相等 */ static <T> Predicate<T> isEqual(Object targetRef) { return (null == targetRef) ? Objects::isNull : object -> targetRef.equals(object); }
案例需求:比较两个字符串是否相等 案例步骤:1) 通过静态方法 isEqual("newboy"),直接返回 Predicate 对象2) 调用 Predicate 中的 test()方法传入另两个字符串分别比较
public class DemoPredicateIsEqual { public static void main(String[] args) { //通过静态方法直接返回 Predicate 对象 Predicate predicate = Predicate.isEqual("newboy"); //调用 test()方法传入另两个字符串分别比较 System.out.println("两个字符串是否相等:" + predicate.test("newboy")); System.out.println("两个字符串是否相等:" + predicate.test("NewBoy")); } }
需求说明集合当中有多条“姓名+性别”的信息如下:"张飞,男", "貂蝉,女", "曹操,男","孙尚香,女","小乔,女"
请通过 Predicate 接口的 and 组合方法,将符合要求的字符串筛选到集合 ArrayList 中,
需要同时满足两个条件:1) 必须为女生 2) 姓名为两个字
开发步骤:1) 创建第 1 个 Predicate 判断条件:使用逗号分隔的第 0 个元素姓名长度是 2
2) 创建第 2 个 Predicate 判断条件:使用逗号分隔的第 1 个元素性别等于女
3) 创建一个新的 List 集合,用于存储过滤以后符合条件的字符串
4) 使用 List 中的 forEach(Lambda)遍历上面的原始 List 集合,
使用 Predicate 中的 and 和 test 方法判断每个元素
5) 两个条件都为真才添加到新的 List 集合中
6) 创建第 1 个 Consumer 接口,输出使用逗号分隔的第 0 个元素姓名
7) 创建第 2 个 Consumer 接口,输出使用逗号分隔的第 1 个元素性别
8) 使用 List 中的 forEach(Lambda)遍历,输出过滤后的新的集合
9) 使用 Consumer 接口中的 andThen 和 accept 方法,输出每一个元素
public static void main(String[] args) { //从数组中创建一个 List 集合 List<String> list = Arrays.asList("张飞,男", "貂蝉,女", "曹操,男","孙尚香,女","小乔,女"); //创建第 1 个 Predicate 判断条件:使用逗号分隔的第 0 个元素姓名长度是 2 Predicate<String> pname = s -> s.split(",")[0].length() ==2; //创建第 2 个 Predicate 判断条件:使用逗号分隔的第 1 个元素性别等于女 Predicate<String> pgender = s-> s.split(",")[1].equals("女"); //创建一个新的 List 集合 List<String> infos = new ArrayList<>(); //使用 Lamba 中的 forEach()遍历上面的 List 集合,使用 Predicate 中的 and 和 test 方法判断每个元素 list.forEach(s -> { //两个都为真才添加到集合中 if (pname.and(pgender).test(s)) { infos.add(s); } }); //创建第 1 个 Consumer 接口,输出使用逗号分隔的第 0 个元素姓名 Consumer<String> cname = s -> System.out.println("姓名:" + s.split(",")[0]); //创建第 2 个 Consumer 接口,输出使用逗号分隔的第 1 个元素性别 Consumer<String> cgender = s -> System.out.println("性别:" + s.split(",")[1]); //使用 Lamba 中的 forEach()遍历,输出过滤后的集合 infos.forEach(s -> { //使用 Consumer 接口中的 andThen 和 accept 方法,每输出一个元素隔一条线 cname.andThen(cgender).accept(s); System.out.println("---------------"); }); }
Function接口: 根据一个参数得到另一个参数值,前面称为计算的参数,后面称为计算的结果。 有进有出,所以称为“函数 Function”。 类似于数学中的函数,通过一个变量求出另一个变量的值。如:f(x) = 2x+3
以下是它的 Java 源代码
import java.util.Objects; /** 代表通过一个变量求出另一个变量的结果的函数 @param 输入给函数的变量 @param 函数输出的结果 */ public interface Function<T, R> { /** 对给定的变量 t 进行计算,得到返回的结果 R */ R apply(T t); /** 默认组合方法,先计算当前函数,再计算传入的函数 */ default <V> Function<T, V> andThen(Function super R, ? extends V> after) { Objects.requireNonNull(after); return (T t) -> after.apply(apply(t)); } /** 默认组合方法,先计算传入的函数,再计算当前函数 */ default <V> Function<V, R> compose(Function super V, ? extends T> before) { Objects.requireNonNull(before); return (V v) -> apply(before.apply(v)); } /** 静态方法:总是返回它的输入变量 */ static <T> Function<T, T> identity() { return t -> t; } }
是java.util.function.Function 接口中的方法 R apply(T t); 对给定的变量 t 进行计算,得到返回的结果 R
apply 方法演示示例: 案例需求将 Integer 类型转换为 String 类型,并且输出转换以后字符串的长度。1) 创建一个 Function 对象,输入类型是整数,输出类型是字符串2) Lambda 表达式将一个整数 i 转成字符串3) 调用 apply(数字)方法得到转换后的字符串,再调用字符串的 length()方法得到长度,打印输出。4) 第 1 次转换 99 这个数字,第 2 次转换 1000 这个数字。
public class DemoFunction { public static void main(String[] args) { //创建一个 Function 对象 Function<Integer,String> converter = i -> Integer.toString(i); System.out.println("99 转成字符串的长度是:" + converter.apply(99).length()); System.out.println("1000 转成字符串的长度是:" + converter.apply(1000).length()); } }
Function 接口中有一个默认的 andThen 方法,用来进行组合操作。 先计算当前函数,再计算传入的函数。两个函数依次执行。 andThen 方法的参数是 Function 对象,返回一个 Function 对象。
JDK 源代码如:
/** 默认组合方法,先计算当前函数,再计算传入的函数 */ default <V> Function<T, V> andThen(Function super R, ? extends V> after) { Objects.requireNonNull(after); return (T t) -> after.apply(apply(t)); }
andThen 方法演示示例: 案例需求:连续进行两个操作:第 1 个操作是将字符串转换成为 int 数字,第 2 个操作将转换好的数字乘以 10。两个操作按照前后顺序组合到一起。1) 让用户从键盘输入 1 个数字,使用字符串接收。2) 创建第 1 个 Function 函数将字符串转成整数3) 创建第 2 个函数将整数乘以 10 返回4) 调用 andThen 方法和 apply,并且输出结果
public class DemoFunctionAndThen { public static void main(String[] args) { //用户输入一个字符串 System.out.println("请输入数字:"); Scanner input = new Scanner(System.in); String str = input.nextLine(); //第 1 个函数将字符串转成整数 Function<String,Integer> f1 = s -> Integer.parseInt(s); //第 2 个函数将整数乘以 10 返回 Function<Integer,Integer> f2 = i -> i * 10; //调用 andThen 方法,并且输出结果 System.out.println("转成整数并乘以 10 以后的结果是:" + f1.andThen(f2).apply(str)); } }
Function 中有一个与 andThen 非常类似的 compose 方法。 中文是"组成"的意思,方法参数是 Function,返回值是 Function, 先运行参数的 apply 方法,再调用自己的 apply 方法。
其 JDK 源代码为:
/** 默认组合方法,先计算传入的函数,再计算当前函数 */ default <V> Function<V, R> compose(Function super V, ? extends T> before) { Objects.requireNonNull(before); return (V v) -> apply(before.apply(v)); } 结合 andThen 方法的 JDK 源码实现进行对比,会发现 compose 方法的参数 Lamda 将会先执行。 所以二者只是先后顺序的不同而已。
案例需求:创建两个函数对象:1 个将字符串转成大写,1 个将字符串转成小写。分别使用 andThen 和 compose 方法组合调用,查看不同的计算结果。 开发步骤:1) 创建第 1 个 Function,输入输出都是 String 类型,将字符串转成大写。2) 创建第 2 个 Function,输入输出都是 String 类型,将字符串转成小写。3) 调用第 1 个函数的 apply 方法,并且输出值4) 调用第 2 个函数的 apply 方法,并且输出值5) 调用 andThen 方法和 apply 方法查看运行结果6) 调用 compose 方法和 apply 方法查看运行结果
public class DemoFunctionCompose { public static void main(String[] args) { Function<String,String> f1=s -> s.toUpperCase(); Function<String,String> f2 = s -> s.toLowerCase(); System.out.println("转成大写:" + f1.apply("Hello")); System.out.println("转成小写:" + f2.apply("Hello")); System.out.println("先转成大写,再转成小写:" + f1.andThen(f2).apply("Hello")); System.out.println("先转成小写,再转成大写:" + f1.compose(f2).apply("Hello")); } }
Function 的应用示例 需求说明请使用 Function 进行函数拼接,按照顺序执行多个函数。操作依次为:1) 将字符串"赵丽颖,20"截取数字年龄部分,得到字符串;2) 将上一步的字符串转换成为 int 类型的数字;3) 将上一步的 int 数字累加 100,得到结果 int 数字。 开发步骤:1) 创建第 1 个 Function 对象,将字符串 20 取出,返回一个字符串2) 创建第 2 个 Function 对象,将字符串转成整数,返回整数3) 创建第 3 个 Function 对象,将整数加 100,返回计算结果4) 调用 andThen 方法 2 次,apply 方法应用字符串:"赵丽颖,20",输出结果 代码实现
public class DemoFunctionApp { public static void main(String[] args) { //创建第 1 个 Function 对象,将字符串 20 取出,返回一个字符串 Function<String,String> fun1 = s -> s.split(",")[1]; //创建第 2 个 Function 对象,将字符串转成整数,返回整数 Function<String,Integer> fun2 = s -> Integer.parseInt(s); //创建第 3 个 Function 对象,将整数加 100,返回计算结果 Function<Integer,Integer> fun3 = num -> num + 100; //调用 andThen 方法 2 次,apply 方法应用字符串,输出结果 System.out.println("计算结果:" + fun1.andThen(fun2).andThen(fun3).apply("赵丽颖,20")); } }
BinaryOperator 表示对两个相同类型的操作数进行操作,产生相同类型的结果。
接口中的方法
static <T> BinaryOperator<T> maxBy(Comparator super T> comparator)
返回一个BinaryOperator ,它根据指定的Comparator返回两个元素中的较大Comparator 。
static <T> BinaryOperator<T> minBy(Comparator super T> comparator)
返回BinaryOperator返回根据指定的两个元件的较小的Comparator 。
这个接口中定义了两个静态方法,
BiFunction 是用于定义两个操作符的函数接口。
T apply(T t, T u); 从父接口 BiFunction 中继承下来的抽象方法, 传入两个参数 t 和 u 进行函数计算,返回计算的结果。 两个参数和返回值都是同一种类型。 default <V> BiFunction<T,U,V> andThen(Function super R,? extends V> after) 返回一个组合函数,首先将该函数应用于其输入,然后将after函数应用于结果。 如果任一函数的评估引发异常,则将其转发给组合函数的调用者。 参数类型 V - after函数的输出类型,以及组合函数 参数 after - 应用此函数后应用的功能 结果 一个组合函数首先应用此函数,然后应用 after函数
案例需求:使用 BinaryOperator 接口的 apply()方法,计算 2 个整数的和,并且输出结果。 案例步骤:1) 创建类 Demo25BinaryOperator2) 创建 BinaryOperator 接口,使用 Lambda 实现方法,方法有两个参数,返回方法的计算结果。3) 调用 apply()方法传入实际的参数,打印计算结果。 案例代码:
public class DemoBinaryOperator { public static void main(String[] args) { BinaryOperator<Integer> operator = (m, n) -> m + n; System.out.println("计算结果是:" + operator.apply(3, 5)); } }
public static BinaryOperator minBy(Comparator comparator) 通过后面的 Comparator 比较器判断,返回两个元素中较小的元素 public static BinaryOperator maxBy(Comparator comparator) 通过后面的 Comparator 比较器判断,返回两个元素中较大的元素 Comparator 接口中的静态方法说明 naturalOrder() 按元素的自然排序的大小进行比较,返回一个 Comparator 对象 reverseOrder() 按元素的倒序大小进行比较,返回一个 Comparator 对象
案例需求有如下数组{2,1,3,5},对数组中的每个元素进行替换。替换算法如下:1) 第 0 个元素不变2) 第 0 个+第 1 个元素的结果代替第 1 个元素3) 第 1 个新元素+第 2 个元素的结果代替 2 个4) 第 2 个新元素+第 3 个元素的结果代替第 3 个5) 依次类推,直到所有的元素替换完成为止。
案例步骤
Arrays 类中的方法 说明 void parallelPrefix(T[] array, BinaryOperator op) 并行累积 作用:对数组中每个元素使用指定的二元操作函数进行替换操作 参数 1:要替换的数组 参数 2:指定二元操作函数
1) 创建 BinaryOperator对象,指定 2 个数的算法是 m+n2) 创建 Integer 类型的数组:{2,1,3,5}3) 输出操作前的数组4) 调用上面的 parallelPrefix()方法,将 BinaryOperator 做为参数传入5) 输出操作后的数组6) 如果使用不同的算法,则每个元素的替换的结果不同。如:换成两个数相乘。 案例代码
public static void main(String[] args) { BinaryOperator<Integer> operator = (m,n) -> m+n; Integer [] arr = {2,1,3,5}; System.out.println("操作前的数组:" + Arrays.toString(arr)) ; Arrays.parallelPrefix(arr,operator); System.out.println("操作后的数组:" + Arrays.toString(arr)) ; }
静态方法的演示 案例需求比较两个整数,使用 minBy 静态方法找出最小值比较两个字符串,使用 maxBy 静态方法找出最大值 案例步骤1) 创建 BinaryOperator对象,使用 minBy()静态方法,按数字的正常大小进行比较。2) 输出最小值,调用 apply()方法,传入 2 个整数。3) 创建 BinaryOperator对象,使用 maxBy()静态方法,按字符串的大小进行比较。4) 输出最大值,调用 apply()方法,传入 2 个字符串:"ABCD","xyz" 案例代码
public static void main(String[] args) { //naturalOrder()是 Comparator 中的静态方法,即按数字的正常大小进行比较 BinaryOperator oper1 = BinaryOperator.minBy(Comparator.naturalOrder()); System.out.println("最小值是:" + oper1.apply(3,5)); //naturalOrder()是 Comparator 中的静态方法,即按字符串的正常大小进行比较 BinaryOperator oper2 = BinaryOperator.maxBy(Comparator.naturalOrder()); System.out.println("最大值是:" + oper2.apply("ABCD","xyz")); }
UnaryOperator 表示对单个操作数的操作,该操作数生成与其操作数类型相同的结果。 UnaryOperator 接口继承于 Function 接口, 所以有 T apply(T t)抽象方法,与前面的 Function 接口中的 apply()方法相同。 它的输入类型和返回类型是相同的类型。
UnaryOperator 接口的源码
package java.util.function; public interface UnaryOperator extends Function { /** 始终返回其输入参数的一元运算符 */ static UnaryOperator identity() { return t -> t; } }
方法的演示
UnaryOperator 接口中的方法 说明 T apply(T t); 从 Function 接口中继承下来的抽象方法,使用给定的参数应用此一元运算函数,返回另一个值。 参数和返回值是同一种类型。 static UnaryOperator identity() 始终返回其输入参数的一元运算符也就是后续 apply()输入的是什么,就返回什么。
案例步骤1) 使用 UnaryOperator.identity()静态方法创建 UnaryOperator对象2) 应用 apply()方法,输入字符串 abc,得到结果也是 abc。 案例代码
public static void main(String[] args) { //创建一个 UnaryOperator对象, UnaryOperator operator = UnaryOperator.identity(); //调用 apply()方法,输出参数的值 System.out.println("输出与输出一样:" + operator.apply("abc")); }
案例需求:有一个整数的列表集合,将集合中每个元素乘以 2,再替换这个元素,输出替换前后的列表集合有一个字符串的列表集合,将集合中每个元素用它的大写进行替换。 案例步骤:
ArrayList 中的方法 说明 replaceAll(UnaryOperator operator) 使用一元操作函数的结果,替换列表中的每个元素
1) 使用 Arrays.asList()创建一个整数列表2) 创建 UnaryOperator一元运算函数,指定运算表达式是 x*23) 调用 ArrayList 的 replaceAll()方法,把上面创建的一元运算函数做为参数传入4) 输出替换前后的列表5) 使用 Arrays.asList()创建一个字符串列表6) 这次直接在 replaceAll()方法中传入 Lambda 表达式,s.toUpperCase()7) 输出替换前后的列表 案例代码:
public static void main(String[] args) { List nums = Arrays.asList(3, 10, 8, 2); System.out.println("替换前:" + nums); UnaryOperator oper = x -> x * 2; nums.replaceAll(oper); System.out.println("替换后:" + nums); List names = Arrays.asList("Jack","Rose","Tom","NewBoy"); System.out.println("替换前:" + names); names.replaceAll(s -> s.toUpperCase()); System.out.println("替换后:" + names); }
常用的函数式接口小结
Supplier 提供数据者 T get();没有传入参数,有结果。 Consumer 消费数据者 void accept(T t); 传入数据,没有结果。 andThen() Predicate 谓语 boolean test(T t); 对传入的数据逻辑判断 and() or() negate() isEqual() Function 函数 R apply(T t); 传入一个变量返回计算结果 andThen() compose() identity() BinaryOperator 二元操作符 T apply(T t,T u); 传入两个参数返回一个结果 andThen() 继承于 BiFunction UnaryOperator 继承于 Function 一元操作符 T apply(T t); 传入一个参数返回一个结果 andThen() compose() identity()