【java源码一带一路系列】之HashMap.compute()

是的，这也J8新增的梗。当我第一眼看到逼函数（BiFunction）的时候就原地炸了。实际上，“Bi”乃binary缩写，即“二元函数”之意（类似“1+1=2”）。这类接口称为“函数式接口”，可以看出，它的==方法有方法体==。且以“default”修饰符修饰，不影响接口的实现类，算是一种向下兼容吧。

/**
 * An informative annotation type used to indicate that an interface
 * type declaration is intended to be a functional interface as
 * defined by the Java Language Specification.
 *
 * Conceptually, a functional interface has exactly one abstract
 * method.  Since {@linkplain java.lang.reflect.Method#isDefault()
 * default methods} have an implementation, they are not abstract.  If
 * an interface declares an abstract method overriding one of the
 * public methods of {@code java.lang.Object}, that also does
 * not count toward the interface"s abstract method count
 * since any implementation of the interface will have an
 * implementation from {@code java.lang.Object} or elsewhere.
 *
 * 
Note that instances of functional interfaces can be created with
 * lambda expressions, method references, or constructor references.
 *
 * 
If a type is annotated with this annotation type, compilers are
 * required to generate an error message unless:
 *
 * 

 * 
 The type is an interface type and not an annotation type, enum, or class.
 * 
 The annotated type satisfies the requirements of a functional interface.
 * 
 *
 * 
However, the compiler will treat any interface meeting the
 * definition of a functional interface as a functional interface
 * regardless of whether or not a {@code FunctionalInterface}
 * annotation is present on the interface declaration.
 *
 * @jls 4.3.2. The Class Object
 * @jls 9.8 Functional Interfaces
 * @jls 9.4.3 Interface Method Body
 * @since 1.8
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}

“@FunctionalInterface”并非必须，就像javascript中的“use strict”,使得编译器能检查该接口是否存在语法错误。此外，从注释还可以看出：

函数接口仅有一个抽象方法；
default方法、Object的重载方法（、静态方法）非抽象方法；

// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node p) { }

从注释可以看到这是为LinkedHashMap留的后路，不过HashMap存取操作中经常发现他们的身影，即使实现为空。。

@Override
public V computeIfAbsent(K key,
                         Function mappingFunction) {
    if (mappingFunction == null)
        throw new NullPointerException();
    int hash = hash(key);
    Node[] tab; Node first; int n, i;
    int binCount = 0;
    TreeNode t = null;
    Node old = null;
    if (size > threshold || (tab = table) == null ||
        (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((first = tab[i = (n - 1) & hash]) != null) {
        if (first instanceof TreeNode)
            old = (t = (TreeNode)first).getTreeNode(hash, key);
        else {
            Node e = first; K k;
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k)))) {
                    old = e;
                    break;
                }
                ++binCount;
            } while ((e = e.next) != null);
        }
        V oldValue;
        if (old != null && (oldValue = old.value) != null) {
            afterNodeAccess(old);
            return oldValue;
        }
    }
    V v = mappingFunction.apply(key);
    if (v == null) {
        return null;
    } else if (old != null) {
        old.value = v; // old.value null
        afterNodeAccess(old);
        return v;
    }
    else if (t != null)
        t.putTreeVal(this, tab, hash, key, v);
    else {
        tab[i] = newNode(hash, key, v, first);
        if (binCount >= TREEIFY_THRESHOLD - 1)
            treeifyBin(tab, hash);
    }
    ++modCount;
    ++size;
    afterNodeInsertion(true);
    return v;
}

public V computeIfPresent(K key,
                          BiFunction remappingFunction) {
    if (remappingFunction == null)
        throw new NullPointerException();
    Node e; V oldValue;
    int hash = hash(key);
    if ((e = getNode(hash, key)) != null &&
        (oldValue = e.value) != null) {
        V v = remappingFunction.apply(key, oldValue);
        if (v != null) {
            e.value = v;
            afterNodeAccess(e);
            return v;
        }
        else
            removeNode(hash, key, null, false, true);
    }
    return null;
}

computeIfAbsent()与computeIfPresent()可以说是compute()的“子集”。

这次的功夫主要花在了学习J8的知识点上，经过前2篇后HashMap本身不再那么可怕。你觉得呢？

更多有意思的内容，欢迎访问笔者小站： rebey.cn

最后分享几个学习Java8过程中看到良心网址(以下链接为网站系列文章之一，希望细心的你举一反三)：

Java8初体验（二）Stream语法详解;

Java 8 中的 Streams API 详解;

Java 8 flatMap example;