Java中的七種函式程式設計技術 - foojay

public class HocSample {
    public static void main(String[] args) {
        var list = Arrays.asList("Orange", "Apple", "Banana", "Grape");

       //我們將陣列和FnFactory的匿名內部類例項作為mapForEach方法的引數傳遞。
        var out = mapForEach(list, new FnFactory<String, Object>() {
            @Override
            public Object execute(final String it) {
                return it.length();
            }
        });
        System.out.println(out); // [6, 5, 6, 5]
    }

    //該方法將陣列和FnFactory的例項作為引數
    static <T, S> ArrayList<S> mapForEach(List<T> arr, FnFactory<T, S> fn) {
        var newArray = new ArrayList<S>();
        // We are executing the method from the FnFactory instance
        arr.forEach(t -> newArray.add(fn.execute(t)));
        return newArray;
    }

    @FunctionalInterface //不會做任何事情，只是提供資訊而已。.
    public interface FnFactory<T, S> {
        // The interface defines the contract for the anonymous class
        S execute(T it);
    }
}

public class HocSample {
    public static void main(String[] args) {
        var list = Arrays.asList("Orange", "Apple", "Banana", "Grape");
        //我們將陣列和一個lambda表示式作為引數傳遞給mapForEach方法。
        var out = mapForEach(list, it -> it.length());
       //這可以進一步簡化為“ mapForEach（list，String :: length）;”，我正在編寫擴充套件版本以提高可讀性
        System.out.println(out); // [6, 5, 6, 5]
    }

   //該方法將一個陣列和一個Function例項作為引數（我們已將自定義介面替換為內建介面）
    static <T, S> ArrayList<S> mapForEach(List<T> arr, Function<T, S> fn) {
        var newArray = new ArrayList<S>();
        //我們正在執行Function例項中的方法
        arr.forEach(t -> newArray.add(fn.apply(t)));
        return newArray;
    }
}

public class ClosureSample {
     //這是一個返回函式介面例項的高階函式
    Function<Integer, Integer> add(final int x) {
       //這是一個閉包，即一個包含Function介面的匿名內部類例項的變數
        //使用外部作用域中的變數
        var partial = new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer y) {
                // variable x is obtained from the outer scope of this method which is declared as final
                return x + y;
            }
        };
        //這裡返回閉包函式例項
        return partial;
    }

    public static void main(String[] args) {
        ClosureSample sample = new ClosureSample();

        //我們正在使用add方法來建立更多變數
        var add10 = sample.add(10);
        var add20 = sample.add(20);
        var add30 = sample.add(30);

        System.out.println(add10.apply(5)); // 15
        System.out.println(add20.apply(5)); // 25
        System.out.println(add30.apply(5)); // 35
    }
}

var list = Arrays.asList("Apple", "Orange", "Banana", "Grape");

//這可以簡化為“ Collections.sort（list，Comparator.naturalOrder（））;”，我正在編寫擴充套件版本以提高可讀性
Collections.sort(list, (String a, String b) -> {
    return a.compareTo(b);
});

System.out.println(list); // [Apple, Banana, Grape, Orange]

public static int sum(int a, int b) {
    return a + b;
}

static Map map = new HashMap<String, Integer>();

public static int sum(int a, int b) {
    var c = a + b;
    map.put(a + "+" + b, c);
    return c;
}

public class FactorialSample {
    // benchmark 9.645 ns/op
    static long factorial(long num) {
        long result = 1;
        for (; num > 0; num--) {
            result *= num;
        }
        return result;
    }

    public static void main(String[] args) {
        System.out.println(factorial(20)); // 2432902008176640000
    }
}

public class FactorialSample {
    // benchmark 19.567 ns/op
    static long factorialRec(long num) {
        return num == 1 ? 1 : num * factorialRec(num - 1);
    }

    public static void main(String[] args) {
        System.out.println(factorialRec(20)); // 2432902008176640000
    }
}

public class FactorialSample {
    // benchmark 16.701 ns/op
    static long factorialTailRec(long num) {
        return factorial(1, num);
    }

    static long factorial(long accumulator, long val) {
        return val == 1 ? accumulator : factorial(accumulator * val, val - 1);
    }

    public static void main(String[] args) {
        System.out.println(factorialTailRec(20)); // 2432902008176640000
    }
}

public class FactorialSample {
    // benchmark 59.565 ns/op
    static long factorialStream(long num) {
        return LongStream.rangeClosed(1, num)
                .reduce(1, (n1, n2) -> n1 * n2);
    }

    public static void main(String[] args) {
        System.out.println(factorialStream(20)); // 2432902008176640000
    }
}

public class EagerSample {
    public static void main(String[] args) {
        System.out.println(addOrMultiply(true, add(4), multiply(4))); // 8
        System.out.println(addOrMultiply(false, add(4), multiply(4))); // 16
    }

    static int add(int x) {
        System.out.println("executing add"); // this is printed since the functions are evaluated first
        return x + x;
    }

    static int multiply(int x) {
        System.out.println("executing multiply"); // this is printed since the functions are evaluated first
        return x * x;
    }

    static int addOrMultiply(boolean add, int onAdd, int onMultiply) {
        return (add) ? onAdd : onMultiply;
    }
}

public class LazySample {
    public static void main(String[] args) {
        //這是一個lambda表示式，表現為閉包
        UnaryOperator<Integer> add = t -> {
            System.out.println("executing add");
            return t + t;
        };
      //這是一個lambda表示式，表現為閉包
        UnaryOperator<Integer> multiply = t -> {
            System.out.println("executing multiply");
            return t * t;
        };
        //傳遞Lambda閉包而不是普通函式
        System.out.println(addOrMultiply(true, add, multiply, 4));
        System.out.println(addOrMultiply(false, add, multiply, 4));
    }

    //這是一個高階函式
    static <T, R> R addOrMultiply(
            boolean add, Function<T, R> onAdd,
            Function<T, R> onMultiply, T t
    ) {
        // Java的？會懶惰計算表示式，因此僅執行所需的方法
        return (add ? onAdd.apply(t) : onMultiply.apply(t));
    }
}

final var list = Arrays.asList("Apple", "Orange", "Banana", "Grape");

list = Arrays.asList("Earth", "Saturn");

final var list = new ArrayList<>();

list.add("Test");
list.add("Test 2");