函数式接口
函数式接口的使用
package com.itheima.demo01.FunctionalInterface;
@FunctionalInterface
public interface MyFunctionalInterface {
public abstract void method();
}
package com.itheima.demo01.FunctionalInterface;
public class MyFunctionalInterfaceImpl implements MyFunctionalInterface{
@Override
public void method() {
}
}
package com.itheima.demo01.FunctionalInterface;
public class Demo {
public static void show(MyFunctionalInterface myInter){
myInter.method();
}
public static void main(String[] args) {
show(new MyFunctionalInterfaceImpl());
show(new MyFunctionalInterface() {
@Override
public void method() {
System.out.println("使用匿名内部类实现接口中的抽象方法");
}
});
show(()->{
System.out.println("使用Lambda表达式重写接口中的抽象方法");
});
show(()-> System.out.println("使用简化版的Lambda表达式重写接口中的抽象方法"));
}
}
运行结果
使用匿名内部类实现接口中的抽象方法
使用Lambda表达式重写接口中的抽象方法
使用简化版的Lambda表达式重写接口中的抽象方法
函数式编程
Lambda的延迟执行
普通日志
package com.itheima.demo02.Lambda;
public class Demo01Logger {
public static void showLog(int level, String message) {
if (level == 1) {
System.out.println(message);
}
}
public static void main(String[] args) {
String msg1 = "Hello";
String msg2 = "World";
String msg3 = "Java";
showLog(2, msg1 + msg2 + msg3);
}
}
使用Lambda表达式进行优化
package com.itheima.demo02.Lambda;
@FunctionalInterface
public interface MessageBuilder {
public abstract String builderMessage();
}
package com.itheima.demo02.Lambda;
public class Demo02Lambda {
public static void showLog(int level, MessageBuilder mb) {
if (level == 1) {
System.out.println(mb.builderMessage());
}
}
public static void main(String[] args) {
String msg1 = "Hello";
String msg2 = "World";
String msg3 = "Java";
showLog(1, () -> {
return msg1 + msg2 + msg3;
});
}
}
运行结果
HelloWorldJava
相当于将() -> { return msg1 + msg2 + msg3; }作为参数传入public static void showLog(int level, MessageBuilder mb)，如果满足level == 1，则会执行传入的这段程序（拼接字符串）。如果不满足，则不会执行这段传入的程序。
函数式接口作为方法的参数
package com.itheima.demo03.LambdaTest;
public class Demo01Runnable {
public static void startThread(Runnable run) {
new Thread(run).start();
}
public static void main(String[] args) {
startThread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "-->" + "线程启动了");
}
});
startThread(() -> {
System.out.println(Thread.currentThread().getName() + "-->" + "线程启动了");
});
startThread(() -> System.out.println(Thread.currentThread().getName() + "-->" + "线程启动了"));
}
}
运行结果
Thread-0–>线程启动了
Thread-1–>线程启动了
Thread-2–>线程启动了
函数式接口作为方法的返回值
返回匿名内部类实现的接口
package com.itheima.demo03.LambdaTest;
import java.util.Arrays;
import java.util.Comparator;
public class Demo02Comparator {
public static Comparator<String> getComparator() {
return new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.length() - o1.length();
}
};
}
public static void main(String[] args) {
String[] arr = {
"aaa", "b", "cccccc", "dddddddddddd"};
System.out.println(Arrays.toString(arr));
Arrays.sort(arr, getComparator());
System.out.println(Arrays.toString(arr));
}
}
运行结果
[aaa, b, cccccc, dddddddddddd]
[dddddddddddd, cccccc, aaa, b]
返回的是Lambda表达式优化的接口
package com.itheima.demo03.LambdaTest;
import java.util.Arrays;
import java.util.Comparator;
public class Demo03Comparator {
public static Comparator<String> getComparator() {
return (String o1, String o2) -> {
return o2.length() - o1.length();
};
}
public static void main(String[] args) {
String[] arr = {
"aaa", "b", "cccccc", "dddddddddddd"};
System.out.println(Arrays.toString(arr));
Arrays.sort(arr, getComparator());
System.out.println(Arrays.toString(arr));
}
}
[aaa, b, cccccc, dddddddddddd]
[dddddddddddd, cccccc, aaa, b]
常用函数式接口
java.util.function.Supplier:生产数据
抽象方法get
package com.itheima.demo04.Supplier;
import java.util.function.Supplier;
public class Demo01Supplier {
public static String getString(Supplier<String> sup) {
return sup.get();
}
public static void main(String[] args) {
System.out.println(getString(() -> "胡歌"));
}
}
运行结果
胡歌
求数组元素的最大值
package com.itheima.demo04.Supplier;
import java.util.function.Supplier;
public class Demo02Supplier {
public static int getMax(Supplier<Integer> sup){
return sup.get();
}
public static void main(String[] args) {
int[] arr={
2,3,52,233,23};
int maxValue=getMax(()->{
int max=arr[0];
for(int i:arr){
if(i>max) max=i;
}
return max;
});
System.out.println(maxValue);
}
}
运行结果
233
java.util.function.Consumer：消费数据
抽象方法accept
消费数据示例——打印
package com.itheima.demo05.Consumer;
import java.util.function.Consumer;
public class Demo01Consumer {
public static void method(String name, Consumer<String> con) {
con.accept(name);
}
public static void main(String[] args) {
method("赵丽颖", (String name) -> {
String reName = new StringBuffer(name).reverse().toString();
System.out.println(reName);
});
}
}
运行结果
颖丽赵
默认方法AndThen
AndThen源码
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> {
accept(t); after.accept(t); };
}
package com.itheima.demo05.Consumer;
import java.util.function.Consumer;
public class Demo02AndThen {
public static void method(String s, Consumer<String> con1, Consumer<String> con2) {
con1.andThen(con2).accept(s);
}
public static void main(String[] args) {
method("Hello",
(t) -> System.out.println(t.toUpperCase()),
(t) -> System.out.println(t.toLowerCase())
);
}
}
运行结果
HELLO
hello
练习：格式化打印
package com.itheima.demo05.Consumer;
import java.util.function.Consumer;
public class Demo03Test {
public static void printInfo(String[] arr, Consumer<String> con1, Consumer<String> con2) {
for (String message : arr) {
con1.andThen(con2).accept(message);
System.out.println();
}
}
public static void main(String[] args) {
String[] arr = {
"迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男"};
printInfo(arr,
(message) -> System.out.print(message.split(",")[0] + " "),
(message) -> System.out.print(message.split(",")[1])
);
}
}
java.util.function.Predicate：对数据的类型进行判断
抽象方法test
package com.itheima.demo06.Predicate;
import java.util.function.Predicate;
public class Demo01Predicate {
public static boolean checkString(String s, Predicate<String> pre) {
return pre.test(s);
}
public static void main(String[] args) {
String s = "abcdef";
System.out.println(checkString(s, (str) -> str.length() > 5));
}
}
运行结果
true
默认方法and
需求:判断一个字符串,有两个判断的条件
1.判断字符串的长度是否大于5
2.判断字符串中是否包含a
package com.itheima.demo06.Predicate;
import java.util.function.Predicate;
public class Demo02Predicate_and {
public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
return pre1.and(pre2).test(s);
}
public static void main(String[] args) {
String s = "abcdef";
boolean b = checkString(s,
(str) -> str.contains("a"),
(str) -> str.length() > 5
);
System.out.println(b);
}
}
运行结果
true
默认方法or
需求:判断一个字符串,有两个判断的条件
1.判断字符串的长度是否大于5
2.判断字符串中是否包含a
package com.itheima.demo06.Predicate;
import java.util.function.Predicate;
public class Demo03Predicate_or {
public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
return pre1.or(pre2).test(s);
}
public static void main(String[] args) {
String s = "abc";
boolean b = checkString(s,
(str) -> str.length() > 5,
(str) -> str.contains("a")
);
System.out.println(b);
}
}
运行结果
true
默认方法negate
需求:判断一个字符串长度是否大于5
如果字符串的长度大于5,那返回false
如果字符串的长度不大于5,那么返回true
package com.itheima.demo06.Predicate;
import java.util.function.Predicate;
public class Demo04Predicate_negate {
public static boolean checkString(String s, Predicate<String> pre) {
return pre.negate().test(s);
}
public static void main(String[] args) {
String s = "abc";
boolean b = checkString(s, (String str) -> str.length() > 5);
System.out.println(b);
}
}
运行结果
true
练习：集合信息筛选
练习：集合信息筛选
数组当中有多条“姓名+性别”的信息如下，
String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，
需要同时满足两个条件：
1. 必须为女生；
2. 姓名为4个字。
package com.itheima.demo06.Predicate;
import java.util.ArrayList;
import java.util.function.Predicate;
public class Demo05Test {
public static ArrayList<String> filter(String[] arr, Predicate<String> pre1, Predicate<String> pre2) {
ArrayList<String> list = new ArrayList<>();
for (String s : arr) {
boolean b = pre1.and(pre2).test(s);
if (b) {
list.add(s);
}
}
return list;
}
public static void main(String[] args) {
String[] array = {
"迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女"};
ArrayList<String> list = filter(array,
(String s) -> s.split(",")[1].equals("女"),
(String s) -> s.split(",")[0].length() == 4
);
for (String s : list) {
System.out.println(s);
}
}
}
运行结果
迪丽热巴,女
古力娜扎,女
java.util.function.Function<T,R>:用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。
抽象方法apply
package com.itheima.demo07.Function;
import java.util.function.Function;
public class Demo01Function {
public static void change(String s, Function<String, Integer> fun) {
int in = fun.apply(s);
System.out.println(in);
}
public static void main(String[] args) {
String s = "1234";
change(s, str -> Integer.parseInt(str));
}
}
运行结果
1234
默认方法andThen
需求:
把String类型的"123",转换为Inteter类型,把转换后的结果加10
把增加之后的Integer类型的数据,转换为String类型
package com.itheima.demo07.Function;
import java.util.function.Function;
public class Demo02Function_andThen {
public static void change(String s, Function<String, Integer> fun1, Function<Integer, String> fun2) {
String ss = fun1.andThen(fun2).apply(s);
System.out.println(ss);
}
public static void main(String[] args) {
String s = "123";
change(s, str -> Integer.parseInt(str) + 10, i -> i + "");
}
}
练习：自定义函数模型拼接
题目
请使用Function进行函数模型的拼接，按照顺序需要执行的多个函数操作为：
String str = "赵丽颖,20";
1. 将字符串截取数字年龄部分，得到字符串；
Function<String,String> "赵丽颖,20"->"20"
2. 将上一步的字符串转换成为int类型的数字；
Function<String,Integer> "20"->20
3. 将上一步的int数字累加100，得到结果int数字。
Function<Integer,Integer> 20->120
package com.itheima.demo07.Function;
import java.util.function.Function;
public class Demo03Test {
public static int change(String s, Function<String, String> fun1,
Function<String, Integer> fun2, Function<Integer, Integer> fun3) {
return fun1.andThen(fun2).andThen(fun3).apply(s);
}
public static void main(String[] args) {
String str = "赵丽颖,20";
int num = change(str, s -> s.split(",")[1], s -> Integer.parseInt(s), i -> i + 100);
System.out.println(num);
}
}
运行结果
120