是的，這也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;