转载

Lambda扩展与用途

JDK 1.8 API 包含了很多内置的函数式接口。其中就包括我们在老版本中经常见到的 Comparator 和 Runnable，Java 8 为他们都添加了 @FunctionalInterface 注解，以用来支持 Lambda 表达式。

值得一提的是，除了 Comparator 和 Runnable 外，还有一些新的函数式接口，它们很多都借鉴于知名的 Google Guava 库。

(1). Predicate 断言

Predicate 是一个可以指定入参类型，并返回 boolean 值的函数式接口。它内部提供了一些带有默认实现的方法，可以被用来组合一个复杂的逻辑判断（ and, or,negate）：

Predicate<String> predicate = (s) -> s.length() > 0;

    predicate.test("foo");              // true
    predicate.negate().test("foo");     // false

    Predicate<Boolean> nonNull = Objects::nonNull;
    Predicate<Boolean> isNull = Objects::isNull;

    Predicate<String> isEmpty = String::isEmpty;
    Predicate<String> isNotEmpty = isEmpty.negate();
复制代码

(2). Function

Function 函数式接口的作用是，我们可以为其提供一个原料，他给生产一个最终的产品。通过它提供的默认方法，组合,链行处理( compose, andThen)：

Function<String, Integer> toInteger = Integer::valueOf;
    Function<String, String> backToString = toInteger.andThen(String::valueOf);

    backToString.apply("123");     // "123"
复制代码

(3). Supplier 生产者

Supplier 与 Function 不同，它不接受入参，直接为我们生产一个指定的结果，有点像生产者模式：

class Person {
        String firstName;
        String lastName;

        Person() {}

        Person(String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        }
    }

    Supplier<Person> personSupplier = Person::new;
    personSupplier.get();   // new Person
复制代码

(4). Consumer 消费者

对于 Consumer，我们需要提供入参，用来被消费，如下面这段示例代码：

class Person {
        String firstName;
        String lastName;

        Person() {}

        Person(String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        }
    }


    Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
    greeter.accept(new Person("Luke", "Skywalker"));
复制代码

(5). Comparator

Comparator 在 Java 8 之前是使用比较普遍的。Java 8 中除了将其升级成了函数式接口，还为它拓展了一些默认方法：

Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);

    Person p1 = new Person("John", "Doe");
    Person p2 = new Person("Alice", "Wonderland");

    comparator.compare(p1, p2);             // > 0
    comparator.reversed().compare(p1, p2);  // < 0
复制代码

(6). Optional

首先， Optional 它不是一个函数式接口，设计它的目的是为了防止空指针异常（ NullPointerException），要知道在 Java 编程中，空指针异常可是臭名昭著的。
让我们来快速了解一下 Optional 要如何使用！你可以将 Optional 看做是包装对象（可能是 null, 也有可能非 null）的容器。当你定义了一个方法，这个方法返回的对象可能是空，也有可能非空的时候，你就可以考虑用 Optional 来包装它，这也是在 Java 8 被推荐使用的做法。

Optional<String> optional = Optional.of("bam");

    optional.isPresent();           // true
    optional.get();                 // "bam"
    optional.orElse("fallback");    // "bam"

    optional.ifPresent((s) -> System.out.println(s.charAt(0)));     // "b"
复制代码

2、Map 集合

前面已经提到过 Map 是不支持 Stream 流的，因为 Map 接口并没有像 Collection 接口那样，定义了 stream() 方法。但是，我们可以对其 key, values, entry 使用流操作，如 map.keySet().stream(), map.values().stream() 和 map.entrySet().stream().
另外, JDK 8 中对 map 提供了一些其他 新特性 :

Map<Integer, String> map = new HashMap<>();
    for (int i = 0; i < 10; i++) {
        // 与老版不同的是，putIfAbent() 方法在 put 之前，会判断 key 是否已经存在，
        //存在则直接返回 value, 否则 put, 再返回 value
        map.putIfAbsent(i, "val" + i);
    }

    // forEach 可以很方便地对 map 进行遍历操作
    map.forEach((key, value) -> System.out.println(value));
复制代码

除了上面的 putIfAbsent() 和 forEach() 外，还可以很方便地对某个 key 的值做相关操作：

// computeIfPresent(), 当 key 存在时，才会做相关处理  如下：对 key 为 3 的值，
    //内部会先判断值是否存在，存在，则做 value + key 的拼接操作
    map.computeIfPresent(3, (num, val) -> val + num);
    map.get(3);             // val33

    // 先判断 key 为 9 的元素是否存在，存在，则做删除操作
    map.computeIfPresent(9, (num, val) -> null);
    map.containsKey(9);     // false

    // computeIfAbsent(), 当 key 不存在时，才会做相关处理  如下：先判断 key 为 23 的元素是否存在，
    //不存在，则添加
    map.computeIfAbsent(23, num -> "val" + num);
    map.containsKey(23);    // true

    // 先判断 key 为 3 的元素是否存在，存在，则不做任何处理
    map.computeIfAbsent(3, num -> "bam");
    map.get(3);             // val33
复制代码

关于删除操作，JDK 8 中提供了能够新的 remove() API:

map.remove(3, "val3");
    map.get(3);             // val33

    map.remove(3, "val33");
    map.get(3);             // null
    
    如上代码，只有当给定的 key 和 value 完全匹配时，才会执行删除操作。
复制代码

关于添加方法，JDK 8 中提供了带有默认值的 getOrDefault() 方法：

// 若 key 42 不存在，则返回 not found
    map.getOrDefault(42, "not found");  // not found
复制代码

对于 value 的合并操作也变得更加简单：

// merge 方法，会先判断进行合并的 key 是否存在，不存在，则会添加元素
    map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
    map.get(9);             // val9

    // 若 key 的元素存在，则对 value 执行拼接操作
    map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
    map.get(9);             // val9concat
复制代码

作者：xxx
链接：xxx
来源：xxx
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
复制代码

3、Map 操作之 merge()

3.1、merge()用法

有一个学生成绩对象的列表，对象包含学生姓名、科目、科目分数三个属性，要求求得每个学生的总成绩。加入列表如下：

private List<StudentScore> buildATestList() {
    List<StudentScore> studentScoreList = new ArrayList<>();
    StudentScore studentScore1 = new StudentScore() {{
        setStuName("张三");
        setSubject("语文");
        setScore(70);
    }};
    StudentScore studentScore2 = new StudentScore() {{
        setStuName("张三");
        setSubject("数学");
        setScore(80);
    }};
    StudentScore studentScore3 = new StudentScore() {{
        setStuName("张三");
        setSubject("英语");
        setScore(65);
    }};
    StudentScore studentScore4 = new StudentScore() {{
        setStuName("李四");
        setSubject("语文");
        setScore(68);
    }};
    StudentScore studentScore5 = new StudentScore() {{
        setStuName("李四");
        setSubject("数学");
        setScore(70);
    }};
    StudentScore studentScore6 = new StudentScore() {{
        setStuName("李四");
        setSubject("英语");
        setScore(90);
    }};
    StudentScore studentScore7 = new StudentScore() {{
        setStuName("王五");
        setSubject("语文");
        setScore(80);
    }};
    StudentScore studentScore8 = new StudentScore() {{
        setStuName("王五");
        setSubject("数学");
        setScore(85);
    }};
    StudentScore studentScore9 = new StudentScore() {{
        setStuName("王五");
        setSubject("英语");
        setScore(70);
    }};

    studentScoreList.add(studentScore1);
    studentScoreList.add(studentScore2);
    studentScoreList.add(studentScore3);
    studentScoreList.add(studentScore4);
    studentScoreList.add(studentScore5);
    studentScoreList.add(studentScore6);
    studentScoreList.add(studentScore7);
    studentScoreList.add(studentScore8);
    studentScoreList.add(studentScore9);

    return studentScoreList;
}

===================常规做法===================
    ObjectMapper objectMapper = new ObjectMapper();
    List<StudentScore> studentScoreList = buildATestList();

    Map<String, Integer> studentScoreMap = new HashMap<>();
    studentScoreList.forEach(studentScore -> {
        if (studentScoreMap.containsKey(studentScore.getStuName())) {
            studentScoreMap.put(studentScore.getStuName(), 
                studentScoreMap.get(studentScore.getStuName()) + studentScore.getScore());
        } else {
            studentScoreMap.put(studentScore.getStuName(), studentScore.getScore());
        }
    });

    System.out.println(objectMapper.writeValueAsString(studentScoreMap));
    // 结果如下：{"李四":228,"张三":215,"王五":235}
    
===================merge()做法===================
    Map<String, Integer> studentScoreMap2 = new HashMap<>();
    studentScoreList.forEach(studentScore -> studentScoreMap2.merge(
        studentScore.getStuName(),
        studentScore.getScore(),
        Integer::sum));

    System.out.println(objectMapper.writeValueAsString(studentScoreMap2));
    // 结果如下：{"李四":228,"张三":215,"王五":235}
复制代码

3.2、merge()简介

merge() 可以这么理解：它将新的值赋值到 key （如果不存在）或更新给定的key 值对应的 value，其源码如下：

default V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) 
{
    Objects.requireNonNull(remappingFunction);
    Objects.requireNonNull(value);
    V oldValue = this.get(key);
    V newValue = oldValue == null ? value : remappingFunction.apply(oldValue, value);
    if (newValue == null) {
        this.remove(key);
    } else {
        this.put(key, newValue);
    }

    return newValue;
}

我们可以看到原理也是很简单的，该方法接收三个参数，
一个 key 值，一个 value，一个 remappingFunction ，
如果给定的key不存在，它就变成了 put(key, value) 。
如果 key 已经存在一些值，我们 remappingFunction 可以选择合并的方式，
    然后将合并得到的 newValue 赋值给原先的 key。
复制代码

3.2、使用场景

这个使用场景相对来说还是比较多的，比如分组求和这类的操作，虽然 stream 中有相关 groupingBy() 方法，但如果你想在循环中做一些其他操作的时候，merge() 还是一个挺不错的选择的。

3.3、其他

除了 merge() 方法之外，我还看到了一些Java 8 中 map 相关的其他方法，比如 putIfAbsent 、compute() 、computeIfAbsent() 、computeIfPresent，这些方法我们看名字应该就知道是什么意思了，故此处就不做过多介绍了，感兴趣的可以简单阅读一下源码（都还是挺易懂的），这里我们贴一下 compute()(Map.class) 的源码，其返回值是计算后得到的新值：

default V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
    Objects.requireNonNull(remappingFunction);
    V oldValue = this.get(key);
    V newValue = remappingFunction.apply(key, oldValue);
    if (newValue == null) {
        if (oldValue == null && !this.containsKey(key)) {
            return null;
        } else {
            this.remove(key);
            return null;
        }
    } else {
        this.put(key, newValue);
        return newValue;
    }
}
复制代码

3.4、总结

本文简单介绍了一下 Map.merge() 的方法，除此之外，Java 8 中的 HashMap 实现方法使用了 TreeNode 和红黑树，在源码阅读上可能有一点难度，不过原理上还是相似的，compute() 同理。所以，源码肯定是要看的，不懂的地方多读多练自然就理解了。

参考：https://www.jianshu.com/p/68e6b30410b0

代码地址：https://github.com/lq920320/algorithm-java-test/blob/master/src/test/java/other/MapMethodsTest.java
复制代码

作者：LQ木头
链接：juejin.im/post/5d9b455ae51d45782b0c1bfb
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
复制代码

原文 https://juejin.im/post/5da411bf6fb9a04e4126b935

正文到此结束

所属分类：编程技术 Java

本文标签： 学生代码 consumer IO GitHub 总结 mapper https Google 参数 ACE stream git API list 删除 lambda node UI value http ArrayList 源码 map key core HashMap java cat 遍历 src Master 产品 App build Collection
版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
本文海报： 生成海报一生成海报二

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

Lambda扩展与用途

(1). Predicate 断言

(2). Function

(3). Supplier 生产者

(4). Consumer 消费者

(5). Comparator

(6). Optional

2、Map 集合

3、Map 操作之 merge()

3.1、merge()用法

3.2、merge()简介

3.2、使用场景

3.3、其他

3.4、总结

热门推荐

相关文章

说给你听

本文目录

随机标签

书籍教程

近期评论

网站信息

其他链接

关于本站

问题交流