就像名字一样，他它只是一个供应商，他它的任务很简单，给你供货。

    Supplier Functional Interface只实现定义了一个方法：get

    1. package java.util.function;
    3. /**
    4.  * Represents a supplier of results.
    5.  *
    6.  * <p>There is no requirement that a new or distinct result be returned each
    7.  * time the supplier is invoked.
    8.  *
    9.  * <p>This is a <a href="package-summary.html">functional interface</a>
    10.  * whose functional method is {@link #get()}.
    11.  *
    12.  * @param <T> the type of results supplied by this supplier
    13.  *
    14.  * @since 1.8
    15.  */
    16. @FunctionalInterface
    17. public interface Supplier<T> {
    19.     /**
    20.      * Gets a result.
    21.      *
    22.      * @return a result
    23.      */
    24.     T get();
    25. }

    就像下面的例子，供应商每次都给你提供一个有一个handsome xiaohundun的Map

    1. package other;
    2. /*
    3.  * @author chou
    4.  * @Description
    5.  * @since 2020/1/13
    6.  **/
    8. import org.junit.Test;
    10. import java.util.HashMap;
    11. import java.util.Map;
    12. import java.util.function.Supplier;
    14. public class SupplierTest {
    15.     @Test
    16.     public void supplierFi () {
    17. //        Supplier<Map<Object,Object>> emptyMap = Collections::emptyMap;
    18. //        Map<Object, Object> mmmmmmamaipi = emptyMap.get();
    19. //        System.out.format("%3$s size %1$x ,hashcode %2$x", mmmmmmamaipi.size(), mmmmmmamaipi.hashCode(), "mmmmmmamaipi");
    20.         Supplier<Map<String,String>> handsomeMap = ()->{
    21.             Map<String,String> rm = new HashMap<>();
    22.             rm.put("xiaohundun", "handsome");
    23.             return rm;
    24.         };
    26.         Map<String,String> handsomeMap1 = handsomeMap.get();
    27.         System.out.format("xiaohundun is %s %n", handsomeMap1.get("xiaohundun"));
    28.         handsomeMap1.put("xiaohundun", "kind");
    29.         Map<String,String> handsomeMap2 = handsomeMap.get();
    30.         System.out.format("xiaohundun is %s", handsomeMap2.get("xiaohundun"));
    31.     }
    32. }

    Supplier FI在流中的应用：

    IntStream.generate接收一个IntSupplier，此Supplier提供数字，中间peek了一下用来虚区，然后用短路操作终结流。

    1. @Test
    2. public void generate () {
    3.     #An infinite stream should be ended by short-circuiting operations such as limit & anyMatch & findFirst etc.
    4.     System.out.println(IntStream.generate(() -> (int) (Math.random() * 100)).peek(System.out::println).anyMatch((i) -> i == 6));
    5. }

    Supplier FI在非流中的应用：

    ThreadLocal有一个静态内部类，它集成继承了ThreadLocal，并且内部绑定了Supplier。ThreadLocal提供了withInitial方法用来创建一个包含初始值的ThreadLocal，当你使用ThreadLocal#get方法的时候会检查线程绑定Map是否为空，如果为空进行值的初始化并绑定Thread与ThreadLocalMap，如果不为空返回ThreadLocalMap中的值。

    1. @Test
    2. public void supplierThreadLocal(){
    3.     Supplier<String> supplierTheadLocal = () -> "xiaohundun";
    4.     ThreadLocal<String> threadLocal = ThreadLocal.withInitial(supplierTheadLocal);
    5.     System.out.println(threadLocal.get());
    6. }
    1. @Test
    2. public void Optional () {
    3.     OptionalInt value = OptionalInt.empty();
    4.     try {
    5.         value.orElseThrow(new Supplier<Throwable>() {
    6.             @Override
    7.             public Throwable get () {
    8.                 return new ArithmeticException("哈哈");
    9.             }
    10.         });
    12.     } catch (Throwable e) {
    13.         System.out.println(e.getMessage());
    14.     }
    15.     value.orElseGet(new IntSupplier() {
    16.         @Override
    17.         public int getAsInt () {
    18.             return 66;
    19.         }
    20.     });
    21. }