1.函数式接口
1.1 函数式接口概述
函数式接口:有且仅有一个抽象方法的接口
Java中函数式编程体现的就是Lambda表达式,所以函数式接口就是可以适用于Lambda使用的接口
只有确保接口中有且仅有一个抽象方法,Java中的Lambda才能顺利地进行推导
如何检测一个接口是不是函数式接口呢?
@FunctionalInterface
放在接口定义的上方:如果接口是函数式接口,编译通过;如果不是,编译失败
注意:
我们自己定义函数式接口的时候,@FunctionalInterface是可选的,就算不写这个注解,只要保证满足函数式接口定义的条件,也照样是函数式接口。
但是,建议加上该注解
1.2 函数式接口作为方法的参数
需求
定义一个类(RunnableDemo),在类中提供两个方法
一个方法是:startThread(Runnable r) 方法参数Runnable是一个函数式接口
一个方法是主方法,在主方法中调用startThread方法
如果方法的参数是一个函数式接口,我们可以使用Lambda表达式作为参数传递
startThread(() -> System.out.println(Thread.currentThread().getName() + “线程启动”));
public class RunnableDemo {
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() + "线程启动"));
}
public static void startThread(Runnable r){
Thread t = new Thread(r);
t.start();
}
}
1.3 函数式接口作为方法的返回值
需求
定义一个类(ComparatorDemo),在类中提供两个方法
一个方法是:Comparator< String > getComparator() 方法返回值Comparartor是一个函数式接口
一个方法是主方法,在主方法中调用getComparator方法
在此处仍有疑问,为什么Comparator接口里有两个抽象方法:int compara、boolean equals,但仍然是一个FunctionalInterface
public class ComparatorDemo {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<String>();
array.add("aaaa");
array.add("bbb");
array.add("cc");
array.add("d");
Collections.sort(array,getComparator());
System.out.println(array);
}
public static Comparator<String> getComparator(){
/*
Comparator<String> comp = new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return s1.length()-s2.length();
}
};
return comp;
*/
return (s1,s2) -> s1.length()-s2.length();
}
}
1.4 常用的函数式接口
Java 8 在java.util.function包下预定义了大量的函数式接口供我们使用
我们来重点学习下面的4个接口
① Supplier接口
② Consumer接口
③ Predicate接口
④ Function接口
1.5 Supplier接口
Supplier< T >:包含一个无参的方法
T get():获得结果
该方法不需要参数,他会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
Supplier< T >接口也被称为生产型接口,如果我们指定了接口的泛型是什么类型,那么接口中的get方法就会产生什么类型的数据供我们使用
public class SupplierDemo {
public static void main(String[] args) {
String s = getString(() -> "Rarity");
System.out.println(s);
int i = getInt(() -> 3);
System.out.println(i);
}
//定义一个方法,返回一个字符串数据
public static String getString(Supplier<String> s){
return s.get();
}
//定义一个方法,返回一个整数数据
public static int getInt(Supplier<Integer> i){
return i.get();
}
}
练习
定义一个类(SupplierTest),在类中提供两个方法
一个方法是:int getMax(Supplier< Integer> sup) 用于返回一个int数组中的最大值
一个方法是主方法,在主方法中调用getMax方法
public class SupplierTest {
public static void main(String[] args) {
int[] arr = {19, 58, 28, 27, 36};
int maxValue = getMax(() -> {
int max = arr[0];
for (int i : arr) {
max = Math.max(max, i);
}
return max;
});
System.out.println(maxValue);
}
public static int getMax(Supplier<Integer> sup) {
return sup.get();
}
}
1.6 Consumer接口
Consumer< T>:包含两个方法
① void accept(T t):对给定的参数执行此操作
② default Consumer< T> andThen(Consumer after):返回一个组合的Consumer,依次执行此操作,然后执行after操作
Consumer< T> 接口也被称为消费型接口,它消费的数据的数据类型由泛型指定
public class ConsumerDemo {
public static void main(String[] args) {
operatorString("Rarity",(String s)->{
System.out.println(s);
});
operatorString("rarity",s -> System.out.println(s));
operatorString("Twilight",System.out::println);
operatorString("Twilight", s->{
System.out.println(new StringBuilder(s).append(" Sparkle").toString());
});
operatorString("Starlight",s -> {
StringBuilder sb = new StringBuilder(s).append(" Glimmer");
System.out.println(sb);
},s -> {
System.out.println(new StringBuilder(s).append(" is a Pony"));
});
}
//定义一个方法,消费一个字符串数据
private static void operatorString(String name, Consumer<String> con){
con.accept(name);
}
//定义一个方法,用不同的方式消费同一个字符串数据两次
private static void operatorString(String name,Consumer<String> con1,Consumer<String> con2){
/* con1.accept(name);
con2.accept(name);*/
//改进
con1.andThen(con2).accept(name);
}
}
练习
String[] strArray = {“Rarity,15”,“Twilight,14”,“FlutterShy,16”};
字符串数组中有多条信息,请按照格式:"姓名:XX,年龄:XX"的格式将信息打印出来
要求:
把打印姓名的动作作为第一个Consumer接口的Lambda实例
把打印年龄的动作作为第二个Consumer接口的Lambda实例
将两个Consumer接口按照顺序组合到一起使用
public class ConsumerTest {
public static void main(String[] args) {
String[] strArray = {"Rarity,15", "Twilight,14", "FlutterShy,16"};
printInfo(strArray, (String s) -> {
String[] info = s.split(",");
String name = info[0];
System.out.print("姓名:" + name);
}, (String s) -> {
String[] info = s.split(",");
int age = Integer.parseInt(info[1]);
System.out.println("年龄:" + age);
});
}
private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2) {
for (String str : strArray) {
con1.andThen(con2).accept(str);
}
}
}
1.7 Predicate接口
Predicate< T>:常用的四个方法
① boolean test(T t):对给定的参数进行判断(判断逻辑由Lambda表达式实现),返回一个布尔值
② default Predicate< T> negate():返回一个逻辑的否定,对应逻辑非
③ default Predicate< T> and(Predicate other):返回一个组合判断,对应短路与
④ default Predicate< T> or(Predicate other):返回一个组合判断,对应短路或
Predicate< T>接口通常用于判断参数是否满足指定的条件
public class PredicateDemo1 {
public static void main(String[] args) {
boolean b1 = checkString("Rarity", (String s) -> {
return s.length() > 8;
});
System.out.println(b1);
boolean b2 = checkString("Rarity",s -> s.length()>8);
System.out.println(b2);
}
private static boolean checkString(String s, Predicate<String> pre) {
// return pre.test(s);
// return !pre.test(s);
return pre.negate().test(s);
}
}
public class PredicateDemo2 {
public static void main(String[] args) {
boolean b1 = checkString("Rarity", s -> s.length() > 8);
System.out.println(b1);
boolean b2 = checkString("TwilightSparkle", s -> s.length() > 6, s -> s.length() < 16);
System.out.println(b2);
}
private static boolean checkString(String s, Predicate<String> pre) {
return pre.test(s);
}
//同一个字符串给出两个不同的判断条件,最后把着两个判断的结果做逻辑与运算的结果作为最终的结果
private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
return pre1.and(pre2).test(s);
}
}
练习
String[] strArray = {“Rarity,15”,“TwilightSparkle,14”,“FlutterShy,16”,“RainbowDash,14”,“AppleJack,16”,“PinkiePie,15”};
字符串数组中有多条信息,请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中,并遍历ArrayList集合
同时满足如下要求:姓名长度大于2;年龄大于14
分析
有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断
必须同时满足两个条件,所以可以使用and方法连接两个判断条件
public class Practice {
public static void main(String[] args) {
String[] strArray = {"Rarity,15","TwilightSparkle,14","FlutterShy,16","RainbowDash,14","AppleJack,16","PinkiePie,15"};
ArrayList<String> arrayList = checkString(strArray, (s) -> {
String name = s.split(",")[0];
return name.length() > 7;
}, (s -> {
int age = Integer.parseInt(s.split(",")[1]);
return age > 14;
}));
System.out.println(arrayList);
}
//通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中
private static ArrayList<String> checkString(String[] strArray, Predicate<String> pre1, Predicate<String> pre2){
ArrayList<String> array = new ArrayList<>();
for(String s : strArray){
if(pre1.and(pre2).test(s)){
array.add(s);
}
}
return array;
}
}
1.8 Function接口
Function<T,R>:常用的两个方法
① R appy(T t):将此函数应用于给定的参数
② default < V> Function andThen(Function after):返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果
Function<T,R>接口通常用于对参数进行处理,转换(处理逻辑由Lambda表达式实现),然后返回一个新的值
public class FunctionDemo {
public static void main(String[] args) {
StringToInt("123456", s -> Integer.parseInt(s));
StringToInt("654321", Integer::parseInt);
System.out.println("--------");
IntToString(456789, i -> String.valueOf(i + 1));
System.out.println("--------");
convert("750", s -> Integer.parseInt(s),i -> String.valueOf(i + 250));
}
//定义一个方法,把一个字符串转换int类型,在控制台输出
private static void StringToInt(String s, Function<String, Integer> fun) {
int i = fun.apply(s);
System.out.println(i);
}
//定义一个方法,把一个int类型的数据加上一个整数后,转为字符串在控制台输出
private static void IntToString(int i, Function<Integer, String> fun) {
String s = fun.apply(i);
System.out.println(s);
}
//定义一个方法,把一个字符串转换int类型,把int类型的数据加上一个整数之后,转为字符串在控制台输出
private static void convert(String s, Function<String, Integer> fun1, Function<Integer, String> fun2){
/* Integer i = fun1.apply(s) ;
String str = fun2.apply(i);
System.out.println(str);*/
String ss = fun1.andThen(fun2).apply(s);
System.out.println(ss);
}
}
练习
String s = “Rarity,15”;
按照指定的要求进行操作:
1.将字符串截取得到数字年龄部分
2.将上一步的年龄字符串转换为int类型的数据
3.将上一步的i那天数据加70,得到一个int结果,在控制台输出
通过Function接口来实现函数拼接
public class FunctionDemo1 {
public static void main(String[] args) {
convert("Rarity,15",s -> s.split(",")[1],age -> Integer.parseInt(age), i -> i+70);
convert("Rarity,15",s -> s.split(",")[1],Integer::parseInt, i -> i+70);
}
private static void convert(String s, Function<String, String> fun1, Function<String, Integer> fun2, Function<Integer, Integer> fun3) {
/* String age = fun1.apply(s);
Integer i = fun2.apply(age);
Integer result = fun3.apply(i);
System.out.println(result);*/
Integer result = fun1.andThen(fun2).andThen(fun3).apply(s);
System.out.println(result);
}
}