标签：-o 连接 抽象 string 参数 red 将不 组合 cti
定义: 有且仅有一个抽象方法的接口
修饰符 interface 接口名称{
public abstract 返回值类型 方法名称(可选参数信息);
}
在接口中public abstract是可以省略的,所以定义函数接口很简单:
public interface MyfunctionInterface{
void myMethod();
}
与@Override注释的作用类似, java 8 中专门为函数式接口引入一个新的解释: @FuncationalInterface
该注释可用于一个接口的定义上
@FunctionalInterface
public Interface myFunctionInterface{
void myMethod();
}
public class Demo{
//使用自定义的函数式接口作为方法参数
private static void doSomething(myFunctionInterface inter){
inter.myMethod(); //调用自定义的函数式接口
}
public static void main(String[] args){
//调用使用函数式接口的方法
doSomething(() -> Systam.out.println("lambda执行了"));
}
}
性能浪费的日志案例, 打印输出
public class DemoLog{
public static void main(String[] args){
String msg1 = "hello";
String msg2 = "world";
String msg3 = "java";
log(1, msg1+msg2+msg3);
}
public static void log(int level, String msg){
if(level==1){
System.out.println(msg);
}
}
}
这段代码存在问题：无论级别是否满足要求，作为 log 方法的第二个参数，三个字符串一定会首先被拼接并传入方 法内，然后才会进行级别判断。如果级别不符合要求，那么字符串的拼接操作就白做了，存在性能浪费。
体验lambda的使用
使用lambda必然是一个函数式接口
@FunctionalInterface
public interface MessageBuilder{
String buildMessage();
}
对log方法进行改造
public class DemoLoggedrLambda{
private static void log(int level, MessageBuilder builder){
if(level == 1){
System.out.println(bulider.buildMessage());
}
}
public static void main(String[] args){
String msg1 = "hello";
String msg2 = "world";
String msg3 = "java";
log(1, () -> msg1+msg2+msg3);
}
}
这样一来,只用当级别满足的时候,进行三个字符串的拼接, 否则三个字符串将不会进行拼接
java.util.function.Supplier<T>接口仅包含一个无参的方法:T get().用来获取一个泛型参数指定类型的对象数据.由于这是一个函数式接口,这就意味着对应的Lambda表达式需要"对外提供"一个符合泛型对象数据
import java.util.function.Supplier;
public class Demo{
private static String getString(Supplier<String> function){
return function.get();
}
public static void main(String[] args){
String msg1 = "hello";
String msg2 = "world";
System.out.println(getString(() -> msg1+msg2));
}
}
使用Supplier接口作为方法参数类型, 通过Lambda表达式求出int数组中最大值; 接口的泛型使用java.lang.Integer.
public class Demo{
// 定义一个方法,方法的参数传递Supplier,泛型使用Integer
public static int getMax(Supplier<Integer> sup){
return sup.get();
}
public static void main(String[] args){
int arr[] = {1, 2, 5, 6, 8};
// 调用getMax的方法,参数传递lambda
int maxNum = getMax(() ->{
//计算数组的最大值
int max = arr[0];
for(int i: arr){
if(i>max){
max=i;
}
}
return max;
});
System.out.println(maxNum);
}
}
java.util.function.Consumer<T>接口和Supplier接口相反, 它不是生产一个数据,而是消费数据其数据类型有泛型决定
Consumer接口中包含抽象方法void accept(T t)意味消费一个指定泛型数据
public class Demo01Consumer {
/*
定义一个方法
方法的参数传递一个字符串的姓名
方法的参数传递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 StringBuffer(name).reverse().toString();
System.out.println(reName);
});
}
}
andThen作用: 需要两个Consumer接口,可以把两个Consumer接口组合在一起,在对数据进行消费
public class Demo{
//定义一个方法, 方法的参数传入一个字符串和两个Consumer接口. Consumer接口的泛型使用字符串
public static void method(String s, Consumer<String> con1, Consumer<String> con2){
// 使用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());
});
}
}
package com.itheima.demo05.Consumer;
import java.util.function.Consumer;
/*
练习:
字符串数组当中存有多条信息，请按照格式“姓名：XX。性别：XX。”的格式将信息打印出来。
要求将打印姓名的动作作为第一个Consumer接口的Lambda实例，
将打印性别的动作作为第二个Consumer接口的Lambda实例，
将两个Consumer接口按照顺序“拼接”到一起。
*/
public class Demo03Test {
//定义一个方法,参数传递String类型的数组和两个Consumer接口,泛型使用String
public static void printInfo(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 = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" };
//调用printInfo方法,传递一个字符串数组,和两个Lambda表达式
printInfo(arr,(message)->{
//消费方式:对message进行切割,获取姓名,按照指定的格式输出
String name = message.split(",")[0];
System.out.print("姓名: "+name);
},(message)->{
//消费方式:对message进行切割,获取年龄,按照指定的格式输出
String age = message.split(",")[1];
System.out.println("性别: "+age+"。");
});
}
}
java.util.function.Predicate<T>对某一种数据类型进行怕吗吨, 结果返回一个boolean值
Predicate忌口中抽象方法:boolean test(T t)用来对指定数据类型数据进行判断的方法
public class Demo{
/* 定义一个方法
参数传递一个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 = "abcdef";
//调用checkString方法对字符串进行校验,参数传递字符串和Lambda表达式
/*boolean b = checkString(s,(String str)->{
//对参数传递的字符串进行判断,判断字符串的长度是否大于5,并把判断的结果返回
return str.length()>5;
});*/
//优化Lambda表达式
boolean b = checkString(s,str->str.length()>5);
System.out.println(b);
}
}
两个条件必选同时满足
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) ‐> test(t) && other.test(t);
}
/*
定义一个方法,方法的参数,传递一个字符串
传递两个Predicate接口
一个用于判断字符串的长度是否大于5
一个用于判断字符串中是否包含a
两个条件必须同时满足
*/
public class Demo{
public static boolean checkString(String s, Predicate<String> pred1, Predicate<String> pred2){
return pre1.and(pre2).test(s);
// 等价于return pre1.test(s) && pre2.test(s);
}
public static void main(String[] args){
//定义一个字符串
String s = "abcdef";
// 调用方法,进行判断
boolean b = checkString(s,(String str) ->{
return str.length()>5;
}, (String str) ->{
return str.contains("a");
});
System.out.println(b);
}
}
一个条件满足
/*
定义一个方法,方法的参数,传递一个字符串
传递两个Predicate接口
一个用于判断字符串的长度是否大于5
一个用于判断字符串中是否包含a
一个条件必须满足
*/
public class Demo{
public static boolean checkString(String s, Predicate<String> pred1, Predicate<String> pred2){
return pre1.or(pre2).test(s);
// 等价于return pre1.test(s) || pre2.test(s);
}
public static void main(String[] args){
//定义一个字符串
String s = "abcdef";
// 调用方法,进行判断
boolean b = checkString(s,(String str) ->{
return str.length()>5;
}, (String str) ->{
return str.contains("a");
});
System.out.println(b);
}
}
去反
public class Demo{
/*
定义一个方法,方法的参数,传递一个字符串
使用Predicate接口判断字符串的长度是否大于5
*/
public static boolean checkString(String s, Predicate<String> pre){
//return !pre.test(s);
return pre.negate().test(s);//等效于return !pre.test(s);
}
public static void main(String[] args) {
//定义一个字符串
String s = "abc";
//调用checkString方法,参数传递字符串和Lambda表达式
boolean b = checkString(s,(String str)->{
//判断字符串的长度是否大于5,并返回结果
return str.length()>5;
});
System.out.println(b);
}
}
/*
练习：集合信息筛选
数组当中有多条“姓名+性别”的信息如下，
String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，
需要同时满足两个条件：
1. 必须为女生；
2. 姓名为4个字。
分析:
1.有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断
2.必须同时满足两个条件,所以可以使用and方法连接两个判断条件
*/
public class Demo{
/*
定义一个方法
方法的参数传递一个包含人员信息的数组
传递两个Predicate接口,用于对数组中的信息进行过滤
把满足条件的信息存到ArrayList集合中并返回
*/
public static ArrayList<String> filter(String[] arr, Predicate<String> pre1,Predicate<String> pre2){
//定义一个ArrayList集合,存储过滤之后的信息
ArrayList<String> list = new ArrayList<>();
//遍历数组,获取数组中的信息
for(String s:arr){
//使用Predicate接口中的方法test对获取的字符串进行判断
boolean b = pre1.and(pre2).test(s);
//对布尔值进行判断
if(b){
//存储到list中
list.add(s);
}
}
return list;
}
public static void main(String[] args){
//定义一个存储字符串的数组
String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
ArrayList<String> list = filter(array, (String s)->{
return s.split(",")[1].equals("女");
}, (String s) ->{
return s.split(",")[0].length()==4;
});
//遍历集合
for (String s:list){
System.out.println(s);
}
}
}
java.util.function.Function<T, R>接口用来根据一个类型的数据得到另一个类型的数据, 前者是前置条件,周这是后置条件
public class Demo01Function {
/*
定义一个方法
方法的参数传递一个字符串类型的整数
方法的参数传递一个Function接口,泛型使用<String,Integer>
使用Function接口中的方法apply,把字符串类型的整数,转换为Integer类型的整数
*/
public static void change(String s, Function<String,Integer> fun){
//Integer in = fun.apply(s);
int in = fun.apply(s);//自动拆箱 Integer->int
System.out.println(in);
}
public static void main(String[] args) {
//定义一个字符串类型的整数
String s = "1234";
//调用change方法,传递字符串类型的整数,和Lambda表达式
change(s,(String str)->{
//把字符串类型的整数,转换为Integer类型的整数返回
return Integer.parseInt(str);
});
//优化Lambda
change(s,str->Integer.parseInt(str));
}
}
默认方法: andThen
和Consumer中的andThen一样
public class Demo02Function_andThen {
/*
定义一个方法
参数串一个字符串类型的整数
参数再传递两个Function接口
一个泛型使用Function<String,Integer>
一个泛型使用Function<Integer,String>
*/
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)->{
//把字符串转换为整数+10
return Integer.parseInt(str)+10;
},(Integer i)->{
//把整数转换为字符串
return i+"";
});
//优化Lambda表达式
change(s,str->Integer.parseInt(str)+10,i->i+"");
}
}
标签：-o 连接 抽象 string 参数 red 将不 组合 cti
原文地址：https://www.cnblogs.com/liudemeng/p/11378085.html
