Lambda表达式

Lambda表达式

语法

//() -> {}
(String first, String second)->{first.length()-second.length()};

注： ()：参数；->：指向； {}：代码体

函数式接口

对于只有一个抽象方法的接口，就可以提供一个lambda表达式。这种接口称为函数式接口

@FunctionalInterface   //一个接口只能有一个lambda的函数接口
public interface lambdaInter {
    void NoReturnPara();
}
public class lambdastudy {
    public static void main(String[] args) {
       lambdaInter lambdaInter1=() -> System.out.println("没有传参，没有输出");
       lambdaInter1.NoReturnPara();
    }

方法引用

//引用字符串比较方法
//String::compareToIgnoreCase
(x,y)->x.compareToIgnoreCase(y)

构造器引用

x-> new int[x]

lambda表达式能够延迟执行，从而可以节省性能

public class DemoLogger {
    public static void main(String[] args) {
        String msgA = "Hello ";
        String msgB = "World ";
        String msgC = "Java";

        log(1, () -> {     //当level==1时，才会执行拼接操作，否则，不执行
            System.out.println("Lambada 执行！");
            return msgA + msgB + msgC;
        });
    }

    private static void log(int level, MessageBuilder mb) {
        if (level == 1) {
            System.out.println(mb.builderMessage());
        }
    }
}

java中常用的函数式接口：

Supplier接口
java.util.function.Supplier 接口仅包含一个无参的方法: T get() 。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。如：

import java.util.function.Supplier;

public class DemoSupplier {
    public static void main(String[] args) {
        String msgA = "HelloWorld ";
        System.out.println(getString( () -> msgA ) );//控制台输出HelloWorld
    }
    private static String getString(Supplier<String> stringSupplier) {
        return stringSupplier.get();
    }
}

Consumer接口
java.util.function.Consumer 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据， 其数据类型由泛型决定。
Consumer 接口中包含抽象方法 void accept(T t) ，意为消费一个指定泛型的数据。基本使用如：

import java.util.function.Consumer;

public class DemoConsumerAccept {
    public static void main(String[] args) {
        consumerString(s -> System.out.println(s));//控制台输出HelloWorld
    }
    private static void consumerString(Consumer<String> function) {
        function.accept("HelloWorld");
    }
}

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

import java.util.function.Consumer;

public class DemoPrintInfo {
    public static void main(String[] args) {
        String[] array = { "张三，男", "李四，女", "王五，男" };

        printInfo(//split(String regex) 将此字符串分割为给定的 regular expression的匹配。 
                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接口
有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用java.util.function.Predicate 接口。
boolean test(T t);
default Predicate and(Predicate<? super T> other)
default Predicate or(Predicate<? super T> other)
default Predicate negate();
static Predicate isEqual(Object targetRef)

import java.util.function.Predicate;

public class DemoPredicateOr {
    public static void main(String[] args) {
        boolean isValid = method(
                // String.contains()方法，仅当此字符串包含指定的字符值序列时返回true。
                s -> s.contains("H"),
                s -> s.contains("W")
        );
        System.out.println("字符串符合要求吗:" + isValid);
    }

    private static boolean method(Predicate<String> one, Predicate<String> two) {
        boolean isValid = one.or(two).test("Hello world");
        return isValid;
    }
}
//输出true

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

import java.util.function.Function;

public class DemoFunctionApply {
    public static void main(String[] args) {
        method(s -> Integer.parseInt(s));
    }  
    private static void method(Function<String, Integer> function) {
        int num = function.apply("10");
        System.out.println(num + 20);
    }
}

Function 接口中有一个默认的 andThen 方法，用来进行组合操作。该方法同样用于“先做什么，再做什么”的场景，和 Consumer 中的 andThen 差不多。