Java8常用示例

java.util.Map中的putIfAbsent、computeIfAbsent、computeIfPresent、compute的区别

HashMap

putIfAbsent

default V putIfAbsent(K key,V value)

If the specified key is not already associated with a value (or is mapped to null) associates it with the given value and returns null, else returns the current value

上面是官方的解释，意思是如果给定的key不存在（或者key对应的value为null），关联给定的key和给定的value，并返回null；

如果存在，返回当前值（不会把value放进去）；

　　　　 Map<Integer, List<Integer>> map = new HashMap<>();
        map.put(2, Lists.newArrayList(22));
        List<Integer> xx = map.putIfAbsent(2, Lists.newArrayList(1));
        System.out.println(map + " " + xx);//返回：{2=[22]} [22]
 
        map.clear();
        xx = map.putIfAbsent(1, Lists.newArrayList(1));
        System.out.println(map + " " + xx);//返回：{1=[1]} null

computeIfAbsent

default V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
If the specified key is not already associated with a value (or is mapped to null), attempts to compute its value using the given mapping function and enters it into this map unless null.

If the function returns null no mapping is recorded. If the function itself throws an (unchecked) exception, the exception is rethrown, and no mapping is recorded. The most common usage is to construct a new object serving as an initial mapped value or memoized result, as in:

map.computeIfAbsent(key, k -> new Value(f(k)));
Or to implement a multi-value map, Map<K,Collection<V>>, supporting multiple values per key:

map.computeIfAbsent(key, k -> new HashSet<V>()).add(v);

官方文档的解释：如果给定的key不存在（或者key对应的value为null），就去计算mappingFunction的值；

如果mappingFunction的值不为null，就把key=value放进去；
如果mappingFunction的值为null，就不会记录该映射关系，返回值为null；
如果计算mappingFunction的值的过程出现异常，再次抛出异常，不记录映射关系，返回null；
如果存在该key，并且key对应的value不为null，返回null；（HashMap返回的是旧value）

　　　　 Map<Integer, List<Integer>> map = new HashMap<>();
        map.put(2, Lists.newArrayList(22));
        List<Integer> xx = map.computeIfAbsent(2, k -> new ArrayList<>());
        System.out.println(map + " " + xx);//返回：{2=[22]} [22] key存在，得到旧值并返回
        xx.add(222);
        System.out.println(map + " " + xx);//返回：{2=[22, 222]} [22, 222]
 
        map.clear();
        xx = map.computeIfAbsent(1, k -> new ArrayList<>());
        System.out.println(map + " " + xx);//返回：{1=[]} [] key不存在，计算后面的表达式并返回
        xx.add(1);
        System.out.println(map + " " + xx);//返回：{1=[1]} [1]

computeIfPresent

default V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
If the value for the specified key is present and non-null, attempts to compute a new mapping given the key and its current mapped value.

If the function returns null, the mapping is removed. If the function itself throws an (unchecked) exception, the exception is rethrown, and the current mapping is left unchanged.

官方文档的解释：key存在并且不为空，计算remappingFunction的值value；

如果value不为空，保存指定key和value的映射关系；
如果value为null，remove（key）；
如果计算value的过程抛出了异常，computeIfPresent方法中会再次抛出，key和其对应的值不会改变

　　　　 Map<Integer, List<Integer>> map = new HashMap<>();
        map.put(2, Lists.newArrayList(22));
        List<Integer> xx = map.computeIfPresent(2, (k, v) -> {
            v.add(222);
            return v;
        });
        System.out.println(map + " " + xx);//返回：{2=[22, 222]} [22, 222] 当key存在，插入新value并返回
 
        xx = map.computeIfPresent(2, (k, v) -> {
            return null;
        });
        System.out.println(map + " " + xx);//返回：{} null 当key存在，插入value=null，remove key并返回null
 
        map.clear();
        xx = map.computeIfPresent(2, (k, v) -> {
            v.add(222);
            return v;
        });
        System.out.println(map + " " + xx);//返回：{} null 当key不存在，不插入新value，返回null

compute

V oldValue = map.get(key);
 V newValue = remappingFunction.apply(key, oldValue);
 if (oldValue != null ) {
    if (newValue != null)
       map.put(key, newValue);
    else
       map.remove(key);
 } else {
    if (newValue != null)
       map.put(key, newValue);
    else
       return null;
 }

和这段代码意思一样。

官方文档：如果lambda表达式的值不为空，不论key是否已经存在，建立一种映射关系key=newValue;否则，不建立映射并返回null。

　　　　 Map<Integer, List<Integer>> map = new HashMap<>();
        map.put(2, Lists.newArrayList(22));
        List<Integer> xx = map.compute(2, (k, v) -> {
           return Lists.newArrayList(22, 222);
        });
        System.out.println(map + " " + xx);//返回:{2=[22, 222]} [22, 222] key存在，插入新value并返回
 
        xx = map.compute(2, (k, v) -> {
            return null;
        });
        System.out.println(map + " " + xx);//返回:{} null 表达式返回null，remove key并返回null
 
        xx = map.compute(2, (k, v) -> {
            return Lists.newArrayList(22, 222);
        });
        System.out.println(map + " " + xx);//返回:{2=[22, 222]} [22, 222] key不存在，插入新value并返回

小结

putIfAbsent和computeIfAbsent

都是在key不存在的时候才会建立key和value的映射关系；
putIfAbset不论传入的value是否为空，都会建立映射（并不适合所有子类，例如HashTable），而computeIfAbsent方法，当存入value为空时，不做任何操作
当key不存在时，返回的都是新的value（为什么不说新插入的value），即使computeIfAbsent在传入的value为null时，不会新建映射关系，但返回的也是null；

computeIfPresent和computeIfAbsent

这两个方法正好相反，前者是在key存在时，才会用新的value替换oldValue
当传入的key存在，并且传入的value为null时，前者会remove（key），把传入的key对应的映射关系移除；而后者不论何时都不会remove()；
前者只有在key存在，并且传入的value不为空的时候，返回值是value，其他情况都是返回null；后者只有在key不存在，并且传入的value不为null的时候才会返回value，其他情况都返回null；

compute
新传入的value不为null就建立映射关系（也就是说不论key是否为null，具体子类再具体分析）
新传入的value为null时：key已存在，且老的对应value不为null，移除改映射关系，返回null；否则，直接返回null

Predicate

Predicate是个断言式接口其参数是<T,boolean>，也就是给一个参数T，返回boolean类型的结果。Predicate的具体实现也是根据传入的lambda表达式来决定的。

基本示例：

Predicate<Integer> aa= xx-> xx== 2;
aa.test(xx);

Predicate默认实现的三个重要方法and，or和negate。这三个方法对应了java的三个连接符号&&、|| 和 !。

举例：

        int[] numbers= {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
        List<Integer> list=new ArrayList<>();
        for(int i:numbers) {
            list.add(i);
        }
        Predicate<Integer> p1=i->i>5;
        Predicate<Integer> p2=i->i<20;
        Predicate<Integer> p3=i->i%2==0;
        List test=list.stream().filter(p1.and(p2).and(p3)).collect(Collectors.toList());
        System.out.println(test.toString());
        /** print:[6, 8, 10, 12, 14]*/
        List test=list.stream().filter(p1.and(p2).and(p3.negate())).collect(Collectors.toList()); 
        /** print:[7, 9, 11, 13, 15]*/

isEqual这个方法的返回类型也是Predicate，所以我们也可以把它作为函数式接口进行使用。我们可以当做==操作符来使用。

List test=list.stream()
            .filter(p1.and(p2).and(p3.negate()).and(Predicate.isEqual(7)))
            .collect(Collectors.toList());
/** print:[7] */

BiPredicate

相比Predicate，其实就是由1个入参变为2个。

BiPredicate<Integer, Integer> xx = (type, subType) -> type == 20 && (subType == 15);

Function

Function是一个泛型类，其中定义了两个泛型参数T和R，在Function中，T代表输入参数，R代表返回的结果。

其作用类似于数学中函数的定义，（x,y）跟<T,R>的作用几乎一致。y = f(x)

Function中没有具体的操作，具体的操作需要我们去为它指定，因此apply具体返回的结果取决于传入的lambda表达式。

R apply(T t);

举例：

public void test(){
    Function<Integer,Integer> test=i->i+1;
    test.apply(5);
}
/** print:6*/

用于逻辑复用：

public void test(){
    Function<Integer,Integer> test1=i->i+1;
    Function<Integer,Integer> test2=i->i*i;
    System.out.println(calculate(test1,5));
    System.out.println(calculate(test2,5));
}
public static Integer calculate(Function<Integer,Integer> test,Integer number){
    return test.apply(number);
}
/** print:6*/
/** print:25*/

实现复杂逻辑：compose、andThen

compose接收一个Function参数，返回时先用传入的逻辑执行apply，然后使用当前Function的apply。

andThen跟compose正相反，先执行当前的逻辑，再执行传入的逻辑。

compose等价于B.apply(A.apply(5))，而andThen等价于A.apply(B.apply(5))。

public void test(){
    Function<Integer,Integer> A=i->i+1;
    Function<Integer,Integer> B=i->i*i;
    System.out.println("F1:"+B.apply(A.apply(5)));
    System.out.println("F1:"+B.compose(A).apply(5));
    System.out.println("F2:"+A.apply(B.apply(5)));
    System.out.println("F2:"+B.andThen(A).apply(5));
}
/** F1:36 */
/** F1:36 */
/** F2:26 */
/** F2:26 */

可以看到上述两个方法的返回值都是一个Function，这样我们就可以使用建造者模式的操作来使用。

B.compose(A).compose(A).andThen(A).apply(5);

BiFunction

相比Function，其实就是由1个入参变为2个。

BiFunction<String, Function<String, String>, Boolean> xx =
            (stat, mapper) -> Optional.ofNullable(stat)
                    .map(mapper)
                    .map(Double::parseDouble)
                    .map(comp -> comp >= 0)
                    .orElse(false);

Optional

empty Optional

Optional<String> empty = Optional.empty();
System.out.println(empty.isPresent());//false

Optional.of

传递给of()的值不可以为空，否则会抛出空指针异常。

Optional<String> xx = Optional.of("kk");
System.out.println(xx.isPresent() + " " + xx.get());//true kk

Optional.ofNullable

使用ofNullable API，则当传递进去一个空值时，不会抛出异常，而只是返回一个空的Optional对象，如同我们用Optional.empty。

Optional<String> xx = Optional.ofNullable("kk");
System.out.println(xx.isPresent() + " " + xx.get());//true xx
xx = Optional.ofNullable(null);
System.out.println(xx.isPresent());//false get()不返回值，因为不存在值

isPresent

判断Optional对象中是否有值，只有值非空才返回true。

ifPresent

传统写法检查空值：

if(name != null){
    System.out.println(name.length);
}

Optional写法：

Optional<String> opt = Optional.ofNullable(name);
opt.ifPresent(na -> {
     System.out.println(na);
});

orElse orElseGet

orElse用来检索Optional对象中的值，它被传入一个“默认参数‘。如果对象中存在一个值，则返回它，否则返回传入的“默认参数”。

String name = null;
String name = Optional.ofNullable(name).orElse("xx");

orElseGet与orElse类似，但是这个函数不接收一个“默认参数”，而是一个函数接口。

String nullName = null;
String name = Optional.ofNullable(nullName).orElseGet(() -> "xx");

两者区别:

public void test() {
        String text = "name";
        String defaultText =
                Optional.ofNullable(text).orElseGet(this::aa);
        System.out.println(defaultText);
        System.out.println("---");
 
        defaultText =
                Optional.ofNullable(text).orElse(aa());
        System.out.println(defaultText);
    }
 
    public String aa() {
        System.out.println("aa method");//orElse,当入参为null，会调用aa()方法
        return "aa";
    }

当text为null，二者一致。

当text不为null，orElse会计算后面的aa()。

orElseThrow

orElseThrow当遇到一个不存在的值的时候，并不返回一个默认值，而是抛出异常。

String nullName = null;
String name = Optional.ofNullable(nullName).orElseThrow(
      IllegalArgumentException::new);

get

当Optional.ofNullable(nullName)存在值时，才可以get，否则报错。

filter map flatmap

Optional.ofNullable(String str)
       .map(Integer::parseInt)
       .filter(p -> p >= 10)
       .filter(p -> p <= 15)
       .isPresent();

有时我们可以使用flatmap()替换map()，二者不同之处在于，map()只有当值不被包裹时才进行转换，而flatmap()接受一个被包裹着的值并且在转换之前对其解包。

public class Person {
    public String name;
 
    public Optional<String> getName() {
        return Optional.ofNullable(name);
    }
}
 
Person person = new Person();
person.name = "xx";
Optional<Person> personOptional = Optional.of(person);
String name = personOptional
      .flatMap(Person::getName)
      .orElse("");

方法getName返回的是一个Optional对象，而不是像trim那样。这样就生成了一个嵌套的Optional对象。

Supplier

Supplier 接口是一个供给型的接口，其实，说白了就是一个容器，可以用来存储数据，然后可以供其他方法使用的一个接口。

　　　　 Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                //返回一个随机值
                return new Random().nextInt();
            }
        };
 
        System.out.println(supplier.get());//每次调用都会走到get()方法内部
        System.out.println(supplier.get());
 
        System.out.println("********************");
 
        //使用lambda表达式，
        supplier = () -> new Random().nextInt();
        System.out.println(supplier.get());
        System.out.println("********************");
 
        //使用方法引用
        Supplier<Double> supplier2 = Math::random;
        System.out.println(supplier2.get());

在 Optional 对象中orElseGet 是需要一个 Supplier 接口。

Consumer

consumer接口就是一个消费型的接口，通过传入参数，然后输出值。

        //使用consumer接口实现方法
        Consumer<String> consumer = new Consumer<String>() {
 
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        Stream<String> stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");
        stream.forEach(consumer);
 
        System.out.println("********************");
 
        //使用lambda表达式，forEach方法需要的就是一个Consumer接口
        stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");
        Consumer<String> consumer1 = (s) -> System.out.println(s);//lambda表达式返回的就是一个Consumer接口
        stream.forEach(consumer1);
        //更直接的方式
        //stream.forEach((s) -> System.out.println(s));
        System.out.println("********************");
 
        //使用方法引用，方法引用也是一个consumer
        stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");
        Consumer consumer2 = System.out::println;
        stream.forEach(consumer);
        //更直接的方式
        //stream.forEach(System.out::println);