lambda函数接口

1 Consumer

      只有输入，没有输出

// #1 函数推导
Consumer consumer1 = (s) -> System.out.println(s);
consumer1.accept("你好");
// #2 第二种写法
Consumer consumer2=System.out::println;
consumer2.accept("洋洋");

// #3 andThen 从前向后执行
consumer2.andThen(consumer2).andThen(consumer1).accept("二哈");  //二哈 二哈 三娃子

// consumer2执行，打印"二哈"
//consumer2执行，打印"二哈"
//consumer1执行，打印"三娃子" （consumer1的接口打印的是"三娃子"）


2 Function
   既有输入，又有输出（类似将参数经过处理并返回）

@Test
public void test1() {

    // #1 第一个参数，参数类型， 第二个参数：返回值类型
    Function<Integer, Integer> function = s -> s * s;
    Integer apply = function.apply(12);
    System.out.println(apply);  //  144

}

@Test
public void test2() {
    // #1 输入 String 返回 int 的function
    Function<String, Integer> parseInt = Integer::parseInt;
    Integer apply1 = parseInt.apply("12");
    System.out.println(apply1);  // 12
}

@Test
public void test3() {

    // #1  compose   ()里面的先执行

    Function<Integer, Integer> function1 = s -> s * s;
    Function<Integer, Integer> function2 = s -> --s;
    Function<Integer, Integer> function3 = s -> ++s;

    // 先执行function3 (3) 再执行 function2 (2) 再执行function1 (4)  先执行的结果输出作为后执行的输入
    Integer apply = function1.compose(function2).compose(function3).apply(2);
    System.out.println(apply);  //4
}

@Test
public void test4() {
    Function<Integer, Integer> function1 = s -> s * s;
    Function<Integer, Integer> function2 = s -> --s;
    Function<Integer, Integer> function3 = s -> s = s + 2;

    // 先执行 function1 (9) 再执行function2(8) 再执行function3 (10)
    Integer apply = function1.andThen(function2).andThen(function3).apply(3);
    System.out.println(apply);
}

@Test
public void test6() {
    // identity方法会返回一个不进行任何处理的Function，即输出与输入值相等；
    Object s = Function.identity().apply("s");
    System.out.println(s.toString());   // s
}

3 Predicate

   “判断”，返回boolean

// test
@Test
public void test1() {

    // 传入一个参数，返回boolean
    Predicate<String> predicate = (s) -> {
        return s.endsWith("a");
    };
    //简写   Predicate<String>  predicate1=s->s.endsWith("a");
    boolean b = predicate.test("asd");
    System.out.println(b);
}


// negate  结果取反
@Test
public void test2() {


    Predicate<String> predicate = s -> s.endsWith("a");
    boolean b = predicate.test("asd");
    System.out.println(b);  //false

    boolean asd = predicate.negate().test("asd");
    System.out.println(asd);    //true
}

// and  针对同一输入值，多个Predicate均返回True时返回True，否则返回False；
@Test
public void test3() {

    Predicate<String> predicate1 = s -> s.endsWith("a");
    Predicate<String> predicate2 = s -> s.startsWith("a");

    boolean asa = predicate1.and(predicate2).test("asa");
    System.out.println(asa); //true
    boolean ass = predicate1.and(predicate2).test("ass");
    System.out.println(ass); //false
}
// or  针对同一输入值，多个Predicate只要有一个返回True则返回True，否则返回False

@Test
public void test4() {
    Predicate<String> predicate1 = s -> s.endsWith("a");
    Predicate<String> predicate2 = s -> s.startsWith("a");

    boolean asa = predicate1.or(predicate2).test("asa");
    System.out.println(asa); //true
    boolean ass = predicate1.or(predicate2).test("ass");
    System.out.println(ass); //true
    boolean sass = predicate1.or(predicate2).test("sass");
    System.out.println(sass); //false
}

4 UnaryOperator

      1元运算,接收T对象，返回T对象(继承的Function接口，只不过输入与输出的类型不能变)

@Test
public void unaryOperator() {
    UnaryOperator<Integer> unaryOperator = (s) -> s + 1;
    Integer apply = unaryOperator.apply(1);
    Optional.ofNullable(apply).ifPresent(System.out::println); // 2
}

5 BinaryOperator

   二目算符 接收两个T对象，返回T对象

@Test
public void binaryOperator() {
    BinaryOperator<String> binaryOperator = (m, n) -> String.valueOf(Integer.parseInt(m) + Integer.parseInt(n));
    String apply = binaryOperator.apply("1", "3");
    Optional.ofNullable(apply).ifPresent(System.out::println);
}

6 IntFunction
   输入参数类型 int ,输出参数类型：自定义。专门处理int类型，避免了拆箱装箱。与Function不是继承关系，而是同级的关系

@Test
public void intFunction(){
    IntFunction<String> intFunction =(s)->String.valueOf(s+4);
    String apply = intFunction.apply(5);
    Optional.ofNullable(apply).ifPresent(System.out::println);

}

.。。。。。。。。。
这些接口在  java.util.function.function  包，还有更多