Java函式式編程神器 VAVR（vavr - turns java™ upside down）

什么是函式式編程

1. 基本概念：他是一種編程范式，對于函式式編程來說，它只關心定義輸入資料和輸出資料相關的關系，數學運算式里面其實是在做一種映射（mapping），輸入的資料和輸出的資料關系是什么樣的，是用函式來定義的，
2. 特征：
   • stateless：函式不維護任何狀態，函式式編程的核心精神是 stateless，簡而言之就是它不能存在狀態，打個比方，你給我資料我處理完扔出來，里面的資料是不變的，
   • immutable：輸入資料是不能動的，動了輸入資料就有危險，所以要回傳新的資料集，(不可變的)

Java為什么要函式式編程

3. 優勢
   • 沒有狀態就沒有傷害，
   • 并行執行無傷害，
   • Copy-Paste 重構代碼無傷害，
   • 函式的執行沒有順序上的問題，

問題所在

• 函式式相對于普通的java變成來說，如果沒有用過就會直接不清楚這個函式是干什么的，這個是干什么的，如果在團隊中只有部分人使用，那我們在其他人在理解我們的代碼上就會有問題，也就回增加學習成本，和開發成本，
• 使用的問題：問題排查的問題 和例外的捕獲的問題，

EXAMPLE

package Vavr;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.sun.istack.internal.FragmentContentHandler;
import io.vavr.CheckedFunction0;
import io.vavr.Function1;
import io.vavr.Function2;
import io.vavr.Function3;
import io.vavr.Lazy;
import io.vavr.Tuple;
import io.vavr.Tuple2;
import io.vavr.control.Either;
import io.vavr.control.Option;
import io.vavr.control.Try;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ThreadLocalRandom;
import javax.annotation.Generated;
import lombok.Getter;

/**
 * 函式式編程demo
 *
 * @author yuanxindong
 * @date 4/17/21  7:30 PM
 */
public class VavrTest {

    /**
     * 元組的使用
     */
    public static void tupleTest() {

        //of 靜態方法支持使用
        Tuple2<String, Integer> tuple2 = Tuple.of("Hello", 100);

        Tuple2<String, Integer> updatedTuple2 = tuple2.map(String::toUpperCase, v -> v * 5);

        String result = updatedTuple2.apply((str, number) -> String.join(", ",
            str, number.toString()));

        System.out.println(result);
    }

    /**
     * function函式的使用
     */
    public static void functionTest() {

        // 函式定義,前3個是入參，最后是R
        Function3<Integer, Integer, Integer, Integer> function3 = (v1, v2, v3) -> (v1 + v2) * v3;

        // 函式的組合
        Function3<Integer, Integer, Integer, Integer> composed =
            function3.andThen(v -> v * 100);

        //執行結果
        int result = composed.apply(1, 2, 3);

        System.out.println(result);

        //還有包含部分函式的應用
        Function1<Integer, Integer> function1 = function3.apply(1, 2);

        Integer apply = function1.apply(1);
        System.out.println(apply);

        //專案聯想
        //結合專案場景使用比如說PDT中定義幾個 函式比如：計算MP時效的函式，計算ALG的函式時效，在定義一些函式結果的拼接等
    }

    /**
     * 柯里化想要解決的問題： 柯里化方法的使用 柯里化的含義： 柯里化（currying）是與λ演算相關的重要概念，通過柯里化，可以把有多個輸入的函式轉換成只有一個輸入的函式，從而可以在λ演算中來表示， 柯里化的名稱來源于數學家 Haskell Curry， Haskell Curry 是一位傳奇性的人物，以他的名字命令了 3 種編程語言，Haskell、Brook 和 Curry，
     * 柯里化是把有多個輸入引數的求值程序，轉換成多個只包含一個引數的函式的求值程序， 對于清單 6 的函式 f(a, b, c)，在柯里化之后轉換成函式 g，則對應的呼叫方式是 g(a)(b)(c)， 函式 (x, y) -> x + y 經過柯里化之后的結果是 x -> (y -> x + y)，
     */
    public static void curriedTest() {
        //設定函式 v1 v
        Function3<Integer, Integer, Integer, Integer> function3 = (v1, v2, v3) -> (v1 + v2) * v3;

        //可以看出來是回傳來了一個函式
        Function1<Integer, Function1<Integer, Integer>> apply = function3.curried().apply(1);

        //多次柯里化后就會回傳我們想要的記過
        int result = function3.curried().apply(1).curried().apply(2).curried().apply(3);
        System.out.println(result);
    }

    /**
     * 記憶化方法 會將之前計算過的方法進行存盤，相同引數在第二次呼叫的時候會使用快取
     */
    public static void memoized() {

        //計算差方
        Function2<BigInteger, Integer, BigInteger> pow = BigInteger::pow;
        //記憶化
        Function2<BigInteger, Integer, BigInteger> memoized = pow.memoized();

        long start = System.currentTimeMillis();
        memoized.apply(BigInteger.valueOf(1024), 1024);
        long end1 = System.currentTimeMillis();

        memoized.apply(BigInteger.valueOf(1024), 1024);
        long end2 = System.currentTimeMillis();
        System.out.printf("%d ms -> %d ms", end1 - start, end2 - end1);
    }

    /**
     * java  8 中的optional  是類似 其目的都是為了避免NPE的出現
     */
    public static void optionTest() {
        //個人覺得option好用的地方在于這個of 靜態函式，
        Option<String> str = Option.of("Hello");

        str.map(String::length);
        //使用對應的值
        Option<Integer> integers = str.flatMap(v -> Option.of(v.length()));
        boolean empty = integers.isEmpty();
        System.out.println(integers);
    }

    /**
     * either 的使用 包含兩個值，left（例外值） 和 right（正確值）
     */
    public static void eitherAndTryTest() {

        //這個是
        Either<String, String> either =
            compute()
                .map(str -> str + " World")
                .mapLeft(Throwable::getMessage);
        System.out.println(either);

        //Try的使用，不用寫過多的catch，左后將left值交給某一個函式統一處理，
        //在pdt中有很多這樣的代碼，try catch 嵌套起來使用 包含引數定義的引數校驗例外
        //
        Fruit.fromColor("1111");


    }

    private static ThreadLocalRandom random = ThreadLocalRandom.current();

    private static Either<Throwable, String> compute() {
        return random.nextBoolean()
            ? Either.left(new RuntimeException("Boom!"))
            : Either.right("Hello");
    }

    @Getter
    public enum Fruit {

        APPLE("APPLE", "BLACK"),
        BANANA("BANANA", "BLUE"),

        NONE("ORANGE", "WHITE");
        private final String name;
        private final String color;

        Fruit(String name, String color) {
            this.name = name;
            this.color = color;
        }

        public static Fruit fromColor(String color) {

            return Try.of(() -> Arrays.stream(Fruit.values())
                .filter(t -> t.getColor().equals(color))
                .findFirst().orElse(NONE))
                .toEither().getOrElse(NONE);
        }

    }


    /**
     * Lazy 表示的是一個延遲計算的值，在第一次訪問時才會進行求值操作，而且該值只會計算一次，之后的訪問操作獲取的是快取的值， Lazy.of 從介面 Supplier 中創建 Lazy 物件，方法 isEvaluated 可以判斷 Lazy 物件是否已經被求值，
     */
    public static void LazyTest() {
        Lazy<BigInteger> lazy = Lazy.of(() ->
            BigInteger.valueOf(1024).pow(1024));

        System.out.println(lazy.isEvaluated());
        System.out.println(lazy.get());
        System.out.println(lazy.isEvaluated());
        System.out.println(lazy.get());
        System.out.println(lazy.isEvaluated());
        Lazy<BigInteger> lazy2 = Lazy.of(() ->
            BigInteger.valueOf(1024).pow(1024));
        System.out.println(lazy2.isEvaluated());
        System.out.println(lazy2.get());

        //未想到應用場景
    }


    public static void main(String[] args) {
        tupleTest();
        functionTest();
        curriedTest();
        memoized();
        LazyTest();
    }

}