Java函数式接口看这一篇就够了

目录：
1.函数式接口的基本概念和格式
2.函数式编程
3.函数式接口作为方法的参数和方法的返回值
4.常用函数式接口

1.函数式接口的基本概念和格式

 

1.函数式接口的基本概念:

函数式接口在Java中是指：有且仅有一个抽象方法的接口。
函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可 以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

如果对Lambda表达式不是很清除那么可以参照这一篇博客:Lambda表达式详解

介绍一个语法糖概念:

语法糖:是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实 底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部 类的“语法糖”，但是二者在原理上是不同的。

2.格式:

只要满足有一个抽象方法的接口即可,当然也可以包含其他的方法(默认静态私有等等)

修饰符 interface 接口名称{ (public abstract) 返回值类型 方法名称(可选参数信息); // 其他非抽象方法内容 
}

由于接口中默认类型为public abstract 所以带不带都行

3.@FunctionalInterface注解:

Java 8中专门为函数式接口引入了一个新的注解： @FunctionalInterface。该注 解可用于一个接口的定义上

@FunctionalInterfacepublic interface MyFunctionalInterface{ void myMethod(); }

我们这一个注解当我们在定义函数式接口的时候发送了错误,那么注解的编译就不通过:
当我们去掉一个抽象的方法的时候就,注意就会正常通过编译:

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注 意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

2.函数式编程

 

1.Lambda表达式的延迟执行
看一段代码：

  public class Demo01Logger { private static void log(int level, String msg) { if (level == 1) { System.out.println(msg); } }public static void main(String[] args) { String msgA = "Hello";String msgB = "World"; String msgC = "Java"; log(1, msgA + msgB + msgC); }
}

分析一下这段代码，发现存在浪费，首先log方法传进两个参数，第一个参数是一个数字，第二个参数是一个拼接后的字符串，那么正常调用的时候我们就要先把字符串拼接好后再调用log函数，如果第一个参数不是1，那么拼接字符串就显得没用，白拼接了，这样就造成了浪费，这时候就可以使用Lambda解决

想要解决问题，那么首先我们了解Lambda的使用特点和前提：

1.使用特点：延迟加载
2.使用前提：必须存在函数式接口

具体解决的代码实现：

package untl1;
public class Demo02LoggerLambda
{private static void log(int level, MessageBuilder builder){if (level == 1){System.out.println(builder.buildMessage());}}public static void main(String[] args){String msgA = "Hello";String msgB = "World";String msgC = "Java";log(1, ()-> msgA+msgB+msgC);}
}
@FunctionalInterface
interface MessageBuilder {String buildMessage();
}

此段代码就完美的解决上述问题，那么，我们如何证实在第一个参数不是1的时候不进行字符串的拼接呢，我们可以在第二个参数加一个书输出语句即

package untl1;
public class Demo02LoggerLambda
{private static void log(int level, MessageBuilder builder){if (level == 1){System.out.println(builder.buildMessage());}}public static void main(String[] args){String msgA = "Hello";String msgB = "World";String msgC = "Java";log(1, ()-> {System.out.println("我第一个参数是1");return msgA+msgB+msgC+1;});log(2, ()-> {System.out.println("我第一个参数不是1");return msgA+msgB+msgC+2;});}
}
@FunctionalInterface
interface MessageBuilder {String buildMessage();
}
运行结果：
我第一个参数是1
HelloWorldJava1

3.函数式接口作为方法的参数和方法的返回值

 

作为方法的参数，上边修正过的例子就是，作为方法的返回值如下例：

package untl1;
public class Demo02LoggerLambda
{private static MessageBuilder log(){return (a,b)->{return a+b;};}public static void main(String[] args){MessageBuilder a=log();System.out.println(a.buildMessage("hello","world"));}
}
@FunctionalInterface
interface MessageBuilder {String buildMessage(String a,String b);
}
运行结果：
helloworld

注意return中的a和b是两个变量名称，可以随意更改

4.常用函数式接口

 

1.supplier接口：
(1) 简介：

java.util.function.Supplier<T> 接口仅包含一个无参的方法： T get() 。用来获取一个泛型参数指定类型的对 象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象 数据,supplier接口又被称为生产型接口,指定接口是什么类型，那么接口的get方法就会产生一个什么类型的数据类型

(2)例子：

package untl1;
import java.util.function.Supplier;
public class MySupplier {public static  String getString(Supplier<String> sup){return sup.get();}public static void main(String[] args) {String str=getString(()->"helloworld");System.out.println(str);}}
运行结果：
helloworld

2.Consumer接口：
(1)简介：

java.util.function.Consumer<T> 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据， 其数据类型由泛型决定。Consumer 接口中包含抽象方法 void accept(T t) ，意为消费一个指定泛型的数据。,至于具体怎么消费如何消费需要自定义(输出或者计算等等…)

(2)l例子：

package untl1;
import java.util.function.Consumer;
public class MyConsumer {public static void method(String name, Consumer<String> con){con.accept(name);}public static void main(String[] args) {method("我是帅哥",(String name1)-> System.out.println(name1));}
}

(3).Consumer默认方法andThen

如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作， 然后再做一个操作，实现组合。而这个方法就是 Consumer 接口中的default方法 andThen 。下面是JDK的源代码：

default Consumer<T> andThen(Consumer<? super T> after) 
{ Objects.requireNonNull(after);return (T t) ‐> {accept(t); after.accept(t); };
}

其实andThen方法简单来说就是把两个Consumer接口组合在一起，在分别对数据进行消费
下面我们不使用andThen和使用andThen的两个例子做对比：
例子1(不使用andThen):

package untl1;
import java.util.function.Consumer;
public class MyConsumer {public static void method(String str, Consumer<String> a,Consumer<String> b){a.accept(str);b.accept(str);}public static void main(String[] args) {method("hello",(String a)-> System.out.println(a),(String b)-> System.out.println(b.toUpperCase()));}}
运行结果：
hello
HELLO

我们使用andThen之后：

package untl1;
import java.util.function.Consumer;
public class MyConsumer {public static void method(String str, Consumer<String> a,Consumer<String> b){a.andThen(b).accept(str);}public static void main(String[] args) {method("hello",(String a)-> System.out.println(a),(String b)-> System.out.println(b.toUpperCase()));}}
运行结果和上边的一样

上述代码由于是a连接b那么先执行a消费数据，然后再执行消费数据
3.Predicate接口：
(1)简介；

有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用 java.util.function.Predicate<T>接口。Predicate 接口中包含一个抽象方法： boolean test(T t) 。

(2)例子：

package untl1;
import java.util.function.Predicate;
public class MyPredicate {public static boolean checkString(String str, Predicate<String> pre){return pre.test(str);}public static void main(String[] args) {String str="abc";boolean b=checkString(str,a->a.length()>6);System.out.println(b);}
}
运行结果：
false

(3)默认方法and:

既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实 现“并且”的效果时，可以使用default方法 and。其JDK源码为

default Predicate<T> and(Predicate<? super T> other) {Objects.requireNonNull(other);return (t) ‐> test(t) && other.test(t); 
}

例子：
我么判断一个字符串里边长度是不是为5，里边是不是包含a这个字符：

package untl1;
import java.util.function.Predicate;
public class MyPredicate {public static boolean checkString(String str, Predicate<String> a,Predicate<String> b){return a.and(b).test(str);//其实就相当于return a.test(str)&&b.test(str)}public static void main(String[] args) {boolean a= checkString("abc",str->str.length()==5,str->str.contains("a") );System.out.println(a);}
}
运算结果：
false

(4)默认方法or:

与 and 的“与”类似，默认方法 or 实现逻辑关系中的“或”。

例子：

package untl1;
import java.util.function.Predicate;
public class MyPredicate {public static boolean checkString(String str, Predicate<String> a,Predicate<String> b){return a.or(b).test(str);//其实就相当于return a.test(str)||b.test(str)}public static void main(String[] args) {boolean a= checkString("abc",str->str.length()==5,str->str.contains("a") );System.out.println(a);}
}
运行结果：
true

(5)默认方法negate：

“或”已经了解了，剩下的“非”（取反）也会简单。

例子：

package untl1;
import java.util.function.Predicate;
public class MyPredicate {public static boolean checkString(String str, Predicate<String> a){return a.negate().test(str);}public static void main(String[] args) {boolean a= checkString("abc",str->str.length()==5);System.out.println(a);}
}
运行结果：
true

5.Function接口：
(1)简介

java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件， 后者称为后置条件。Function 接口中最主要的抽象方法为：R apply(T t) ，根据类型T的参数获取类型R的结果。 使用的场景例如：将 String 类型转换为 Integer 类型。

(2)
例子：

package untl1;
import java.util.function.Function;
public class MyFunction {public static void change(String str, Function<String,Integer> fun){int  in=fun.apply(str);//自动拆箱System.out.println(in+1);}public static void main(String[] args) {String str="1234";change(str,a-> Integer.parseInt(a));}}
运行结果：
1235

(3)默认方法andThen:

同样进行组合操作：

例子：
我们把String类型的123转换成Integer加上10，再转换成String类型：

package untl1;
import java.util.function.Function;
public class MyFunction {public static void change(String str, Function<String,Integer>       fun1,Function<Integer,String>  fun2){String str1=fun1.andThen(fun2).apply(str);System.out.println(str1);}public static void main(String[] args) {String str="123";change(str,a-> Integer.parseInt(a)+10,b->b+"");}}
运行结果：
133