常用的函数式接口
1.Comparator
如果一个方法的返回值是一个函数式接口，那么就可以直接返回一个lambda表达式。
当需要通过一个方法来获取一个java.util.Compartor接口类型的对象作为排序器时，就可以调该方法获取
public class Demo03Comparator {
public static Comparator<String > getCompartor()
{
/*return new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length()-o2.length();
}
};*/
//使用函数式接口
/* return (String o1, String o2)-> {
return o1.length()-o2.length();
};*/
//简化lambda表达式，去掉修饰符，{}和return ;
return (o1,o2)->o1.length()-o2.length() ;
}
public static void main(String[] args) {
String arr[]={"a","bb","dddd","ccc"};
//System.out.println(arr.toString());
System.out.println(Arrays.toString(arr));
Arrays.sort(arr,getCompartor());
System.out.println(Arrays.toString(arr));
}
}
2.Suppiler
suppiler生产式接口
Interface Supplier
T -该供应商提供的结果类型
代表结果供应商。
没有要求每次调用供应商时都会返回新的或不同的结果。
这是一个functional interface的功能方法是get()
import java.util.function.Supplier;
public class Demo04Suppiler {//作为参数使用，内部调用get方法
public static String getname(Supplier<String> sup)
{
return sup.get();
}
//使用函数式接口
public static void main(String[] args) {
String str = getname(() -> {
return "迪丽热巴";
});
System.out.println(str);
//简化版
String str2 = getname(() -> "迪丽热巴");
System.out.println(str2);
}
}
用suplier获取最大值方法举例
public class Demo04SupplierMax {
public static int getMax(Supplier<Integer> sup)
{
return sup.get();
}
public static void main(String[] args) {
//创建数组
int[] arr={100,20,45,64,-88,99};
//调用方法，使用lambda表达式：
int max1 = getMax(() -> {
int max = arr[0];
for (int number : arr
) {
if (number > max) {
max = number;
}
}
return max;
});
System.out.println("数组中最大值式："+max1);
}
}
3.Consumer(在idea中可按住ctrl点击鼠标查看具体抽象方法)
import java.util.function.Consumer;
public class Demo05Consumer {
public static void method(String name, Consumer<String> con)
{
con.accept(name);
}
public static void main(String[] args) {
method("迪丽热巴",(String name)->{
System.out.println(name);
});
method("迪丽热巴",(name)->{
String reversename=new StringBuffer(name).reverse().toString();
System.out.println(reversename);
});
}
}
3.2.andThen（配合accept使用）
import java.util.function.Consumer;
public class Demo06andThen {
public static void method(String name, Consumer<String> con1,Consumer<String> con2)
{
/* con1.accept(name);
con2.accept(name);*/
con2.andThen(con1).accept(name);//先消费二再消费一
}
public static void main(String[] args) {
method("abcDefg",
(t)->{
System.out.println(t.toUpperCase());
},
(t)->{
System.out.println(t.toLowerCase());
});
}
}
使用andThen打印一串数组
import java.util.function.Consumer;
public class Demo07Test {
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={"迪丽热巴，19","古力娜扎，19","刘亦菲，16"};
printInfo(arr,
(message)->{
String[] array = message.split("，");
System.out.print("姓名："+array[0]);
},
(message)->{
String[] array = message.split("，");
System.out.print("，年龄："+array[1]);
});
}
}
4.Predicate
import java.util.function.Predicate;
public class Demo08Predicate {
//定义一个方法，参数传递一个string类型，和一个predicate接口，使用Predicate中的方法test对其进行测试
public static boolean checkstr(String str, Predicate<String> pre)
{
return pre.test(str);
}
public static void main(String[] args) {
boolean b = checkstr("abcdefg", (String str) -> {
return str.length() > 5;
});
System.out.println(b);
//简写lambda
System.out.println(checkstr("abcdefg",(message)->message.length()<5));
}
}
4.2Predicate中negate.test(与上面的结果相反)
import java.util.function.Predicate;
public class Demo08Predicate_negative {
//定义一个方法，参数传递一个string类型，和一个predicate接口，使用Predicate中的方法test对其进行测试
public static boolean checkstr(String str, Predicate<String> pre)
{
/*return !pre.test(str);*/
return pre.negate().test(str);//等效
}
public static void main(String[] args) {
boolean b = checkstr("abcdefg", (String str) -> {
return str.length() > 5;
}
);
System.out.println(b);
//简写lambda
System.out.println(checkstr("abcdefg",(message)->message.length()<5));
}
}
4.3 and 和 or用法（相关的结果请读者自行运行得出）
import java.util.function.Predicate;
public class Demo08Predicateand {
//定义一个方法，参数传递一个string类型，和一个predicate接口，使用Predicate中的方法test对其进行测试
public static boolean checkstr(String str, Predicate<String> pre1,Predicate<String> pre2)
{
return pre1.and(pre2).test(str);
}
public static void main(String[] args) {
boolean b = checkstr("abcdefg", (String str) -> {
return str.length() > 5;
},
(String str2)->{return str2.contains("a");}
);
System.out.println(b);
//简写lambda
System.out.println(checkstr("abcdefg",(message)->message.length()<5,(str2)->str2.contains("a")));
}
}
import java.util.function.Predicate;
public class Demo08Predicateor {
//定义一个方法，参数传递一个string类型，和一个predicate接口，使用Predicate中的方法test对其进行测试
public static boolean checkstr(String str, Predicate<String> pre1,Predicate<String> pre2)
{
return pre1.or(pre2).test(str);
}
public static void main(String[] args) {
boolean b = checkstr("abcdefg", (String str) -> {
return str.length() > 5;
},
(String str2)->{return str2.contains("a");}
);
System.out.println(b);
//简写lambda
System.out.println(checkstr("abcdefg",(message)->message.length()<5,(str2)->str2.contains("a")));
}
}
4.4 fliter
筛选一组数列中名字为4，且是女的人，并展示出来
import java.util.ArrayList;
import java.util.function.Predicate;
/*信息筛选，名字是四个字的，且是女的*/
public class Demo08PredicateTestFilter {
public static ArrayList<String> filter(String arr[], Predicate<String> pre1,Predicate<String> pre2)
{
ArrayList<String> arrayList=new ArrayList<>();
for (String s : arr) {
boolean b = pre1.and(pre2).test(s);
if(b)
{
arrayList.add(s);
}
}
return arrayList;
}
public static void main(String[] args) {
String arr[]={"迪丽热巴，女","古力娜扎，女","马儿扎哈，男","刘亦菲，女","胡歌，男"};
ArrayList<String> list = filter(arr,
(s) -> {
String[] as = s.split("，");
return as[0].length()==4;
},
(s) -> {
String[] as = s.split("，");
return as[1].equals("女");
});
for (String s : list) {
System.out.println(s);
}
}
}
结果
迪丽热巴，女
古力娜扎，女
Function
Function接口中的默认方法andThen：用来进行组合操作
需求：
把String类型的“123”，转换为Integer类型，把转换后的结果加10
把增加后Integer类型的数据，转换为String类型
分析：
转换了两次
第一次是把String类型转换为了Integer类型
所以我们可以使用Function<String ,Integer> fun1
Integer i=fun1.aplply(“123”)+10;
第二次把Integer类型转换为String类型
所以我们可以使用Function<integer，String> fun2
String s=fun2.apply(i);
我们可以使用andThen方法，把两次转换组合在一起使用
String s=fun1.andThen(fun2).apply(“123”);
fun1先调用apply方法，把字符串转换为Integer
fun2再调用apply方法，把Integer转换为字符串
import java.util.function.Function;
public class Demo09FunctionandThen {
public static void change(String str, Function<String,Integer> fun1,Function<Integer,String> fun2)
{
String in=fun1.andThen(fun2).apply(str);
System.out.println(in);
}
public static void main(String[] args) {
String num="1234";
change(num,
(str)->{return Integer.parseInt(str)+10;},
(Integer integer)->{return integer.toString();});
//简化lambda
change("1234567",(str)->Integer.parseInt(str)*10,(intg)->intg.toString()+"yuan");
}
}
5.2
练习自定义函数模型拼接
题目：
请使用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
public class Demo09FunctionandTest {
/*定义一个方法
参数传递包含姓名和年龄的字符串
参数再传递3个Function接口用于类型转换*/
public static void change(String str, Function<String,String> fun1,
Function<String,Integer> fun2,Function<Integer,Integer> fun3)
{
int in=fun1.andThen(fun2).andThen(fun3).apply(str);
String[] sr = str.split("，");
System.out.println("一百年后"+sr[0]+"的年龄是："+in);
}
public static void main(String[] args) {
String num="迪丽热巴，20";
change(num,
(str)->{
String[] sa = str.split("，");
return sa[1].toString();},
(String str)->{return Integer.parseInt(str);},
(integer)->{return integer+100;});
//简化lambda
change("古力娜扎，17",str->{String[] sa = str.split("，");
return sa[1].toString();},
str->Integer.parseInt(str),
integer->integer+100);
}
}
扫一扫
1110
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
