函数式接口定义
有且仅有一个抽象方法的接口
放在接口定义的上方，表示该接口是函数式接口接口有且仅有一个抽象方法
注意
定义函数式接口的时候，@FunctionalInterface是可选的，就算不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。
实战
函数式接口作为方法的参数
public class Demo1 {
public static void main(String[] args) {
System.out.println('-----函数式接口作为方法的参数----');
method((String s) -> {
System.out.println(s);
});
}
public static void method(Toshow toshow) {
toshow.toSee('小明');
}
interface Toshow {
void toSee(String userName);
}
}
函数式接口作为方法的返回值
常用的函数式接口
包含一个无参的方法Tget()：获得结果该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据Supplier接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用。
案例1
public class Demo3 {
public static void main(String[] args) {
String s = getString(() -> {
return '小苗';
});
System.out.println(s);
System.out.println('---------------');
Integer i = getInteger(() -> 30);
System.out.println(i);
}
//定义一个方法，返回一个整数数据
private static Integer getInteger(Supplier sup) {
return sup.get();
}
//定义一个方法，返回一个字符串数据
private static String getString(Supplier sup) {
return sup.get();
}
}
案例2
用于返回一个int数组中的最大值
public class Demo5 {
public static void main(String[] args) {
// 定义一个int数组
int[] arr = { 19, 50, 28, 37, 46 };
int maxValue = getMax(() -> {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
});
System.out.println(maxValue);
}
// 返回一个int数组中的最大值
private static int getMax(Supplier sup) {
return sup.get();
}
}
包含两个方法voidaccept(Tt)：对给定的参数执行此操作defaultConsumerandThen(Consumerafter)：返回一个组合的Consumer，依次执行此操作，然后执行after操作。这个要看源码才能理解。被称为消费型接口，它消费的数据类型由泛型指定。
案例
public class Demo3 {
public static void main(String[] args) {
operatorString('ABC', (String s) -> {
System.out.println(s.toLowerCase());
});
System.out.println('-----------');
operatorString('ABC', (String s) -> {
System.out.println(s + '转小写：' + s.toLowerCase());
}, (String s) -> {
System.out.println('倒序：' + new StringBuilder(s).reverse().toString());
});
}
// 定义一个方法，用不同的方式消费同一个字符串数据两次
private static void operatorString(String name, Consumer con1, Consumer con2) {
// con1.accept(name);
// con2.accept(name);
con1.andThen(con2).accept(name);
}
// 定义一个方法，消费一个字符串数据
private static void operatorString(String name, Consumer con) {
con.accept(name);
}
}
案例2
1. String[] strArray = {'林青霞,30', '张曼玉,35', '王祖贤,33'};
2. 字符串数组中有多条信息，请按照格式：'姓名：XX,年龄：XX'的格式将信息打印出来
要求：
把打印姓名的动作作为第一个Consumer接口的Lambda实例
把打印年龄的动作作为第二个Consumer接口的Lambda实例
将两个Consumer接口按照顺序组合到一起使用
public class Demo4 {
public static void main(String[] args) {
String[] strArray = { '林青霞,30', '张曼玉,35', '王祖贤,33' };
printInfo(strArray,
(String str) -> {
String name = str.split(',')[0];
System.out.print('姓名：' + name);
},
(String str) -> {
int age = Integer.parseInt(str.split(',')[1]);
System.out.println(',年龄：' + age);
});
}
private static void printInfo(String[] strArray, Consumer con1, Consumer con2) {
for (String str : strArray) {
con1.andThen(con2).accept(str);
}
}
}
Predicate接口通常用于判断参数是否满足指定的条件常用方法如下booleantest(Tt)：对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值defaultPredicate
案例1
public class Demo1 {
public static void main(String[] args) {
boolean b1 = checkString('A', (String s) -> {
return s.equals('A');
});
System.out.println('b1：' + b1);
boolean b2 = checkString('B', (String s) -> {
return s.equals('A');
});
System.out.println('b2：' + b2);
}
// 逻辑非操作
private static boolean checkString(String s, Predicate pre) {
// return pre.test(s);
// return !pre.test(s);
return pre.negate().test(s);
}
}
案例2
public class Demo2 {
public static void main(String[] args) {
boolean b1 = checkString2('A', (String s) -> {
return s.equals('A');
}, (String s) -> {
return s.equals('B');
});
System.out.println('b1：' + b1);
boolean b2 = checkString3('A', (String s) -> {
return s.equals('A');
}, (String s) -> {
return s.equals('B');
});
System.out.println('b2：' + b2);
}
// 逻辑与运算
private static boolean checkString2(String s, Predicate pre1, Predicate pre2) {
return pre1.and(pre2).test(s);
}
// 逻辑或运算
private static boolean checkString3(String s, Predicate pre1, Predicate pre2) {
return pre1.or(pre2).test(s);
}
}
案例3
1. String[] strArray = {'林青霞,30', '柳岩,34', '张曼玉,35', '貂蝉,31', '王祖贤,33'};
2. 字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
3. 要求：同时满足如下要求
1:姓名长度大于2
2:年龄大于33
4. 分析:
1:有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断
2:必须同时满足两个条件,所以可以使用and方法连接两个判断条件
public class Demo3 {
public static void main(String[] args) {
String[] strArray = { '林青霞,30', '柳岩,34', '张曼玉,35', '貂蝉,31', '王祖贤,33' };
ArrayList array = myFilter(strArray,
s -> s.split(',')[0].length() > 2,
s -> Integer.parseInt(s.split(',')[1]) > 33);
for (String str : array) {
System.out.println(str);
}
}
// 通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中
private static ArrayList myFilter(String[] strArray, Predicate pre1, Predicate pre2) {
// 定义一个集合
ArrayList array = new ArrayList<>();
// 遍历数组
for (String str : strArray) {
if (pre1.and(pre2).test(str)) {
array.add(str);
}
}
return array;
}
}
Function
Function
案例1
public class Demo4 {
public static void main(String[] args) {
System.out.println('--------把一个字符串转换int类型，在控制台输出----------');
convert('100', s -> Integer.parseInt(s));
System.out.println('--------把一个int类型的数据加上一个整数之后，转为字符串在控制台输出----------');
convert(100, i -> String.valueOf(i + 566));
System.out.println('--------把一个字符串转换int类型，把int类型的数据加上一个整数之后，转为字符串在控制台输出----------');
convert('100', s -> Integer.parseInt(s), i -> String.valueOf(i + 566));
}
// 把一个字符串转换int类型，在控制台输出
private static void convert(String s, Function fun) {
int i = fun.apply(s);
System.out.println(i);
}
// 把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
private static void convert(int i, Function fun) {
String s = fun.apply(i);
System.out.println(s);
}
// 把一个字符串转换int类型，把int类型的数据加上一个整数之后，转为字符串在控制台输出
private static void convert(String s, Function fun1, Function fun2) {
// Integer i = fun1.apply(s);
// String ss = fun2.apply(i);
// System.out.println(ss);
String ss = fun1.andThen(fun2).apply(s);
System.out.println(ss);
}
}
文章为作者独立观点，不代表股票交易接口观点
股民评论