函数式接口

函数式接口在Java中是指：有且仅有一个抽象方法的接口

@FunctionalInterface //检测
public interface MyFunctionalInterface { 
	void myMethod();
 }

函数式编程

lambda延迟执行（性能提升）

 @FunctionalInterfacepublic 
 interface MessageBuilder { 
      String buildMessage();
      }

    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 );
     }}

常用函数式接口

java.util.function

Supplier接口

import java.util.function.Supplier;
public class Demo {
        public static String getString(Supplier<String> function) {
            return function.get();
        }
        public static void main(String[] args) {
            String msgA = "Hello";
            String msgB = "World";
            System.out.println(getString(() -> msgA + msgB));
        }


}

Consumer接口

java.util.function.Consumer 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，
其数据类型由泛型决定。

抽象方法：accept

    private static void consumeString(Consumer<String> function) {
        function.accept("Hello");
    }

    public static void main(String[] args) {
        consumeString(s -> System.out.println(s));

    }

默认方法：andThen

消费数据的时候，首先做一个操作，
然后再做一个操作，实现组合
谁写前面，谁先消费

import java.util.function.Consumer;
public class Demo10ConsumerAndThen {
    private static void consumeString(Consumer<String> one, Consumer<String> two) {
        one.andThen(two).accept("Hello");
    }
    public static void main(String[] args) {
        consumeString(
                s -> System.out.println(s.toUpperCase()),
                s -> System.out.println(s.toLowerCase()));
    }
}

import java.util.function.Consumer;

public class Demo {
    public static void main(String[] args) {
        String[] array = {"张威,女", "王五,女", "张特立,男"};
        printInfo(s -> System.out.print("姓名：" + s.split(",")[0]),
                s -> System.out.println("。性别：" + s.split(",")[1] + "。"),
                array);
    }
    private static void printInfo(Consumer<String> one, Consumer<String> two, String[] array) {
        for (String info : array) {
            one.andThen(two).accept(info); // 姓名：王五。性别：女。
        }
    }
}

Predicate接口

java.util.function.Predicate 接口
要对某种类型的数据进行判断，从而得到一个boolean值结果
抽象方法：test
boolean test(T t)
默认方法：and
默认方法：or

import java.util.function.Predicate;
public class Demo16PredicateAnd {
    private static void method(Predicate<String> one, Predicate<String> two) {
        boolean isValid = one.or(two).test("Helloworld");
        System.out.println("字符串符合要求吗：" + isValid);
    }
    public static void main(String[] args) {
        method(s -> s.contains("H"), s -> s.contains("W"));
    }
}

默认方法：negate
取反

Function接口

抽象方法：apply
默认方法：andThen
Function 接口中有一个默认的 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+"");
    }
}