java lamda表达式超详细常见使用技巧

一时失言乱红尘 2023-06-16 14:55 10阅读 0赞

Java8为容器新增一些有用的方法，这些方法有些是为完善原有功能，有些是为引入函数式编程（Lambda表达式），学习和使用这些方法有助于我们写出更加简洁有效的代码．本文分别以ArrayList和HashMap为例，讲解Java8集合框架（Java Collections Framework）中新加入方法的使用．

定义对象：

public class Apple {
        private Integer id;
        private String name;
        private BigDecimal money;
        private Integer num;
        public Apple(Integer id, String name, BigDecimal money, Integer num) {
            this.id = id;
            this.name = name;
            this.money = money;
            this.num = num;
        }
    }
    
    测试数据
    
    List<Apple> appleList = new ArrayList<>();//存放apple对象集合
     
    Apple apple1 =  new Apple(1,"苹果1",new BigDecimal("3.25"),10);
    Apple apple12 = new Apple(1,"苹果2",new BigDecimal("1.35"),20);
    Apple apple2 =  new Apple(2,"香蕉",new BigDecimal("2.89"),30);
    Apple apple3 =  new Apple(3,"荔枝",new BigDecimal("9.99"),40);
     
    appleList.add(apple1);
    appleList.add(apple12);
    appleList.add(apple2);
    appleList.add(apple3);

1、分组

List里面的对象元素，以某个属性来分组，例如，以id分组，将id相同的放在一起：

//List 以ID分组 Map<Integer,List<Apple>>

Map<Integer, List<Apple>> groupBy = appleList.stream().collect(Collectors.groupingBy(Apple::getId));

System.err.println("groupBy:"+groupBy);
    {1=[Apple{id=1, name='苹果1', money=3.25, num=10}, Apple{id=1, name='苹果2', money=1.35, num=20}], 2=[Apple{id=2, name='香蕉', money=2.89, num=30}], 3=[Apple{id=3, name='荔枝', money=9.99, num=40}]}

2、List转Map

id为key，apple对象为value

/**
     * List -> Map
     * 需要注意的是：
     * toMap 如果集合对象有重复的key，会报错Duplicate key ....
     *  apple1,apple12的id都为1。
     *  可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
     */
    
    
    Map<Integer, Apple> appleMap = appleList.stream().collect(Collectors.toMap(Apple::getId, a -> a,(k1,k2)->k1));

打印：
    
    {1=Apple{id=1, name='苹果1', money=3.25, num=10}, 2=Apple{id=2, name='香蕉', money=2.89, num=30}, 3=Apple{id=3, name='荔枝', money=9.99, num=40}}

**List转Map按key去重 重复key 值处理**

Map<String, ObjectBasicBO> result =
                    Optional.ofNullable(list).get().stream().collect(
                        Collectors.toMap(ObjectBasicBO::getValue, Function.identity(), (old, key2) -> key2));

** List去重**

数据：
    
            BookBo bookBo1 = new BookBo("1", "语文");
            BookBo bookBo2 = new BookBo("2", "数学");
            BookBo bookBo3 = new BookBo("3", "英语");
            BookBo bookBo4 = new BookBo("4", "地理");
            BookBo bookBo5 = new BookBo("5", "生物");
            BookBo bookBo6 = new BookBo("1", "语文");
            List<BookBo> bookBoList = Arrays.asList(bookBo1, bookBo2, bookBo3, bookBo4, bookBo5, bookBo6);

List<BookBo> distinctList = bookBoList
                    //collectingAndThen收集然后在
                    .stream().collect(Collectors.collectingAndThen(Collectors.toCollection(()->new TreeSet<>(Comparator.comparing(o-> o.getName()))), ArrayList::new))
                    .stream().sorted(Comparator.comparing(BookBo::getName)).collect(Collectors.toList());

3、过滤Filter

从集合中过滤出来符合条件的元素：

//过滤出符合条件的数据
    
    
    List<Apple> filterList = appleList.stream().filter(a -> a.getName().equals("香蕉")).collect(Collectors.toList());
    
    
     
    System.err.println("filterList:"+filterList);
    [Apple{id=2, name='香蕉', money=2.89, num=30}]

4.求和

将集合中的数据按照某个属性求和:

//计算 总金额
    
    BigDecimal totalMoney = appleList.stream().map(Apple::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
    
    
    System.err.println("totalMoney:"+totalMoney);  //totalMoney:17.48

5.查找流中最大 最小值

Collectors.maxBy 和 Collectors.minBy 来计算流中的最大或最小值。

Optional<Dish> maxDish = Dish.menu.stream().
          collect(Collectors.maxBy(Comparator.comparing(Dish::getCalories)));
    
    
    maxDish.ifPresent(System.out::println);
    
    
     
    Optional<Dish> minDish = Dish.menu.stream().
          collect(Collectors.minBy(Comparator.comparing(Dish::getCalories)));
    
    
    minDish.ifPresent(System.out::println);

6.去重

import static java.util.Comparator.comparingLong;
    import static java.util.stream.Collectors.collectingAndThen;
    import static java.util.stream.Collectors.toCollection;
    
     
    // 根据id去重
         List<Person> unique = appleList.stream().collect(
                    collectingAndThen(
                            toCollection(() -> new TreeSet<>(comparingLong(Apple::getId))), ArrayList::new)
            );

多字段拼接去重

List<ClassEntity> distinctClass = classEntities.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.getProfessionId() + ";" + o.getGrade()))), ArrayList::new));

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly96eWM4OC5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70][]

7、 [java8 stream多字段排序][java8 stream]

很多情况下sql不好解决的多表查询,临时表分组,排序,尽量用java8新特性stream进行处理

>     List<类> list; 代表某集合
>      
>     //返回 对象集合以类属性一升序排序 
>     list.stream().sorted(Comparator.comparing(类::属性一));
>      
>     //返回 对象集合以类属性一降序排序 注意两种写法 
>     list.stream().sorted(Comparator.comparing(类::属性一).reversed());
>     
>     //先以属性一升序,结果进行属性一降序 
>     list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()));
>     以属性一降序
>      
>     //返回 对象集合以类属性一升序 属性二升序 
>     list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));
>      
>     //返回 对象集合以类属性一降序 属性二升序 注意两种写法 
>     list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));
>     先以属性一升序,升序结果进行属性一降序,再进行属性二升序
>      
>     list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));//先以属性一降序,再进行属性二升序
>      
>     //返回 对象集合以类属性一降序 属性二降序 注意两种写法 
>     list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));
>     先以属性一升序,升序结果进行属性一降序,再进行属性二降序
>      
>     list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));
>     先以属性一降序,再进行属性二降序
>      
>     //返回 对象集合以类属性一升序 属性二降序 注意两种写法 
>     list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());
>     先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序
>      
>     list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));
>     先以属性一升序,再进行属性二降序
> 
> 通过以上例子我们可以发现
> 
> 1. Comparator.comparing(类::属性一).reversed();
> 
> 2. Comparator.comparing(类::属性一,Comparator.reverseOrder());
> 
> 两种排序是完全不一样的,一定要区分开来 1 是得到排序结果后再排序,2是直接进行排序,很多人会混淆导致理解出错,2更好理解,建议使用2

实际例子:

现有一个类test 有两个属性:state 状态 time 时间,需要状态顺序且时间倒序

class test {
        //状态
        private int state;
        //时间
        private Date time;
     
        public test(int state, Date time) {
            this.state = state;
            this.time = time;
        }
     
        public int getState() {
            return state;
        }
     
        public void setState(int state) {
            this.state = state;
        }
     
        public Date getTime() {
            return time;
        }
     
        public void setTime(Date time) {
            this.time = time;
        }
     
        @Override
        public String toString() {
            return "test{" +
                    "state=" + state +
                    ", time=" + DateUtils.formatDateYMD(time) +
                    '}';
        }
    }

class testRun {
        public static void main(String[] args) {
            List<test> testList = new ArrayList<>();
            Date d = DateUtils.now();
            for (int i = 1; i <= 3; i++) {
                test t = new test(i, DateUtils.addDays(d, i));
                testList.add(t);
            }
            for (int i = 1; i <= 3; i++) {
                test t = new test(i, DateUtils.addMonths(d, i));
                testList.add(t);
            }
     
            testList.forEach(o -> {
                System.out.println(o.toString());
            });
            List<test> sort = testList.stream().sorted(Comparator.comparing(test::getState).thenComparing(test::getTime,Comparator.reverseOrder())).collect(toList());
            System.out.println("------------------------------------");
            sort.forEach(o -> {
                System.out.println(o.toString());
            });
     
     
        }
    }

运行结果:

>  
> 
> `排序前:`
> 
> `test{state=``1``, time=``2019``-``07``-``24``}`
> 
> `test{state=``2``, time=``2019``-``07``-``25``}`
> 
> `test{state=``3``, time=``2019``-``07``-``26``}`
> 
> `test{state=``1``, time=``2019``-``08``-``23``}`
> 
> `test{state=``2``, time=``2019``-``09``-``23``}`
> 
> `test{state=``3``, time=``2019``-``10``-``23``}`
> 
> `------------------------------------`
> 
> `排序后:`
> 
> `test{state=``1``, time=``2019``-``08``-``23``}`
> 
> `test{state=``1``, time=``2019``-``07``-``24``}`
> 
> `test{state=``2``, time=``2019``-``09``-``23``}`
> 
> `test{state=``2``, time=``2019``-``07``-``25``}`
> 
> `test{state=``3``, time=``2019``-``10``-``23``}`
> 
> `test{state=``3``, time=``2019``-``07``-``26}`
> 
> `Process finished with exit code ``0`

===============================概念介绍如下==========================================

## 前言 ##

我们先从最熟悉的[Java集合框架(Java Collections Framework, JCF)][Java_Java Collections Framework_ JCF]开始说起。

为引入Lambda表达式，Java8新增了`java.util.funcion`包，里面包含常用的**函数接口**，这是Lambda表达式的基础，Java集合框架也新增部分接口，以便与Lambda表达式对接。

首先回顾一下Java集合框架的接口继承结构：

![JCF\_Collection\_Interfaces][JCF_Collection_Interfaces]

上图中绿色标注的接口类，表示在Java8中加入了新的接口方法，当然由于继承关系，他们相应的子类也都会继承这些新方法。下表详细列举了这些方法。

<table> 
 <thead> 
  <tr> 
   <th>接口名</th> 
   <th>Java8新加入的方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Collection</td> 
   <td>removeIf() spliterator() stream() parallelStream() forEach()</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>replaceAll() sort()</td> 
  </tr> 
  <tr> 
   <td>Map</td> 
   <td>getOrDefault() forEach() replaceAll() putIfAbsent() remove() replace() computeIfAbsent() computeIfPresent() compute() merge()</td> 
  </tr> 
 </tbody> 
</table>

这些新加入的方法大部分要用到`java.util.function`包下的接口，这意味着这些方法大部分都跟Lambda表达式相关。我们将逐一学习这些方法。

## Collection中的新方法 ##

如上所示，接口`Collection`和`List`新加入了一些方法，我们以是`List`的子类`ArrayList`为例来说明。了解[Java7`ArrayList`实现原理][Java7_ArrayList]，将有助于理解下文。

### forEach() ###

该方法的签名为`void forEach(Consumer<? super E> action)`，作用是对容器中的每个元素执行`action`指定的动作，其中`Consumer`是个函数接口，里面只有一个待实现方法`void accept(T t)`（后面我们会看到，这个方法叫什么根本不重要，你甚至不需要记忆它的名字）。

需求：*假设有一个字符串列表，需要打印出其中所有长度大于3的字符串.*

Java7及以前我们可以用增强的for循环实现：

// 使用曾强for循环迭代
    ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too"));
    for(String str : list){
        if(str.length()>3)
            System.out.println(str);
    }

现在使用`forEach()`方法结合匿名内部类，可以这样实现：

// 使用forEach()结合匿名内部类迭代
    ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too"));
    list.forEach(new Consumer<String>(){
        @Override
        public void accept(String str){
            if(str.length()>3)
                System.out.println(str);
        }
    });

上述代码调用`forEach()`方法，并使用匿名内部类实现`Comsumer`接口。到目前为止我们没看到这种设计有什么好处，但是不要忘记Lambda表达式，使用Lambda表达式实现如下：

// 使用forEach()结合Lambda表达式迭代
    ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too"));
    list.forEach( str -> {
            if(str.length()>3)
                System.out.println(str);
        });

上述代码给`forEach()`方法传入一个Lambda表达式，我们不需要知道`accept()`方法，也不需要知道`Consumer`接口，类型推导帮我们做了一切。

### removeIf() ###

该方法签名为`boolean removeIf(Predicate<? super E> filter)`，作用是**删除容器中所有满足`filter`指定条件的元素**，其中`Predicate`是一个函数接口，里面只有一个待实现方法`boolean test(T t)`，同样的这个方法的名字根本不重要，因为用的时候不需要书写这个名字。

需求：*假设有一个字符串列表，需要删除其中所有长度大于3的字符串。*

我们知道如果需要在迭代过程冲对容器进行删除操作必须使用迭代器，否则会抛出`ConcurrentModificationException`，所以上述任务传统的写法是：

// 使用迭代器删除列表元素
    ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too"));
    Iterator<String> it = list.iterator();
    while(it.hasNext()){
        if(it.next().length()>3) // 删除长度大于3的元素
            it.remove();
    }

现在使用`removeIf()`方法结合匿名内部类，我们可是这样实现：

// 使用removeIf()结合匿名名内部类实现
    ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too"));
    list.removeIf(new Predicate<String>(){ // 删除长度大于3的元素
        @Override
        public boolean test(String str){
            return str.length()>3;
        }
    });

上述代码使用`removeIf()`方法，并使用匿名内部类实现`Precicate`接口。相信你已经想到用Lambda表达式该怎么写了：

// 使用removeIf()结合Lambda表达式实现
    ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too"));
    list.removeIf(str -> str.length()>3); // 删除长度大于3的元素

使用Lambda表达式不需要记忆`Predicate`接口名，也不需要记忆`test()`方法名，只需要知道此处需要一个返回布尔类型的Lambda表达式就行了。

### replaceAll() ###

该方法签名为`void replaceAll(UnaryOperator<E> operator)`，作用是**对每个元素执行`operator`指定的操作，并用操作结果来替换原来的元素**。其中`UnaryOperator`是一个函数接口，里面只有一个待实现函数`T apply(T t)`。

需求：*假设有一个字符串列表，将其中所有长度大于3的元素转换成大写，其余元素不变。*

Java7及之前似乎没有优雅的办法：

// 使用下标实现元素替换
    ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too"));
    for(int i=0; i<list.size(); i++){
        String str = list.get(i);
        if(str.length()>3)
            list.set(i, str.toUpperCase());
    }

使用`replaceAll()`方法结合匿名内部类可以实现如下：

// 使用匿名内部类实现
    ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too"));
    list.replaceAll(new UnaryOperator<String>(){
        @Override
        public String apply(String str){
            if(str.length()>3)
                return str.toUpperCase();
            return str;
        }
    });

上述代码调用`replaceAll()`方法，并使用匿名内部类实现`UnaryOperator`接口。我们知道可以用更为简洁的Lambda表达式实现：

// 使用Lambda表达式实现
    ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too"));
    list.replaceAll(str -> {
        if(str.length()>3)
            return str.toUpperCase();
        return str;
    });

### sort() ###

该方法定义在`List`接口中，方法签名为`void sort(Comparator<? super E> c)`，该方法**根据`c`指定的比较规则对容器元素进行排序**。`Comparator`接口我们并不陌生，其中有一个方法`int compare(T o1, T o2)`需要实现，显然该接口是个函数接口。

需求：*假设有一个字符串列表，按照字符串长度增序对元素排序。*

由于Java7以及之前`sort()`方法在`Collections`工具类中，所以代码要这样写：

// Collections.sort()方法
    ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too"));
    Collections.sort(list, new Comparator<String>(){
        @Override
        public int compare(String str1, String str2){
            return str1.length()-str2.length();
        }
    });

现在可以直接使用`List.sort()方法`，结合Lambda表达式，可以这样写：

// List.sort()方法结合Lambda表达式
    ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you", "too"));
    list.sort((str1, str2) -> str1.length()-str2.length());

### spliterator() ###

方法签名为`Spliterator<E> spliterator()`，该方法返回容器的**可拆分迭代器**。从名字来看该方法跟`iterator()`方法有点像，我们知道`Iterator`是用来迭代容器的，`Spliterator`也有类似作用，但二者有如下不同：

1.  `Spliterator`既可以像`Iterator`那样逐个迭代，也可以批量迭代。批量迭代可以降低迭代的开销。
2.  `Spliterator`是可拆分的，一个`Spliterator`可以通过调用`Spliterator<T> trySplit()`方法来尝试分成两个。一个是`this`，另一个是新返回的那个，这两个迭代器代表的元素没有重叠。

可通过（多次）调用`Spliterator.trySplit()`方法来分解负载，以便多线程处理。

### stream()和parallelStream() ###

`stream()`和`parallelStream()`分别**返回该容器的`Stream`视图表示**，不同之处在于`parallelStream()`返回并行的`Stream`。**`Stream`是Java函数式编程的核心类**，我们会在后面章节中学习。

## Map中的新方法 ##

相比`Collection`，`Map`中加入了更多的方法，我们以`HashMap`为例来逐一探秘。了解[Java7`HashMap`实现原理][Java7_HashMap]，将有助于理解下文。

### forEach() ###

该方法签名为`void forEach(BiConsumer<? super K,? super V> action)`，作用是**对`Map`中的每个映射执行`action`指定的操作**，其中`BiConsumer`是一个函数接口，里面有一个待实现方法`void accept(T t, U u)`。`BinConsumer`接口名字和`accept()`方法名字都不重要，请不要记忆他们。

需求：*假设有一个数字到对应英文单词的Map，请输出Map中的所有映射关系．*

Java7以及之前经典的代码如下：

// Java7以及之前迭代Map
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "one");
    map.put(2, "two");
    map.put(3, "three");
    for(Map.Entry<Integer, String> entry : map.entrySet()){
        System.out.println(entry.getKey() + "=" + entry.getValue());
    }

使用`Map.forEach()`方法，结合匿名内部类，代码如下：

// 使用forEach()结合匿名内部类迭代Map
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "one");
    map.put(2, "two");
    map.put(3, "three");
    map.forEach(new BiConsumer<Integer, String>(){
        @Override
        public void accept(Integer k, String v){
            System.out.println(k + "=" + v);
        }
    });

上述代码调用`forEach()`方法，并使用匿名内部类实现`BiConsumer`接口。当然，实际场景中没人使用匿名内部类写法，因为有Lambda表达式：

// 使用forEach()结合Lambda表达式迭代Map
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "one");
    map.put(2, "two");
    map.put(3, "three");
    map.forEach((k, v) -> System.out.println(k + "=" + v));
    }

### getOrDefault() ###

该方法跟Lambda表达式没关系，但是很有用。方法签名为`V getOrDefault(Object key, V defaultValue)`，作用是**按照给定的`key`查询`Map`中对应的`value`，如果没有找到则返回`defaultValue`**。使用该方法程序员可以省去查询指定键值是否存在的麻烦．

需求；*假设有一个数字到对应英文单词的Map，输出4对应的英文单词，如果不存在则输出NoValue*

// 查询Map中指定的值，不存在时使用默认值
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "one");
    map.put(2, "two");
    map.put(3, "three");
    // Java7以及之前做法
    if(map.containsKey(4)){ // 1
        System.out.println(map.get(4));
    }else{
        System.out.println("NoValue");
    }
    // Java8使用Map.getOrDefault()
    System.out.println(map.getOrDefault(4, "NoValue")); // 2

### putIfAbsent() ###

该方法跟Lambda表达式没关系，但是很有用。方法签名为`V putIfAbsent(K key, V value)`，作用是只有在**不存在`key`值的映射或映射值为`null`时**，才将`value`指定的值放入到`Map`中，否则不对`Map`做更改．该方法将条件判断和赋值合二为一，使用起来更加方便．

### remove() ###

我们都知道`Map`中有一个`remove(Object key)`方法，来根据指定`key`值删除`Map`中的映射关系；Java8新增了`remove(Object key, Object value)`方法，只有在当前`Map`中**`key`正好映射到`value`时**才删除该映射，否则什么也不做．

### replace() ###

在Java7及以前，要想替换`Map`中的映射关系可通过`put(K key, V value)`方法实现，该方法总是会用新值替换原来的值．为了更精确的控制替换行为，Java8在`Map`中加入了两个`replace()`方法，分别如下：

*  `replace(K key, V value)`，只有在当前`Map`中**`key`的映射存在时**才用`value`去替换原来的值，否则什么也不做．
 *  `replace(K key, V oldValue, V newValue)`，只有在当前`Map`中**`key`的映射存在且等于`oldValue`时**才用`newValue`去替换原来的值，否则什么也不做．

### replaceAll() ###

该方法签名为`replaceAll(BiFunction<? super K,? super V,? extends V> function)`，作用是对`Map`中的每个映射执行`function`指定的操作，并用`function`的执行结果替换原来的`value`，其中`BiFunction`是一个函数接口，里面有一个待实现方法`R apply(T t, U u)`．不要被如此多的函数接口吓到，因为使用的时候根本不需要知道他们的名字．

需求：*假设有一个数字到对应英文单词的Map，请将原来映射关系中的单词都转换成大写．*

Java7以及之前经典的代码如下：

// Java7以及之前替换所有Map中所有映射关系
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "one");
    map.put(2, "two");
    map.put(3, "three");
    for(Map.Entry<Integer, String> entry : map.entrySet()){
        entry.setValue(entry.getValue().toUpperCase());
    }

使用`replaceAll()`方法结合匿名内部类，实现如下：

// 使用replaceAll()结合匿名内部类实现
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "one");
    map.put(2, "two");
    map.put(3, "three");
    map.replaceAll(new BiFunction<Integer, String, String>(){
        @Override
        public String apply(Integer k, String v){
            return v.toUpperCase();
        }
    });

上述代码调用`replaceAll()`方法，并使用匿名内部类实现`BiFunction`接口。更进一步的，使用Lambda表达式实现如下：

// 使用replaceAll()结合Lambda表达式实现
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "one");
    map.put(2, "two");
    map.put(3, "three");
    map.replaceAll((k, v) -> v.toUpperCase());

简洁到让人难以置信．

### merge() ###

该方法签名为`merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)`，作用是：

1.  如果`Map`中`key`对应的映射不存在或者为`null`，则将`value`（不能是`null`）关联到`key`上；
2.  否则执行`remappingFunction`，如果执行结果非`null`则用该结果跟`key`关联，否则在`Map`中删除`key`的映射．

参数中`BiFunction`函数接口前面已经介绍过，里面有一个待实现方法`R apply(T t, U u)`．

`merge()`方法虽然语义有些复杂，但该方法的用方式很明确，一个比较常见的场景是将新的错误信息拼接到原来的信息上，比如：

map.merge(key, newMsg, (v1, v2) -> v1+v2);

### compute() ###

该方法签名为`compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)`，作用是把`remappingFunction`的计算结果关联到`key`上，如果计算结果为`null`，则在`Map`中删除`key`的映射．

要实现上述`merge()`方法中错误信息拼接的例子，使用`compute()`代码如下：

map.compute(key, (k,v) -> v==null ? newMsg : v.concat(newMsg));

### computeIfAbsent() ###

该方法签名为`V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)`，作用是：只有在当前`Map`中**不存在`key`值的映射或映射值为`null`时**，才调用`mappingFunction`，并在`mappingFunction`执行结果非`null`时，将结果跟`key`关联．

`Function`是一个函数接口，里面有一个待实现方法`R apply(T t)`．

`computeIfAbsent()`常用来对`Map`的某个`key`值建立初始化映射．比如我们要实现一个多值映射，`Map`的定义可能是`Map<K,Set<V>>`，要向`Map`中放入新值，可通过如下代码实现：

Map<Integer, Set<String>> map = new HashMap<>();
    // Java7及以前的实现方式
    if(map.containsKey(1)){
        map.get(1).add("one");
    }else{
        Set<String> valueSet = new HashSet<String>();
        valueSet.add("one");
        map.put(1, valueSet);
    }
    // Java8的实现方式
    map.computeIfAbsent(1, v -> new HashSet<String>()).add("yi");

使用`computeIfAbsent()`将条件判断和添加操作合二为一，使代码更加简洁．

### computeIfPresent() ###

该方法签名为`V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)`，作用跟`computeIfAbsent()`相反，即，只有在当前`Map`中**存在`key`值的映射且非`null`时**，才调用`remappingFunction`，如果`remappingFunction`执行结果为`null`，则删除`key`的映射，否则使用该结果替换`key`原来的映射．

这个函数的功能跟如下代码是等效的：

// Java7及以前跟computeIfPresent()等效的代码
    if (map.get(key) != null) {
        V oldValue = map.get(key);
        V newValue = remappingFunction.apply(key, oldValue);
        if (newValue != null)
            map.put(key, newValue);
        else
            map.remove(key);
        return newValue;
    }
    return null;

## 总结 ##

1.  Java8为容器新增一些有用的方法，这些方法有些是为**完善原有功能**，有些是为**引入函数式编程**，学习和使用这些方法有助于我们写出更加简洁有效的代码．
2.  **函数接口**虽然很多，但绝大多数时候我们根本不需要知道它们的名字，书写Lambda表达式时类型推断帮我们做了一切．

[本文github地址][github]

[https://github.com/CarpenterLee][https_github.com_CarpenterLee]

[https://github.com/CarpenterLee/JavaLambdaInternals][https_github.com_CarpenterLee_JavaLambdaInternals]

参考：

[https://blog.csdn.net/lu930124/article/details/77595585][https_blog.csdn.net_lu930124_article_details_77595585]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly96eWM4OC5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191126213048224.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly96eWM4OC5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[java8 stream]: https://www.cnblogs.com/kuanglongblogs/p/11230250.html
[Java_Java Collections Framework_ JCF]: https://github.com/CarpenterLee/JCFInternals
[JCF_Collection_Interfaces]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWFnZXMyMDE1LmNuYmxvZ3MuY29tL2Jsb2cvOTM5OTk4LzIwMTcwMy85Mzk5OTgtMjAxNzAzMDUyMjE0Mjk5NzAtMTY1MzU0NjQzNi5wbmc?x-oss-process=image/format,png
[Java7_ArrayList]: https://github.com/CarpenterLee/JCFInternals/blob/master/markdown/2-ArrayList.md
[Java7_HashMap]: https://github.com/CarpenterLee/JCFInternals/blob/master/markdown/6-HashSet%20and%20HashMap.md
[github]: https://github.com/CarpenterLee/JavaLambdaInternals/blob/master/3-Lambda%20and%20Collections.md
[https_github.com_CarpenterLee]: https://github.com/CarpenterLee
[https_github.com_CarpenterLee_JavaLambdaInternals]: https://github.com/CarpenterLee/JavaLambdaInternals
[https_blog.csdn.net_lu930124_article_details_77595585]: https://blog.csdn.net/lu930124/article/details/77595585