Java8新特性——Lambda表达式

Java8新特性之-Lambda表达式

  Lambda 表达式(也叫闭包)：指将函数作为一个参数传递到方法中。使用 Lambda 表达式可以使代码变的更加简洁紧凑,其实质属于函数式编程的概念。

1.1 为什么使用Lambda 表达式

1. 避免定义过多的匿名内部类;
2. 使代码看起来更简洁,只留下代码的核心逻辑;

1.2 函数式接口

1.2.1 概念

• 函数式接口(Functional Interface):指只包含唯一一个抽象方法的接口,被成为函数式接口.
• 对于函数式接口,我们可以通过Lambda表达式来创建该接口的对象;

1.2.2 Java8四大内置函数式接口

1. Consumer:消费型接口   方法：void accept(T t);  对应子口:BiConsumer<T, U>
2. Supplier:供给型接口     方法：T get();      对应子接口:无
3. Function:函数式接口     方法：apply(T t);     对应子接口:BiFunction<T, U, R>
4. Predicate:断言型接口     方法：boolean test(T t);   对应子接口:BiPredicate<T, U>

public class InnerLambda {
    public static void main(String[] args) {
        consumer(2000,m-> System.out.println("出去浪了一圈,消费了"+m+"元")); //消费型
        List<Integer> list = supplier(5,()->(int)(Math.random()*100));     //供给型
        for (Integer num:list) {
            System.out.println(num);
        }
        System.out.println(function("你好,中国!", str -> str.substring(3,5)));//函数式
        List<String> list1 = predicate(Arrays.asList("tom","jack","merry","tony","ok"), str->str.length()>3);//断言式
        for (String str:list1) {
            System.out.println(str);
        }
    }
    //1.Consumer<T>:消费型接口
    public static void consumer(double money, Consumer<Double> con){
        con.accept(money);
    }
    //2.Supplier<T>:供给型接口,产生制定个数的整数
    public static List<Integer> supplier(int num, Supplier<Integer> sup){
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            list.add(sup.get());
        }
        return list;
    }
    //3.Function<T R>:函数式接口,去除字符串前后空格
    public static String function(String str, Function<String,String> fun){
        return fun.apply(str);
    }
    //4.Predicate<t>:断言型接口,满足条件的字符串
    public static List<String> predicate(List<String> list, Predicate<String> pre){
        List<String> filterList = new ArrayList<>();
        for (String str:list) {
            if(pre.test(str)){
                filterList.add(str);
            }
        }
        return filterList;
    }
}

1.3 Lambda表达式演变

public class TestLambda {
    public static void main(String[] args) {
        new Like1().lambda(1);
        new Like2().lambda(2);
        //3.局部内部类
        class Like3 implements ILike{
            public void lambda(int a) {
                System.out.println("I Like Lambda"+a+"!");
            }
        }
        new Like3().lambda(3);
        //4.匿名内部类,没有类名(Like4),必须借助接口或父类
        ILike like = new ILike() {
            public void lambda(int a) {
                System.out.println("I Like Lambda"+a+"!");
            }
        };
        like.lambda(4);
        //5.Lambda表达式:只有一个类及一个方法,故类名和方法名均省略,然后用->连接
        like = (int a) -> {
            System.out.println("I Like Lambda"+a+"!");
        };
        like.lambda(5);
        //5-1.Lambda表达式简化(规则参考总结)
        like = a -> System.out.println("I Like Lambda"+a+"!");
        like.lambda(6);
    }
    //2.静态内部类
    static class Like2 implements ILike{
        public void lambda(int a) {
            System.out.println("I Like Lambda"+a+"!");
        }
    }
}
//0.定义一个函数接口:只有一个抽象方法
interface ILike{
    void lambda(int a);
}
//1.实现类
class Like1 implements ILike{
    public void lambda(int a) {
        System.out.println("I Like Lambda"+a+"!");
    }
}

1.4 总结

1. 使用Lambda表达式的前提是:是一个函数式接口
2. 方法有多个参数时,要么全部省略参数类型,要么全部都写参数类型,且小括号不可省略(单个参数可省略小括号);
3. 方法体中只有一个语句时,可以省略方法的大括号。