java8新特性之Lambda表达式

时间 2021-04-15

标签 java app ide 函数学习 idea spa code orm 栏目 Java 繁體版

原文原文链接

java8在2014年就推出了，成天喊着8版本稳定，企业都用jdk8，结果8的特性如今才系统的学，罪过罪过啊！此系列博客可能3-4篇，带你全面地了解java8新特性。java

其实我日常学习的时候看某些入门博客，总担忧写的不全，因此但愿本身之后写的技术博客可以把必须的尽量全的总结出来，作到看一篇就可以入门的水平。app

lambda快速体验

入门最快就是看demo啦，如今有个需求，让你在众多苹果中挑选出红色的苹果ide

苹果类函数

public class Apple {
    String color;
    int weight;
    //省略构造函数，get方法
}

写法1：

public static List<Apple> filterGreenAppleWithNormal(List<Apple> apples) {
    List<Apple> res = new ArrayList<>();
    for (Apple apple : apples) {
        if ("red".equals(apple.getColor())) {
            res.add(apple);
        }
    }
    return res;
}

//调用
List<Apple> normal = filterGreenAppleWithNormal(apples);

若是再有一个需求说挑选出绿色的苹果呢，按照这种写法就须要建立一个新的类，而后仅仅把"red" 修改为"green" 其它都不变，这明显是不显示的。因此能够把颜色当成参数传进去学习

写法2：

public static List<Apple> filterGreenAppleWithArg(List<Apple> apples, String color) {
    List<Apple> res = new ArrayList<>();
    for (Apple apple : apples) {
        if (color.equals(apple.getColor())) {
            res.add(apple);
        }
    }
    return res;
}

//调用
List<Apple> arg = filterGreenAppleWithArg(apples, "red");

此时再有一个需求，须要筛选出必定重量或者某个颜色的苹果，须要怎么办呢，按照上述想法是把能想到的属性都堆到方法的参数中。ui

public static List<Apple> filterWeightOrColorWithArg(List<Apple> apples, String color, int weight, boolean flag) {
    List<Apple> res = new ArrayList<>();

    for (Apple apple : apples) {
        if (flag && color.equals(apple.getColor()) || !flag && apple.getWeight() > weight) {
            res.add(apple);
        }
    }
    return res;
}

//调用
List<Apple> weightOrColor = filterWeightOrColorWithArg(apples, "", 500, false);

能够这样写吗，固然能够解决问题，可是若是有5个属性呢，6个属性呢，还有，参数中的flag是什么意思呢。idea

仔细一想，筛选颜色，筛选重量，这些的本质是在筛选，是一个行为（后面更专业称谓语），能够把行为抽象成一个接口 。spa

行为接口

public interface AppleFilter {
    boolean filter(Apple apple);
}

写法3：

首先须要实现这个接口来具体化行为code

筛选红色苹果实现类

public class RedFilter implements AppleFilter {
    @Override
    public boolean filter(Apple apple) {
        return "red".equals(apple.getColor());
    }
}

回到使用orm

public static List<Apple> filterApples(List<Apple> apples, AppleFilter filter) {
    List<Apple> res = new ArrayList<>();

    for (Apple apple : apples) {
        if (filter.filter(apple)) {
            res.add(apple);
        }
    }

    return res;
}

//调用
List<Apple> behavior = filterApples(apples, new GreenFilter());

这样看就舒服多了，当有新需求的时候，只须要再添加一个类，好比需求是筛选出重量超200g的苹果，只须要新建一个筛选类实现上述接口便可。

public class WeightGt200Filter implements AppleFilter {
    @Override
    public boolean filter(Apple apple) {
        return apple.getWeight() > 200;
    }
}

还能怎样精简代码呢？熟悉Java的小伙伴到这里应该就想到了匿名内部类

写法4：

List<Apple> innerClass = filterApples(apples, new AppleFilter() {
    @Override
    public boolean filter(Apple apple) {
        return "green".equals(apple.getColor());
    }
});

通常到这一步，比较不错的IDE就会开始提醒建议了

这就到了咱们今天的重点，lambda表达式

写法5：

List<Apple> lambda = filterApples(apples, apple -> apple.getWeight() > 500);

没错，就是这么精简，不过filterApples 这个方法是不能省略的，可是扩展性相较1，2，简洁性相较3，4都好了不少

什么是lambda

能够把Lamdba表达式理解为简洁地表示可传递的匿名函数的一种形式：它没有名称，但它有 参数列表、函数主题、返回类型，可能还有一个能够抛出的异常列表

书写格式： (参数) -> {主体}

正如上面写法5同样(apple) -> {apple.getWeight() > 500;}

lambda表达式对参数可以自动推断类型，固然也能够显示书写类型
没有return语句，应为已经有隐含了return
lambda中能够有多行语句

使用案例：

() -> {}
() -> "java"
() -> {return "java";}
(int a, int b) -> a * b
() -> {System.out.println("hello"); System.out.println("java");}

如何才能使用lambda

使用 函数式接口的时候才能使用lambda表达式

所谓函数式接口就是仅仅定义了一个抽象方法，好比一开始把行为抽象成一个AppleFilter 接口，该接口只有一个filter() 方法。注意是只有一个抽象方法，并非只有一个方法，通俗来讲是继承该接口的类只须要实现一个方法。

最多见的两个接口是Comparator 和Runnable

后来为了更方便地区分函数式接口，Java新的API中多了一个@FuntionalInterface ，该注解仅仅是代表该类是函数式接口（并非必须的），若是有该注解的同时声明了两个抽象方法，那么将会报错

java.util.function下4个经常使用的函数式接口

java.util.function 下主要有4个经常使用的函数式接口，Function，Predicate，Consumer，Predicate ，随便截取其中的一个源码片断来看，其实也没啥好看的

对这些函数式接口也是得看接口是如何声明的，这里就拿Predicate 举例，该接口主要是对传进来的对象进行一个处理，而后返回boolean 值。是否是有点熟悉，没错，就是和筛选苹果同样

predicateDemo

public static List<Apple> predicateDemo(List<Apple> apples, Predicate<Apple> predicate) {
    List<Apple> res = new ArrayList<>();
    for (Apple apple : apples) {
        if (predicate.test(apple)) {
            res.add(apple);
        }
    }
    return res;
}

//调用
List<Apple> predicate = predicateDemo(apples, apple -> "green".equals(apple.getColor()));

其余的也是同理，上才艺

functionDemo

public static List<Integer> functionDemo(List<Integer> nums, Function<Integer, Integer> function) {
    List<Integer> res = new ArrayList<>();
    for (int num : nums) {
        res.add(function.apply(num));
    }
    return res;
}

//调用
List<Integer> function = functionDemo(Arrays.asList(1, 8, 7, 3, 9, 2), (num) -> num * 2);

consumerDemo

public static void consumerDemo(List<Integer> list, Consumer<Integer> consumer) {
    for (int num : list) {
        consumer.accept(num);
    }
}

//调用
consumerDemo(Arrays.asList(1, 5, 6), (num) -> System.out.println(num));
consumerDemo(Arrays.asList(1, 5, 6), System.out::println);

supplierDemo

public static void supplierDemo(List<Integer> nums, Supplier<String> supplier) {
    StringBuilder sb = new StringBuilder();
    for (int num : nums) {
        sb.append(num).append(supplier.get());
    }
    System.out.println(sb);
}

//调用
supplierDemo(Arrays.asList(1, 5, 6), ()->"java");

方法引用

上面的lambda写法是最精简的吗，不，不是的，还有最最最精简的写法，那就是利用方法引用

方法引用主要有3类：

指向静态方法的方法引用

Comparator<Integer> normalComparator = (a, b) -> a.compareTo(b);
Comparator<Integer> referenceComparator = Integer::compareTo;

指向任一类型实例方法的方法引用

Function<String, Integer> normalFunction = (str) -> str.length();
Function<String, Integer> referenceFunction = String::length;

BiPredicate<List<String>, String> normalPredicate = (strings, str) -> strings.contains(str);
BiPredicate<List<String>, String> referencePredicate = List::contains;

指向现有对象的实例方法引用

Apple apple = new Apple();
Supplier<Integer> normal = () -> apple.getWeight();
Supplier<Integer> reference = apple::getWeight;

固然也能够用于构造函数

Supplier<Apple> normalSupplier = () -> new Apple();
Supplier<Apple> referenceSupplier = Apple::new;

总结

以上就是java8中的lambda表达式，还有一些知识点是没有讲的，可是以为不是特别必须，好比类型推断是怎么推断的，还有Lambda复合，抛出异常，拆箱装箱一样没有讲。而后一些东西也不是全盘托出，须要各位小伙伴去idea中进入到源码观看。