一，函数式接口的定义
/**
* 函数式接口：有且只有一个抽象方法的接口。当然接口可以包含其他的方法（默认，静态，私有）
* @FunctionalInterface注解：
* 作用：可以检测接口是否是一个函数式接口，是：编译成功，否：编译失败（接口中没有抽象方法|抽象方法的个数多余一个）
*/
@FunctionalInterface
public interface MyFunctionInterface {
//定义一个抽象方法
public abstract void method();
}
二，函数式接口的使用
/**
* 函数式接口的使用：一般可以作为方法的参数和返回值类型
*/
public class DemoTestMyFunction {
//定义一个方法，参数使用函数式接口MyFunctionalInterface
public static void show(MyFunctionInterface myInter){
myInter.method();
}
public static void main(String[] args) {
//调用show方法，方法的参数是一个接口，所以可以传递接口的实现类对象
show(new MyFunctionalInterfaceImpl());
//调用show方法，方法的参数是一个接口，所以我们可以传递接口的匿名内部类
show(new MyFunctionalInterfaceImpl(){
@Override
public void method() {
System.out.println("使用匿名内部类重写接口中的抽象方法");
}
});
//调用show方法，方法的参数是一个函数式接口，所以我们可以Lambda表达式
show(()->{
System.out.println("使用Lambda表达式，重写接口中的抽象方法");
});
//简化Lambda表达式
show(()->System.out.println("使用Lambda表达式，重写接口中的抽象方法"));
}
}
三，使用Lambda优化日志
@FunctionalInterface
public interface MessageBuilder {
//定义一个拼接消息的抽象方法，返回被拼接的消息
public abstract String builderMessage();
}
/**
* 使用Lambda优化日志案例
* lambda的特点：延迟加载
* lambda的使用前提，必须存在函数式接口
*/
public class Demo02Lambda {
//定义一个显示日志的方法，方法的参数传递日志的等级和MessageBuilder接口
public static void showLog(int level, MessageBuilder mb){
//对日志的等级进行判断，如果是1级，则调用MessageBuilder接口中的builderMessage方法
if(level == 1){
System.out.println(mb.builderMessage());
}
}
public static void main(String[] args) {
//定义三个日志信息
String msg1 = "hello";
String msg2= "world";
String msg3 = "java";
//调用showLog方法，参数MessageBuilder是一个函数式接口，所以可以传递lambda表达式
showLog(1, ()->{
//返回一个拼接好的字符串
return msg1 + msg2 + msg3;
});
/**
* 使用lambda表达式作为参数传递，仅仅是把参数传递到showLog方法中，
* 只有满足条件日志的等级是一级
* 才会调用接口MessageBuilder中的方法builderMessage
* 才会进行字符串的拼接
*/
}
}
函数式接口作为方法的参数案例
/**
* 例如java.lang.Runnable接口就是一个函数式接口，
* 假设有一个startThread方法使用该接口作为参数，那么就可以使用Lambda进行传参，
* 这种情况其实和Thread类的构造方法参数为Runnable没有本质区别
*/
public class Demo01Runnable {
//定义一个方法startThread，方法的参数使用函数式接口Runnable
public static void startThread(Runnable run){
//开启多线程
new Thread(run).start();
}
public static void main(String[] args) {
//调用startThread方法，方法的参数是一个接口，那么我们可以传递这个接口的匿名内部类
startThread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "--->" + "线程启动了");
}
});
//调用startThread方法，方法的参数是一个函数式接口，所以可以传递lambda表达式
startThread(()->{
System.out.println(Thread.currentThread().getName() + "--->" + "线程启动了");
});
//优化lambda表达式
startThread(()->System.out.println(Thread.currentThread().getName() + "--->" + "线程启动了"));
}
}
函数式接口作为方法的返回值类
/**
* 如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个lambda表达式。
* 当需要通过一个方法来获取一个java.util.Comparator接口类型的对象作为一个排序器时，就可以调用该方法获取。
*/
public class Demo02Comparator {
//定义一个方法，方法的返回值类型使用函数式接口Comparator
public static Comparator<String> getComparator(){
/*//方法的返回值类型是一个接口，那么我们可以返回这个接口的匿名内部类
return new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
//按照字符串的降序排序
return o2.length() - o1.length();
}
};*/
/* //方法的返回值类型是一个函数式接口，所以我们可以返回一个lambda表达式
return (String o1, String o2)->{
return o2.length() - o1.length();
};*/
//继续优化lambda表达式
return (o1, o2)->o2.length() - o1.length();
}
public static void main(String[] args) {
//创建一个字符串数组
String[] arr = {"aaa", "b", "ccc", "dddddddd"};
//输出排序前的数组
System.out.println(Arrays.toString(arr));
//调用Arrays.sort方法
Arrays.sort(arr, getComparator());
//输出排序后的数组
System.out.println(Arrays.toString(arr));
}
}
三，常用的接口Supplier接口
import java.util.function.Supplier;
/**
* 常用的函数式接口
* java.util.function.Supplier<T>接口仅包含一个无参的方法：T get()。用来获取一个泛型参数指定类型的对象数据
* Supplier<T>接口被称之为生产型接口，指定接口的泛型是什么类型，那么接口中的get放啊就会生产什么类型的数据
*/
public class Demo01Supplier {
//定义一个方法，方法的参数传递Supplier<T>接口，泛型指定String，get方法就会返回一个String
public static String getString(Supplier<String> sup){
return sup.get();
}
public static void main(String[] args) {
//调用getString方法，方法的参数Supplier是一个函数式接口，所以可以传递Lambda表达式
String s = getString(()->
//生产一个字符串并返回
"胡歌");
System.out.println(s);
}
}
四，Consumer接口
java.util.function.Consumer<T>接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。
是一个消费型接口，泛型执行什么类型，就可以使用accept方法消费什么类型的数据
public class Demo04Consumer {
//定义一个方法，方法的参数传递一个字符串的姓名，方法的参数传递Consumer接口，泛型使用String，可以使用Consumer接口消费字符串的姓名
public static void method(String name, Consumer<String> con){
con.accept(name);
}
public static void main(String[] args) {
//调用method方法，传递字符串姓名，方法的另一个参数是Consumer接口，是一个函数式接口，所以可以传递lambda表达式
method("赵丽颖",(String name)->{
//对传递的字符串进行消费
//消费方式：直接输出字符串
System.out.println(name);
//消费方式：把字符串进行反转输出
String reName = new StringBuilder(name).reverse().toString();
System.out.println(reName);
});
}
}
默认方法：andThen
作用：需要两个Consumer接口，可以把两个Consumer接口组合在一起，在对数据进行消费
public class Demo05AndThen {
//定义一个方法，方法的参数传递一个字符串和两个Consumer接口，Consumer接口的泛型使用字符串
public static void method(String s, Consumer<String> con1, Consumer<String> con2){
/*con1.accept(s);
con2.accept(s);*/
//使用andThen方法，把两个Consumer接口连接到一起，再消费数据
con1.andThen(con2).accept(s);//con1连接con2,先执行con1消费数据，再执行con2消费数据
}
public static void main(String[] args) {
//调用method方法，传递一个字符串两个lambda表达式
method("Hello",
(t)->{
//消费方式，把字符串转换为大写输出
System.out.println(t.toUpperCase());
},
(t)->{
//消费方式，把字符串转换为小写输出
System.out.println(t.toLowerCase());
});
}
}
import java.util.function.Consumer;
/**
* 练习：字符串数组中存在多条信息，按照格式"姓名：XX。性别：XX。"的格式将信息打印出来
* 要求将打印姓名的动作作为第一个Consumer接口的lambda实例，
* 将打印性别的动作作为第二个Consumer接口的lambda实例，
* 将两个Consumer接口按照顺序"拼接"到一起。
*/
public class Demo06Consumer {
//定义一个方法，参数传递String类型的数组和两个Consumer接口，泛型使用String
public static void peintInfo(String[] arr, Consumer<String> con1, Consumer<String> con2){
//遍历字符串数组
for(String message : arr){
//使用andThen方法连接两个Consumer 接口，消费字符串
con1.andThen(con2).accept(message);
}
}
public static void main(String[] args) {
//定义一个字符串类型的数组
String[] arr = {"迪丽热巴,女","古力娜扎,女","黄晓明,男"};
//调用peintInfo方法，传递一个字符串数组和两个lambda表达式
peintInfo(arr,
(message)->{
//消费方式：对message进行切割，获取姓名，按照指定格式输出
String name = message.split(",")[0];
System.out.print("姓名：" + name);
},
(message)->{
//消费方式：对message进行切割，获取年龄，按照指定格式输出
String age = message.split(",")[1];
System.out.println("。年龄：" + age + "。");
});
}
}
五，Predicate接口
java.util.function.Predicate<T>接口
作用：对某种数据类型的数据进行判断，结果返回一个boolean值
接口中含有一个抽象方法：boolean test(T t)：用来对指定数据类型数据进行判断的方法
import java.util.function.Predicate;
public class Demo07Predicate {
/**
* 定义一个方法
* 参数传递一个String类型的字符串
* 传递一个Predicate接口，泛型使用String
* 使用Predicate中的方法test对字符串进行判断，并把判断的结果返回
*/
public static boolean checkString(String s, Predicate<String> pre){
return pre.test(s);
}
public static void main(String[] args) {
//定义一个字符串
String s = "abcde";
//调用checkString方法对字符串进行校验，参数传递字符串和lambda表达式
boolean b = checkString(s, (String str)->{
//对参数传递的字符串进行判断，判断字符串的长度是否大于5，并把结果返回
return str.length()>5;
});
System.out.println(b);
}
}
import java.util.function.Predicate;
/**
* 逻辑表达式：可以连接多个判断的条件
* &&：与运算符，有false则true
* ||：或运算符，有true则true
* ！：取反运算符，非真则假，非假则真
* 需求：判断一个字符串，有两个判断条件
* 1，判断字符串的长度是否大于5
* 2，判断字符串中是否包含a
* 两个条件必须同时满足，我们就可以使用&&运算符连接两个条件
*/
public class Demo08Predicate_and {
public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2){
// return pre1.test(s) && pre2.test(s);
return pre1.and(pre2).test(s);//等价于
}
public static void main(String[] args) {
//定义一个字符串
String s= "abcdef";
//调用checkString方法，参数传递字符串和两个lambda表达式
boolean b = checkString(s,
(String str)->{
return str.contains("a");
},
(String str)->{
return str.length()>5;
});
System.out.println(b);
}
}
import java.util.function.Predicate;
/**
* /**
* * 逻辑表达式：可以连接多个判断的条件
* * &&：与运算符，有false则true
* * ||：或运算符，有true则true
* * ！：取反运算符，非真则假，非假则真
* * 需求：判断一个字符串，有两个判断条件
* * 1，判断字符串的长度是否大于5
* * 2，判断字符串中是否包含a
* * 满足一个条件即可，我们就可以使用||运算符连接两个条件
* */
public class Demo08Predicate_or {
public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2){
return pre1.test(s) || pre2.test(s);
}
public static void main(String[] args) {
//定义一个字符串
String s= "bbcdef";
//调用checkString方法，参数传递字符串和两个lambda表达式
boolean b = checkString(s,
(String str)->{
return str.contains("a");
},
(String str)->{
return str.length()>5;
});
System.out.println(b);
}
}
import java.util.function.Predicate;
/**
* 需求：判断一个字符串长度是否大于5，如果字符串长度大于5，返回false，如果字符串长度不大于5，那么返回true
* 所以，我们可以使用取反符号！对判断的结果进行取反
*/
public class Demo08Predicate_negate {
public static boolean checkString(String s, Predicate<String> pre){
//return !pre.test(s);
return pre.negate().test(s);
}
public static void main(String[] args) {
String s = "abcdfgr";
boolean b = checkString(s,(String str)->{
return str.length() > 5;
});
System.out.println(b);
}
}
练习题
import java.util.ArrayList;
import java.util.function.Predicate;
/**
* 需要同时满足两个条件：1，必须为女生 2，姓名为4个字
*/
public class Demo08Predicate_Test {
public static ArrayList<String> filter(String[] arr, Predicate<String> pre1, Predicate<String> pre2){
//定义一个ArrayList集合，存储过滤后的信息
ArrayList<String> list = new ArrayList<>();
//遍历数组，获取数组中的每一条信息
for(String s : arr){
boolean b = pre1.and(pre2).test(s);
//对得到的boolean值进行判断
if(b){
list.add(s);
}
}
return list;
}
public static void main(String[] args) {
//定义一个存储字符串的数组
String[] arr = {"迪丽热巴,女", "古力娜扎,女","玛尔扎哈,男","赵丽颖,女"};
//调用filter方法，传递字符串数组和两个lambda表达式
ArrayList<String> list = filter(arr, (String s)->{
//获取字符串中的性别，判断是否为女
return s.split(",")[1].equals("女");
}, (String s)->{
//获取字符串中的姓名，判断是否为4个字符
return s.split(",")[0].length() == 4;
});
//遍历集合
for(String s:list){
System.out.println(s);
}
}
}
六，Function接口
java.util.function.Function<T, R>接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。
import java.util.function.Function;
public class Demo09Function {
/*
定义一个方法，方法的参数传递一个字符串类型的整数，方法的参数传递一个Function接口，泛型使用<String, Integer>
使用Function接口中的方法apply，把字符串类型的整数，转换为Integer类型的整数
*/
public static void change(String s, Function<String, Integer> fun ){
Integer in = fun.apply(s);
System.out.println(in);
}
public static void main(String[] args) {
//定义一个字符串类型的整数
String s = "1234";
//调用change方法，传递字符串类型的整数和lambda表达式
change(s, (String str)->{
//把字符串类型的整数，转换为Integer类型的整数,返回
return Integer.parseInt(str);
});
}
}
Function接口中的默认方法andThen:用来进行组合操作
import java.util.function.Function;
/**
* 需求：把String类型的"123"，转换为Integer类型，把转换后的结果加10
* 把增加之后的Integer类型的数据，转换为String类型
* 分析：转换了两次，第一次是把String类型转换为Integer类型，所以可以使用
* Function<String,Integer> fun1 Integer in = fun1.apply("123") + 10;
* 第二次是把Integer类型转换为String类型，所以可以使用
* Function<String,Integer> fun2 String s = fun2.apply(i);
* 可以使用andThen放啊，把两次组合在一起使用
* String s = fun1.andThen(fun2).apply("123");
*
*/
public class Demo09Function_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方法，传递字符串和两个lambda表达式
change(s, (String str)->{
return Integer.parseInt(str) + 10;
}, (Integer i)->{
return i + "";
});
}
}
练习：自定义函数模型拼接
import java.util.function.Function;
public class Demo09Function_Test1 {
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, (String s)->{
return s.split(",")[1];
},
(String s)->{
return Integer.parseInt(s);
},
(Integer i)->{
return i + 100;});
System.out.println(num);
}
}
