/**
 * 規約
 */
public class Demo04 {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        test01(numbers);
        test02(numbers);
        test03(numbers);
        test04(numbers);
        test05();
    }

    /**
     * 求和
     */
    public static void test01(List<Integer> numbers) {
//        Integer sum = numbers.stream().reduce(0, (a, b) -> a + b);
//        int sum = Integer.sum(1, 2);
//        Integer sum = numbers.stream().reduce(0, Integer::sum);//Integer類現在有了一個靜態的sum方法來對兩個數求和，這恰好是我們想要的，用不著反覆用Lambda寫同一段程式碼了
        //為什麼它返回一個Optional<Integer>呢？考慮流中沒有任何元素的情況。reduce操作無
        //法返回其和，因為它沒有初始值。這就是為什麼結果被包裹在一個Optional物件裡，以表明和
        //可能不存在。現在看看用reduce還能做什麼。
        Optional<Integer> sumOptional = numbers.stream().reduce(Integer::sum);
        if (sumOptional.isPresent()) {
            System.out.println(sumOptional.get());
        }
    }

    /**
     * 求積
     */
    public static void test02(List<Integer> numbers) {
//        Integer accumulate = numbers.stream().reduce(1, (a, b) -> a * b);
        Optional<Integer> accumulateOptional = numbers.stream().reduce((a, b) -> a * b);
        if (accumulateOptional.isPresent()) {
            System.out.println(accumulateOptional.get());
        }
    }

    /**
     * 求最大值
     */
    public static void test03(List<Integer> numbers) {
//        Optional<Integer> optionalMaxValue = numbers.stream().reduce(Integer::max);
        Optional<Integer> optionalMaxValue = numbers.stream().reduce((a, b) -> a > b ? a : b);
        if (optionalMaxValue.isPresent()) {
            System.out.println("最大值為：" + optionalMaxValue.get());
        }
    }

    /**
     * 求最小值
     */
    public static void test04(List<Integer> numbers) {
//        Optional<Integer> optionalMinValue = numbers.stream().reduce(Integer::min);
        Optional<Integer> optionalMinValue = numbers.stream().reduce((a, b) -> a > b ? b : a);
        if (optionalMinValue.isPresent()) {
            System.out.println("最小值：" + optionalMinValue.get());
        }
    }

    /**
     * 數一數有多少個菜餚:
     * 要解決這個問題，你可以把流中每個元素都對映成數字1，然後用reduce求和。這
     * 相當於按順序數流中的元素個數僅僅是為了練習啊
     */
    public static void test05() {
        List<Dish> menues = Arrays.asList(new Dish("rice", true, 10000, Dish.Type.FISH), new Dish("meat", false, 20000, Dish.Type.FISH), new Dish("rice", true, 30000, Dish.Type.FISH));
//        Optional<Integer> menuesSum = menues.stream().map(dish -> 1).reduce(Integer::sum);
//        if(menuesSum.isPresent()){
//            System.out.println(menuesSum.get());
//        }
        long count = menues.stream().count();
        System.out.println(count);
    }
}