函数式接口

函数式接口：有且只有一个抽象方法的接口，(可以包含其他默认，静态，私有方法)

//函数式接口的使用，创建一个函数式接口
public interface FunctionalInterfaceDemo{public abstract void method();
}

//实现函数式接口
public class FunctionalInterfaceDemoImpl implements FunctionalInterfaceDemo{public void method(){System.out.println("我实现了函数式接口");}
}

public class Test{public static void main(String[] args){//参数是接口，使用接口的实现类对象来调用method方法show(new FunctionalInterfaceDemoImpl());//参数是接口，使用接口的匿名内部类来调用方法 show(new FunctionalInterfaceDemo() {public void method() {System.out.println("我使用了接口的匿名内部类");}});//函数式接口，可以使用Lambda表达式//(参数的内容)->{方法体}show(()->{System.out.println("使用lambda表达式");});}public static void show(FunctionalInterfaceDemo fid){fid.method();}
}
//我实现了函数式接口
//我使用了接口的匿名内部类
//使用lambda表达式

性能浪费的日志案例

public class LoggerDemo{public static void main(String[] args){String msg1 = "Hello";String msg2 = "World";String msg3 = "Java";showLog(1,msg1+msg2+msg3);}public static void showLog(int level,String message){//这里如果输入的不是1，那么前面的字符串就会白拼接了//造成了性能浪费if(level==1){System.out.println(message);}}
}

使用Lambda优化日志

//Lambda特点，延迟加载
public class LambdaDemo2{public static void main(String[] args){String msg1 = "Hello";String msg2 = "World";String msg3 = "Java";//方法参数是一个接口，可以传递接口的匿名内部类showLog(1,new MessageBuilder(){public String builderMessage(){return msg1+msg2+msg3;}});//调用方法,接口参数是函数式接口，可以使用的是Lambda表达式showLog(1,()->{return msg1+msg2+msg3;});//感觉使用匿名内部类作为参数比较好理解，但是使用Lambda表达式的话比较简洁，但是也不好理解，有点抽象}public static void showLog(int level,MessageBuilder mb){//如果日记等级是1，就调用MessageBuilder的方法if(level == 1){//不等于1的话，这一段就不会执行，就不会调用到方法，就不会拼接字符串，就不会存在性能浪费System.out.println(mb.builderMessage());}}
}

函数式接口作为方法的参数案列

public class RunnableDemo{public static void main(String[] args){//调用startThread方法//方法参数是一个函数式接口，可以使用Lambda表达式//当然也可以通过接口的实现类对象，或者匿名内部类对象进行传参//首先使用匿名内部类对象来调用方法startThread(new Runnable(){public void run(){System.out.println(Thread.currentThread().getName()+"-->线程启动");}});//使用Lambda表达式作为参数startThread(()->{System.out.println(Thread.currentThread().getName()+"-->线程启动");});}//接口Runnable是一个函数式接口public static void startThread(Runnable run){//调用我startThread方法，我就开启一条线程//Thread类的有一个带Runnable接口的构造方法，//传递该接口，就可以开启一条线程对象new Thread(run).start();}//大概能理解，但是有点绕
}

函数式接口作为返回值得类型

import java.util.*;
public class ComparatorDemo{public static void main(String[] args){String[] arr ={"aaa","b","ccccc","dddddddd"};//把数组的内容以字符串的形式打印出来System.out.println(Arrays.toString(arr));//根据比较器产生的顺序对指定对象组进行排序Arrays.sort(arr,getComparator());System.out.println(Arrays.toString(arr));}//定义一个方法，其返回值类型是Comparatorpublic static Comparator<String> getComparator(){return (o1,o2)->o2.length()-o1.length();}
}

常用的函数式接口_Supplier接口

import java.util.function.*;
/*
* Supplier<T> 接口被称之为生产性接口，接口指定的类型是什么，接口中get方法就会返回一个相同的类型
*/
public class SupplierDemo {public static void main(String[] args) {//匿名内部类System.out.println(getString(new Supplier<String>() {@Overridepublic String get() {//下面的方法getString执行方法体的语句，sp.get()，获取到了"春风扶槛露华浓"，传递给main方法，main方法打印输出return "春风扶槛露华浓";}}));//按照我的理解这里的return 把"云想衣裳花想容"传递给了下面的方法getString,下面的方法再次return回来，所以就打印输出"云想衣裳花想容"//String s = getString(()->{return "云想衣裳花想容";});System.out.println(s);}//Supplier是一个函数式接口public static String getString(Supplier<String> sp){return sp.get();}
}
//看视频不是很理解，但是写的话自己理清楚思路按照Lambda的格式，一步一步想清楚，勉强能写出来，

//求最大值
import java.util.function.*;public class MaxDemo {public static void main(String[] args) {int[] arr= {12,42,33,55,23,75,24};//调用getMax方法//参数是一个函数式接口，可以使用Lambda表达式int maxNum=getMax(()->{int max=arr[0];for(int i:arr){if(i>max){max=i;}}//要求有返回,必须加returnreturn max;});System.out.println(maxNum);}public static int getMax(Supplier<Integer> sp){//调用Supplier的get方法，他会返回指定的类型return sp.get();}}

Consumer接口

import java.util.function.*;public class ConsumerDemo {public static void main(String[] args) {//调用method,函数式接口的accept有参数method("李白",(String name)->{//方法体写要对name做什么操作System.out.println("云想衣裳花想容->"+name);});}//Consumer<T>接口是一个消费的数据//泛型指定什么类型，就可以使用方法accept方法消费什么类型的数据public static void method(String name,Consumer<String> con){//当你调用method的时候，你可以对name进行指定的操作con.accept(name);}
}

​ 个人总结Lambda表达式的几个知识点

有return语句的方法，L表达式也要跟着return，不然编译不通过，我想不通为什么，反正就是要这样

L表达式要不要加参数，好像是看函数式接口的抽象方法有没有参数

要执行的操作都是在L表达式中的方法体给出

Consumer接口默认方法andThen

andThen：需要两个Consumer接口，可以把两个Consumer接口组合到一起，在对数据进行消费

package demo18;import java.util.function.Consumer;public class ConsumerDemo1 {public static void main(String[] args) {//调用方法method("李白",//可以指定参数类型(String name)->{System.out.println("云想衣裳花想容");},//也可以不指定参数类型(name)->{System.out.println("春风扶槛露华浓"+name);});}public static void method(String name, Consumer<String> con1,Consumer<String> con2){//默认方法andThen方法可以把两个接口连接在一起，一起消费数据name,//消费的方式可以在Lambda表达式中给出con1.andThen(con2).accept(name);}
}

Consumer接口练习

package demo18;import java.util.function.*;public class Test {public static void main(String[] args) {//准备一个数组String[] arr={"孙策，大乔","周瑜，小乔","吕布，貂蝉"};//调用方法methodmethod(arr,(s)->{//遍历获得元素，传递到了这里，//现在对元素进行切割，切割返回的是一个素组，通过索引0来获取需要的元素String name= s.split("，")[0];System.out.print("男: "+name);},//遍历获得元素，现在轮到我来对他进行切割，需要1元素    (s)->{String name1= s.split("，")[1];System.out.println(" 女 "+name1);});}public static void method(String[] str, Consumer<String> con1,Consumer<String> con2){//只要调用我，我就把他传递过来的集合给遍历了，获取出每一个元素，让con1和con2一起去操作这个元素//具体的操作步骤已经在Lambda表达式中给出for(String s :str){con1.andThen(con2).accept(s);}}
}

Prediat接口

package demo18;import java.util.function.*;public class PredicateDemo {public static void main(String[] args) {//调用方法method//这个函数式接口Predicate是有参数的//等一下不要忘记把变量名改一下boolean b= method("云想衣裳花想容",(String s)->{return s.equals("春风扶槛露华浓");});System.out.println(b);}public static boolean method(String s,Predicate<String> pre){//调用Predicate中的方法test，对传递进来的参数进行判断//具体的判断步骤可以在Lambda表达式中写出return pre.test(s);}
}

Predicate接口_默认方法and

package demo18;import java.io.InputStream;
import java.util.function.Predicate;public class PredicateDemo1 {public static void main(String[] args) {boolean b =  method("云想衣裳花想容",(String str)->{System.out.println(str.length());return str.length()>5;},(String str)->{return str.contains("花");});System.out.println(b);}public static boolean method(String str, Predicate<String> pre1 , Predicate<String> pre2){//对传递过来的str进行判断//and，两个为true 就返回truereturn pre1.and(pre2).test(str);}
}

Predicate接口_默认方法or和negate

or有一个为true，就为true

negate是取反的意思，

Predicate接口的练习

import java.util.*;
import java.util.function.*;public class Test1 {public static void main(String[] args) {String[] array = {"迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女"};ArrayList<String> list = method(array,(String s) -> {String name = s.split(",")[0];boolean b1 = name.length() == 4;return b1;}, (String s) -> {String sex = s.split(",")[1];boolean b2 = sex.equals("女");return b2;});System.out.println(list);}public static ArrayList<String> method(String[] arr, Predicate<String> pre1, Predicate<String> pre2) {//定义一个集合，用来接收条件满足的元素ArrayList<String> list = new ArrayList<String>();//对传递进来的参数进行判断for (String s : arr) {//在Lambda表达式中进行具体的操作boolean b = pre1.and(pre2).test(s);//在Lambda表达式中如果操作完了，就会执行下面这一步if (b) {list.add(s);}}return list;}
}

Function接口

Function接口的抽象方法 R apply(T t),根据类型T的参数获取类型T的结果

import java.util.function.*;public class FunctionDemo {public static void main(String[] args) {String s = "1234";change(s,(String str)->{return Integer.parseInt(str);});}public static void change(String s, Function<String,Integer> fun){Integer in = fun.apply(s);System.out.println(in);}
}

import java.util.function.*;public class FunctionDemo {public static void main(String[] args) {String s = "123";change(s,(String str) -> {return Integer.parseInt(str) + 10;},(Integer i) -> {return i + "";});}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);}
}