1、函数式接口概述

函数式接口： 有且仅有一个抽象方法的接口。
Java中的函数式编程体现就是Lambda表达式。
所以函数式接口即可以适用于Lambda使用的接口。

如何检测一个接口是不是函数式接口？

@FunctionalInterface
放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败。

package com.test8;@FunctionalInterface
public interface Inter {void show();
}

package com.test8;public class Demo {public static void main(String[] args) {Inter i=()-> System.out.println("Hello world!");i.show();}
}

注意：自定义函数式接口时，@FunctionalInterface是可选的，就算不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。

2、函数式接口做为方法的参数

如果方法的参数是一个函数式接口，可以使用Lambda表达式作为参数传递。

package com.test9;public class Demo {public static void main(String[] args) {//匿名内部类startThread(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"线程启动");}});//Lambda表达式startThread(()-> System.out.println(Thread.currentThread().getName()+"线程启动"));}private static void startThread(Runnable r){Thread t=new Thread(r);t.start();}
}

3、函数式接口作为方法的返回值

如果方法的返回值是一个函数式接口，可以使用Lambda表达式作为结果返回。

package com.test10;import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;public class Demo {public static void main(String[] args) {ArrayList<String> array=new ArrayList<String>();array.add("aa");array.add("b");array.add("cccc");array.add("ddd");System.out.println("排序前："+array);Collections.sort(array);//自然排序System.out.println("自然排序后："+array);Collections.sort(array,getComparator());System.out.println("指定比较器排序后："+array);}private 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;//Lambda表达式
//        return (String s1,String s2)->{//            return s1.length()-s2.length();
//        };return (s1,s2)->s1.length()-s2.length();}
}

3、常用的函数式接口

Java8在java.util.function包下预定义了大量的函数数式接口供我们使用。

Supplier接口
Consumer接口
Predicate接口
Function接口

3.1、Supplier接口

Supplier：包含一个无参的方法

T get()：获得结果
该方法不需要参数，它会按照某种实现逻辑（由Lambda表达式实现）返回一个数据。
Supplier接口也称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用。

案例一：

package com.test11;import java.util.function.Supplier;public class Demo {public static void main(String[] args) {//        String s=getString(()->{//           return "唐青枫";
//        });String s=getString(()->"唐青枫");System.out.println(s);Integer i=getInteger(()->10);System.out.println(i);}private static String getString(Supplier<String> sup){return sup.get();}private static Integer getInteger(Supplier<Integer> sup){return sup.get();}
}

案例二：

package com.test10;import java.util.function.Supplier;public class Test {public static void main(String[] args) {int[] arr={1,9,2,7,5};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);}private static int getMax(Supplier<Integer> sup){return sup.get();}
}

3.2、Consumer接口

Consumer：包含两个方法

void accept(T t)：对给定的参数执行此操作。
default Consumer andThen(Consumer after)：返回一个组合的Consumer，依次执行操作，然后执行after操作。
Consumer接口也称为消费型接口，它消费的数据的数据类型由泛型指定。

案例一：

package com.test10;import java.util.function.Consumer;public class ConsumerDemo {public static void main(String[] args) {//Lambda表达式operatorString("唐青枫",(String name)->{System.out.println(name);});//Lambda表达式operatorString("唐青枫",name-> System.out.println(name));//方法引用operatorString("唐青枫", System.out::println);//Lambda表达式operatorString("唐青枫",(String name)->{String s=new StringBuilder(name).reverse().toString();System.out.println(s);});System.out.println("****************************");//Lambda表达式operatorString("曲无忆",name-> System.out.println(name),name-> System.out.println(new StringBuilder(name).reverse().toString()));}//消费一个字符串数据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);}
}

案例二：

package com.test10;import java.util.function.Consumer;public class ConsumerTest {public static void main(String[] args) {String[] arr={"唐青枫,20","曲无忆,21","离玉堂,22","叶知秋,23"};printInfo(arr,(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[] arr, Consumer<String> con1, Consumer<String> con2){for(int i=0;i<arr.length;i++){con1.andThen(con2).accept(arr[i]);}}
}

3.3、Predicate接口

Predicate：常用的四个方法：

boolean test(T t)：对给定的参数进行判断（判断逻辑由Lambda表达式实现），返回一个布尔值。
default Predicate<T> negate()：返回一个逻辑的否定，对应逻辑非。
default Predicate<T> and(Predicate other)：返回一个组合判断，对应短路与。
default Predicate<T> or(Predicate other)：返回一个组合判断，对应短路或。
Predicate接口通常用于判断参数是否满足指定的条件。

negate、test案例

package com.test12;import java.util.function.Predicate;public class Demo {public static void main(String[] args) {//Lambda表达式
//        boolean b=checkString("Hello",(String str)->{//            return str.length()>8;
//        });boolean b=checkString("Hello",str->str.length()>8);System.out.println(b);System.out.println("****************************");b=checkString1("Hello",str->str.length()>8);System.out.println(b);}private static boolean checkString(String str, Predicate<String> pre){return pre.test(str);}private static boolean checkString1(String str,Predicate<String> pre){//        return !pre.test(str);//上一句等价于return pre.negate().test(str);}
}

and、or案例

package com.test12;import java.util.function.Predicate;public class Demo1 {public static void main(String[] args) {boolean b1=checkString("hello",s->s.length()>8,s->s.length()<15);boolean b2=checkString("helloworld",s->s.length()>8,s->s.length()<15);System.out.println(b1);System.out.println(b2);}private static boolean checkString(String str, Predicate<String> pre1, Predicate<String> pre2){//        boolean b1=pre1.test(str);
//        boolean b2=pre2.test(str);
//        boolean b=b1 && b2;
//        return b;//上述等价于return pre1.and(pre2).test(str);//判断两个条件和//对应的有
//      return pre1.or(pre2).test(str);//判断两个条件或}
}

案例：筛选满足条件的数据
姓名长度>2且年龄>20

package com.test13;import java.util.ArrayList;
import java.util.function.Predicate;public class Demo {public static void main(String[] args) {String[] arr={"唐青枫,20","慕晴,21","曲无忆,22","孔雀,23","离玉堂,25"};//姓名长度>2且年龄>20ArrayList<String> arrayList=myFilter(arr,str->str.split(",")[0].length()>2,str->Integer.parseInt(str.split(",")[1])>20);for(String str:arrayList){System.out.println(str);}}private static ArrayList<String> myFilter(String[] arr, Predicate<String> pre1, Predicate<String> pre2){ArrayList<String> arrayList=new ArrayList<String>();for(int i=0;i<arr.length;i++){if(pre1.and(pre2).test(arr[i])){arrayList.add(arr[i]);}}return arrayList;}
}

3.4、Function接口

Function<T,R>：常用的两个方法

R apply(T t)：将此函数应用于给定的参数。
default<V> Function andThen(Function after)：返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果。
Function<T,R>：接口通常用于对参数进行处理，转换（处理逻辑由Lambda表达式实现）,然后返回一个新的值。

package com.test14;import java.util.function.Function;public class Demo {public static void main(String[] args) {convert("666",(s)->Integer.parseInt(s));convert(666,i->String.valueOf(i));convert("666",s->Integer.parseInt(s),i->String.valueOf(i));}private static void convert(String s, Function<String,Integer> fun){int i=fun.apply(s);System.out.println(i);}private static void convert(Integer i,Function<Integer,String> fun){String s=fun.apply(i);System.out.println(s);}private static void convert(String s,Function<String,Integer> fun1,Function<Integer,String> fun2){//        int i=fun1.apply(s);
//        String str=fun2.apply(i);String str=fun1.andThen(fun2).apply(s);System.out.println(str);}
}

Java之函数式接口相关推荐

学习 Java 8 - 函数式接口 Lambda
学习 Java 8 - 函数式接口 Java 8 引入了函数式接口的概念.函数式接口其实就是只包含一个抽象方法的普通 Java 接口.在没有引入函数式接口之前,我们通常使用内部类和匿名类来实现类似的功 ...
高级JAVA - 利用函数式接口实现通用的取并集/交集/差集进阶版
在前文(高级JAVA - 利用函数式接口实现通用的取并集/交集/差集)中我们实现了利用函数式接口获取交集/差集 , 但是只能全部生成 , 假如我们只需要一个交集的话 , 所有代码仍然会执行一次 . 比 ...
java中函数式接口的使用
java中函数式接口的使用一.自己创建的函数式接口 1.1 概念只存在一个抽象方法的接口. 1.2 使用步骤: 1.创建函数式接口,创建格式参照使用格式. 2.创建一个实例类 3.在实例类中使用函 ...
Java之函数式接口(FunctionalInterface)
Java之函数式接口(FunctionalInterface) 1. FunctionalInterface是什么? FunctionalInterface 中文称之为函数式接口.是Java新特性之 ...
Java四大函数式接口
Java8函数式接口 1. Consumer<T> 消费型接口 2. Supplier <R> 供给型接口 3. Function<T, R> 函数型接口 4. P ...
【Java】函数式接口与Lambda表达式
函数式接口--@FunctionalInterface Code @FunctionalInterface interface IService {void say(String message); ...
高级JAVA - 利用函数式接口实现通用的取并集/交集/差集
package com.xing.dto;import com.xing.common.utils.XDataUtil; import lombok.Data;import java.util.Arr ...
java自定义函数式接口
⾃定义lambda接⼝流程定义⼀个函数式接⼝需要标注此接⼝ @FunctionalInterface,否则万⼀团队成员在接⼝上加了其他⽅法则容易出故障编写⼀个⽅法,输⼊需要操做的数据和接⼝在 ...
java 8 函数式接口_必看：通俗易懂地告诉你什么是java8中的“函数式接口”
花10分钟认真的看完一篇文章,或许会有意想不到的收获 java8发布已经好几年了,相信很多小伙伴都使用过java8,java8这版本带来了很多新特性,其中一个就是"函数式接口",今 ...
java 常用函数式接口_「java8系列」神奇的函数式接口
前言在上一篇Lambda的讲解中我们就提到过函数式接口,比如:Consumer consumer = (s) -> System.out.println(s);其中Consumer就是一个函数 ...

Java之函数式接口

文章目录