Java - Lambda 快速入門

package com.imooc;

/**
 * 用戶身份認證標記接口
 */
@FunctionalInterface
public interface IUserCredential {

    /**
     * 通過用戶賬號，驗證用戶身份信息的接口
     * @param username 要驗證的用戶賬號
     * @return 返回身份信息[系統管理員、用戶管理員、普通用戶]
     */
    String verifyUser(String username);

//    boolean test();

    default String getCredential(String username) {
        // 模擬方法
        if ("admin".equals(username)) {
            return "admin + 系統管理員用戶";
        } else if("manager".equals(username)){
            return "manager + 用戶管理員用戶";
        } else {
            return "commons + 普通會員用戶";
        }
    }
}

package com.imooc;

/**
 * 消息傳輸格式化轉換接口
 */
@FunctionalInterface
public interface IMessageFormat {

    /**
     * 消息轉換方法
     * @param message 要轉換的消息
     * @param format 轉換的格式[xml/json..]
     * @return 返回轉換後的數據
     */
    String format(String message, String format);

//    boolean test();
    String toString();

    /**
     * 消息合法性驗證方法
     * @param msg 要驗證的消息
     * @return 返回驗證結果
     */
    static boolean verifyMessage(String msg) {
        if (msg != null) {
            return true;
        }
        return false;
    }
}

package com.imooc.impl;

import com.imooc.IUserCredential;

/**
 * Copyright (C), 2018-2019, copyright info. DAMU., Ltd.
 * FileName: com.imooc.impl UserCredentialImpl
 * <p>TODO</p>
 *
 * @author <a href="http://blog.csdn.net/muwenbin_flex">大牧莫邪</a>
 * @version 1.00
 */
public class UserCredentialImpl implements IUserCredential {
    @Override
    public String verifyUser(String username) {
        if ("admin".equals(username)) {
            return "系統管理員";
        } else if("manager".equals(username)) {
            return "用戶管理員";
        }
        return "普通會員";
    }
}

package com.imooc.impl.impl;

import com.imooc.IMessageFormat;

/**
 * Copyright (C), 2018-2019, copyright info. DAMU., Ltd.
 * FileName: com.imooc.impl.impl MessageFormatImpl
 * <p>TODO</p>
 *
 * @author <a href="http://blog.csdn.net/muwenbin_flex">大牧莫邪</a>
 * @version 1.00
 */
public class MessageFormatImpl implements IMessageFormat {
    @Override
    public String format(String message, String format) {
        System.out.println("消息轉換...");
        return  message;
    }
}

package imooclambda;

import com.imooc.IMessageFormat;
import com.imooc.IUserCredential;
import com.imooc.impl.UserCredentialImpl;
import com.imooc.impl.impl.MessageFormatImpl;
import java.util.Random;
import java.util.UUID;
import java.util.function.*;

/**
 * Hello world!
 *
 * 需求改動：
 *  所有的用戶驗證，可以同時獲取用戶的驗證信息[是否認證成功|成功~返回用戶|null]
 *
 *  Lambda表達式 基本語法
 */
public class App 
{
    String welcome = "慕課網歡迎您.";
    public static void main( String[] args ) {
		// 一、接口的靜態方法和默認方法

		// 1. 默認方法
		IUserCredential ic = new UserCredentialImpl();
		System.out.println(ic.verifyUser("admin"));
		System.out.println(ic.getCredential("admin"));

		// 2. 靜態方法
		String msg = "hello world";
		if (IMessageFormat.verifyMessage(msg)) {
		   IMessageFormat format = new MessageFormatImpl();
		   format.format(msg, "json");
		}

		// 匿名內部類，實現接口的抽象方法
		IUserCredential ic2 = new IUserCredential() {
		   @Override
		   public String verifyUser(String username) {
		       return "admin".equals(username)?"管理員":"會員";
		   }
		};

		// 二、lambda表達式 是 函數式接口的一種實現
		System.out.println(ic2.verifyUser("manager"));
		System.out.println(ic2.verifyUser("admin"));

		// lambda表達式，針對函數式接口的簡單實現
		IUserCredential ic3 = (String username) -> {
		   return "admin".equals(username)?"lbd管理員": "lbd會員";
		};

		System.out.println(ic3.verifyUser("manager"));
		System.out.println(ic3.verifyUser("admin"));
    }
}

/*
    java.util.function提供了大量的函數式接口
    Predicate 接收參數T對象，返回一個boolean類型結果
    Consumer 接收參數T對象，沒有返回值
    Function 接收參數T對象，返回R對象
    Supplier 不接受任何參數，直接通過get()獲取指定類型的對象
    UnaryOperator 接口參數T對象，執行業務處理後，返回更新後的T對象
    BinaryOperator 接口接收兩個T對象，執行業務處理後，返回一個T對象
 */

// 三、JDK8 提供的常見函數式接口
Predicate<String> pre = (String username) -> {
   return "admin".equals(username);
};

System.out.println(pre.test("manager"));
System.out.println(pre.test("admin"));

Consumer<String> con = (String message) -> {
   System.out.println("要發送的消息：" + message);
   System.out.println("消息發送完成");
};
con.accept("hello 慕課網的學員們..");
con.accept("imooc lambda expression.");

Function<String, Integer> fun = (String gender) -> {
   return "male".equals(gender)?1:0;
};
System.out.println(fun.apply("male"));
System.out.println(fun.apply("female"));

Supplier<String> sup = () -> {
   return UUID.randomUUID().toString();
};
System.out.println(sup.get());
System.out.println(sup.get());
System.out.println(sup.get());

UnaryOperator<String> uo = (String img)-> {
   img += "[100x200]";
   return img;
};

System.out.println(uo.apply("原圖--"));

BinaryOperator<Integer> bo = (Integer i1, Integer i2) -> {
   return i1 > i2? i1: i2;
};

System.out.println(bo.apply(12, 13));

package imooclambda;

import com.imooc.IMessageFormat;
import com.imooc.IUserCredential;
import com.imooc.impl.UserCredentialImpl;
import com.imooc.impl.impl.MessageFormatImpl;
import java.util.Random;
import java.util.UUID;
import java.util.function.*;

/**
 * Hello world!
 *
 * 需求改動：
 *  所有的用戶驗證，可以同時獲取用戶的驗證信息[是否認證成功|成功~返回用戶|null]
 *
 *  Lambda表達式 基本語法
 */
public class App 
{
    String welcome = "慕課網歡迎您.";
    public static void main( String[] args ) {
        // 1. lambda表達式的基本語法
        /*
            1)聲明：就是和lambda表達式綁定的接口類型
            2)參數：包含在一對圓括號中，和綁定的接口中的抽象方法中的參數個數及順序一致。
            3)操作符：->
            4)執行代碼塊：包含在一對大括號中，出現在操作符號的右側

            [接口聲明] = (參數) -> {執行代碼塊};
         */
       ILambda1 i1 = () -> {
           System.out.println("hello imooc!");
           System.out.println("welcome to imooc!");
       };
       i1.test();

       ILambda1 i2 = () -> System.out.println("hello imooc");
       i2.test();

       ILambda2 i21 = (String n, int a) -> {
           System.out.println(n + "say: my year's old is " + a);
       };
       i21.test("jerry", 18);

       ILambda2 i22 = (n, a) -> {
           System.out.println(n + " 說：我今年" + a + "歲了.");
       };
       i22.test("tom", 22);

       ILambda3 i3 = (x, y) -> {
           int z = x + y;
           return z;
       };
       System.out.println(i3.test(11, 22));

       ILambda3 i31 = (x, y) -> x + y;
       System.out.println(i31.test(100, 200));

        /*
            1. lambda表達式，必須和接口進行綁定。
            2. lambda表達式的參數，可以附帶0個到n個參數，括號中的參數類型可以不用指定，jvm在運行時，會自動根據綁定的抽象方法中電參數進行推導。
            3. lambda表達式的返回值，如果代碼塊只有一行，並且沒有大括號，不用寫return關鍵字，單行代碼的執行結果，會自動返回。
                如果添加了大括號，或者有多行代碼，必須通過return關鍵字返回執行結果。
         */

    }

    // 沒有參數，沒有返回值的lambda表達式綁定的接口
    interface ILambda1{
        void test();
    }

    // 帶有參數，沒有返回值的lambda表達式
    interface ILambda2{
        void test(String name, int age);
    }

    // 帶有參數，帶有返回值的lambda表達式
    interface ILambda3 {
        int test(int x, int y);
    }
}

package imooclambda;

import java.util.ArrayList;
import java.util.List;

/**
 * Copyright (C), 2018-2019, copyright info. DAMU., Ltd.
 * FileName: imooclambda App2
 * <p>lambda表達式 變量捕獲</p>
 *
 * @author <a href="http://blog.csdn.net/muwenbin_flex">大牧莫邪</a>
 * @version 1.00
 */
public class App2 {
    String s1 = "全局變量";

    // 1. 匿名內部類型中對於變量的訪問
    public void testInnerClass() {
        String s2 = "局部變量";

        new Thread(new Runnable() {
            String s3 = "內部變量";
            @Override
            public void run() {
                // 訪問全局變量
//                System.out.println(this.s1);// this關鍵字~表示是當前內部類型的對象
                System.out.println(s1);

                System.out.println(s2);// 局部變量的訪問，~不能對局部變量進行數據的修改[final]
//                s2 = "hello";

                System.out.println(s3);
                System.out.println(this.s3);

            }
        }).start();
    }

    // 2. lambda表達式變量捕獲
    public void testLambda() {
        String s2 = "局部變量lambda";

        new Thread(() -> {
            String s3 = "內部變量lambda";

            // 訪問全局變量
            System.out.println(this.s1);// this關鍵字，表示的就是所屬方法所在類型的對象
            // 訪問局部變量
            System.out.println(s2);
//            s2 = "hello";// 不能進行數據修改，默認推導變量的修飾符：final
            System.out.println(s3);
            s3 = "labmda 內部變量直接修改";
            System.out.println(s3);
        }).start();
    }

    public static void main(String[] args) {
        App2 app = new App2();
//        app.testInnerClass();
        app.testLambda();

    }
}

package imooclambda;

import java.util.ArrayList;
import java.util.List;

/**
 * Copyright (C), 2018-2019, copyright info. DAMU., Ltd.
 * FileName: imooclambda App3
 * <p>lambda表達式類型檢查</p>
 *
 * @author <a href="http://blog.csdn.net/muwenbin_flex">大牧莫邪</a>
 * @version 1.00
 */
public class App3 {

    public static void test(MyInterface<String, List> inter) {
        List<String> list = inter.strategy("hello", new ArrayList());
        System.out.println(list);
    }

    public static void main(String[] args) {
        test(new MyInterface<String, List>() {
            @Override
            public List strategy(String s, List list) {
                list.add(s);
                return list;
            }
        });

        test((x, y) -> {
            y.add(x);
            return y;
//            x.add(y);
//            return x;
        });

        /*
        (x,y)->{..} --> test(param) --> param==MyInterface --> lambda表達式-> MyInterface類型
        這個就是對於lambda表達式的類型檢查，MyInterface接口就是lambda表達式的目標類型(target typing)

        (x,y)->{..} --> MyInterface.strategy(T r, R r)--> MyInterface<String, List> inter
            --> T==String R==List --> lambda--> (x, y) == strategy(T t , R r)--> x==T==String  y==R==List
            lambda表達式參數的類型檢查
         */

    }
}

@FunctionalInterface
interface MyInterface<T, R> {
    R strategy (T t, R r);
}

package imooclambda;

/**
 * Copyright (C), 2018-2019, copyright info. DAMU., Ltd.
 * FileName: imooclambda App4
 * <p>方法重載對於lmabda表達式的影響</p>
 *
 * @author <a href="http://blog.csdn.net/muwenbin_flex">大牧莫邪</a>
 * @version 1.00
 */
public class App4 {

    interface Param1 {
        void outInfo(String info);
    }

    interface Param2 {
        void outInfo(String info);
    }

    // 定義重載的方法
    public void lambdaMethod(Param1 param) {
        param.outInfo("hello param1 imooc!");
    }
    public void lambdaMethod(Param2 param) {
        param.outInfo("hello param2 imooc");
    }

    public static void main(String[] args) {
        App4 app = new App4();

        app.lambdaMethod(new Param1() {
            @Override
            public void outInfo(String info) {
                System.out.println(info);
            }
        });

        app.lambdaMethod(new Param2() {
            @Override
            public void outInfo(String info) {
                System.out.println("------");
                System.out.println(info);
            }
        });

        /*
        lambda表達式存在類型檢查-> 自動推導lambda表達式的目標類型
        lambdaMethod() -> 方法 -> 重載方法
                -> Param1  函數式接口
                -> Param2  函數式接口
                調用方法-> 傳遞Lambda表達式-> 自動推導->
                    -> Param1 | Param2
         */
//        app.lambdaMethod( (String info) -> {
//            System.out.println(info);
//        });
    }
}

package com.imooc.test;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * Copyright (C), 2018-2019, copyright info. DAMU., Ltd.
 * FileName: com.imooc.test Test
 * <p>
 *     1. 靜態方法引用的使用
 *      類型名稱.方法名稱() --> 類型名稱::方法名稱
 *     2. 實例方法引用的使用
 *      創建類型對應的一個對象 --> 對象應用::實例方法名稱
 *     3. 構造方法引用的使用
 *      類型對象的構建過程 --> 類型名稱::new
 * </p>
 *
 * @author <a href="http://blog.csdn.net/muwenbin_flex">大牧莫邪</a>
 * @version 1.00
 */
public class Test {

    public static void main(String[] args) {
       // 存儲Person對象的列表
       List<Person> personList = new ArrayList<>();
       personList.add(new Person("tom", "男", 16));
       personList.add(new Person("jerry", "女", 15));
       personList.add(new Person("shuke", "男", 30));
       personList.add(new Person("beita", "女", 26));
       personList.add(new Person("damu", "男", 32));

       // 1. 匿名內部類實現方式
       Collections.sort(personList, new Comparator<Person>() {
           @Override
           public int compare(Person o1, Person o2) {
               return o1.getAge() - o2.getAge();
           }
       });
       System.out.println(personList);

       // 2. lambda表達式的實現方式
       Collections.sort(personList, (p1, p2) -> p1.getAge() - p2.getAge());

       // 3. 靜態方法引用
       Collections.sort(personList, Person::compareByAge);

       // 4. 實例方法引用
       PersonUtil pu = new PersonUtil();
       Collections.sort(personList, pu::compareByName);
       System.out.println("tom".hashCode());
       System.out.println("jerry".hashCode());
       System.out.println(personList);

       // 5. 構造方法引用：綁定函數式接口
       IPerson ip = Person::new;
       Person person = ip.initPerson("jerry", "男", 22);
       System.out.println(person);
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class Person {
   private String name;    // 姓名
   private String gender;  // 性別
   private int age;        // 年齡

   public static int compareByAge(Person p1, Person p2) {
       return p1.getAge() - p2.getAge();
   }
}

class PersonUtil {
   // 增加一個實例方法
   public int compareByName(Person p1, Person p2) {
       return p1.getName().hashCode() - p2.getName().hashCode();
   }
}

interface IPerson {
   // 抽象方法：通過指定類型的構造方法初始化對象數據
   Person initPerson(String name, String gender, int age);
}

package com.imooc.test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Copyright (C), 2018-2019, copyright info. DAMU., Ltd.
 * FileName: com.test Test2
 * <p>Stream概述</p>
 *
 * @author <a href="http://blog.csdn.net/muwenbin_flex">大牧莫邪</a>
 * @version 1.00
 */
public class Test2 {
    public static void main(String[] args) {
        // 1. 添加測試數據：存儲多個賬號的列表
        List<String> accounts = new ArrayList<String>();
        accounts.add("tom");
        accounts.add("jerry");
        accounts.add("beita");
        accounts.add("shuke");
        accounts.add("damu");

        // 1.1. 業務要求：長度大於等於5的有效賬號
        for (String account : accounts) {
            if (account.length() >= 5) {
                System.out.println("有效賬號："  + account);
            }
        }

        // 1.2. 迭代方式進行操作
        Iterator<String> it = accounts.iterator();
        while(it.hasNext()) {
            String account = it.next();
            if (account.length() >= 5) {
                System.out.println("it有效賬號：" + account);
            }
        }

        // 1.3. Stream結合lambda表達式，完成業務處理
        List validAccounts = accounts.stream().filter(s->s.length()>=5).collect(Collectors.toList());
        System.out.println(validAccounts);

    }
}

package com.imooc.test;

import java.io.BufferedReader;

/**
 * Copyright (C), 2018-2019, copyright info. DAMU., Ltd.
 * FileName: com.imooc.test Test3
 * <p>Stream常見操作API介紹
 *  1. 聚合操作
 *
 *  2. stream的處理流程
 *      數據源
 *      數據轉換
 *      獲取結果
 *  3. 獲取Stream對象
 *      1. 從集合或者數組中獲取[**]
 *          Collection.stream()，如accounts.stream()
 *          Collection.parallelStream()
 *          Arrays.stream(T t)
 *      2. BufferReader
 *          BufferReader.lines()-> stream()
 *      3. 靜態工廠
 *          java.util.stream.IntStream.range()..
 *          java.nio.file.Files.walk()..
 *      4. 自定構建
 *          java.util.Spliterator
 *      5. 更多的方式..
 *          Random.ints()
 *          Pattern.splitAsStream()..
 *   4. 中間操作API{intermediate}
 *      操作結果是一個Stream，中間操作可以有一個或者多個連續的中間操作，需要注意的是，中間操作
 *          只記錄操作方式，不做具體執行，直到結束操作發生時，才做數據的最終執行。
 *          中間操作：就是業務邏輯處理。
 *      中間操作過程：無狀態：數據處理時，不受前置中間操作的影響。
 *                      map/filter/peek/parallel/sequential/unordered
 *                  有狀態：數據處理時，受到前置中間操作的影響。
 *                      distinct/sorted/limit/skip
 *   5. 終結操作|結束操作{Terminal}
 *      需要注意：一個Stream對象，只能有一個Terminal操作，這個操作一旦發生，就會真實處理數據，生成對應的處理結果。
 *      終結操作：非短路操作：當前的Stream對象必須處理完集合中所有 數據，才能得到處理結果。
 *                  forEach/forEachOrdered/toArray/reduce/collect/min/max/count/iterator
 *              短路操作：當前的Stream對象在處理過程中，一旦滿足某個條件，就可以得到結果。
 *                  anyMatch/allMatch/noneMatch/findFirst/findAny等
 *                  Short-circuiting，無限大的Stream-> 有限大的Stream。
 * </p>
 *
 * @author <a href="http://blog.csdn.net/muwenbin_flex">大牧莫邪</a>
 * @version 1.00
 */
public class Test3 {}

package com.imooc.test;

import java.util.*;
import java.util.stream.Stream;

/**
 * Copyright (C), 2018-2019, copyright info. DAMU., Ltd.
 * FileName: com.imooc.text Test1
 * <p>集合元素的常見操作</p>
 *
 * @author <a href="http://blog.csdn.net/muwenbin_flex">大牧莫邪</a>
 * @version 1.00
 */
public class Test1 {

    public static void main(String[] args) {
        // 1. 批量數據 -> Stream對象
        // 多個數據
        Stream stream = Stream.of("admin", "tom", "damu");

        // 數組
        String [] strArrays = new String[] {"xueqi", "biyao"};
        Stream stream2 = Arrays.stream(strArrays);

        // 列表
        List<String> list = new ArrayList<>();
        list.add("少林");
        list.add("武當");
        list.add("青城");
        list.add("崆峒");
        list.add("峨眉");
        Stream stream3 = list.stream();

        // 集合
        Set<String> set = new HashSet<>();
        set.add("少林羅漢拳");
        set.add("武當長拳");
        set.add("青城劍法");
        Stream stream4 = set.stream();

        // Map
        Map<String, Integer> map = new HashMap<>();
        map.put("tom", 1000);
        map.put("jerry", 1200);
        map.put("shuke", 1000);
        Stream stream5 = map.entrySet().stream();

        // 2. Stream對象對於基本數據類型的功能封裝
        // int / long / double
//        IntStream.of(new int[] {10, 20, 30}).forEach(System.out::println);
//        IntStream.range(1, 5).forEach(System.out::println);
//        IntStream.rangeClosed(1, 5).forEach(System.out::println);

        // 3. Stream對象 --> 轉換得到指定的數據類型
        // 數組
//        Object [] objx = stream.toArray(String[]::new);

        // 字符串
//        String str = stream.collect(Collectors.joining()).toString();
//        System.out.println(str);

        // 列表
//        List<String> listx = (List<String>) stream.collect(Collectors.toList());
//        System.out.println(listx);

        // 集合
//        Set<String> setx = (Set<String>) stream.collect(Collectors.toSet());
//        System.out.println(setx);

        // Map
//        Map<String, String> mapx = (Map<String, String>) stream.collect(Collectors.toMap(x->x, y->"value:"+y));
//        System.out.println(mapx);

        // 4. Stream中常見的API操作
        List<String> accountList = new ArrayList<>();
        accountList.add("xongjiang");
        accountList.add("lujunyi");
        accountList.add("wuyong");
        accountList.add("linchong");
        accountList.add("luzhishen");
        accountList.add("likui");
        accountList.add("wusong");

        // map() 中間操作，map()方法接收一個Functional接口
//        accountList = accountList.stream().map(x->"梁山好漢:" + x).collect(Collectors.toList());

        // filter() 添加過濾條件，過濾符合條件的用戶
//        accountList = accountList.stream().filter(x-> x.length() > 5).collect(Collectors.toList());

        // forEach 增強型循環
//        accountList.forEach(x-> System.out.println("forEach->" + x));
//        accountList.forEach(x-> System.out.println("forEach->" + x));
//        accountList.forEach(x-> System.out.println("forEach->" + x));

        // peek() 中間操作，迭代數據完成數據的依次處理過程
//        accountList.stream()
//                .peek(x -> System.out.println("peek 1: " + x))
//                .peek(x -> System.out.println("peek 2:" + x))
//                .forEach(System.out::println);

//        accountList.forEach(System.out::println);

        // Stream中對於數字運算的支持
        List<Integer> intList = new ArrayList<>();
        intList.add(20);
        intList.add(19);
        intList.add(7);
        intList.add(8);
        intList.add(86);
        intList.add(11);
        intList.add(3);
        intList.add(20);

        // skip() 中間操作，有狀態，跳過部分數據
//        intList.stream().skip(3).forEach(System.out::println);

        // limit() 中間操作，有狀態，限制輸出數據量
//        intList.stream().skip(3).limit(2).forEach(System.out::println);

        // distinct() 中間操作，有狀態，剔除重複的數據
//        intList.stream().distinct().forEach(System.out::println);

        // sorted() 中間操作，有狀態，排序

        // max() 獲取最大值
        Optional optional = intList.stream().max((x, y)-> x-y);
        System.out.println(optional.get());
        
        // min() 獲取最小值 類似 max()
        // ……

        // reduce() 合併處理數據
        Optional optional2 = intList.stream().reduce((sum, x)-> sum + x);
        System.out.println(optional2.get());
    }
}

 

package com.imooc.performance;

import java.util.*;

public class Test {

    public static void main(String[] args) {

        Random random = new Random();
        // 1. 基本數據類型：整數
//        List<Integer> integerList = new ArrayList<Integer>();
//
//        for(int i = 0; i < 1000000; i++) {
//            integerList.add(random.nextInt(Integer.MAX_VALUE));
//        }
//
//        // 1) stream
//        testStream(integerList);
//        // 2) parallelStream
//        testParallelStream(integerList);
//        // 3) 普通for
//        testForloop(integerList);
//        // 4) 增強型for
//        testStrongForloop(integerList);
//        // 5) 迭代器
//        testIterator(integerList);

        // 2. 複雜數據類型：對象
        List<Product> productList = new ArrayList<>();
        for(int i = 0; i < 1000000; i++) {
            productList.add(new Product("pro" + i, i, random.nextInt(Integer.MAX_VALUE)));
        }

        // 調用執行
        testProductStream(productList);
        testProductParallelStream(productList);
        testProductForloop(productList);
        testProductStrongForloop(productList);
        testProductIterator(productList);

    }

    public static void testStream(List<Integer> list) {
        long start = System.currentTimeMillis();

        Optional optional = list.stream().max(Integer::compare);
        System.out.println(optional.get());

        long end = System.currentTimeMillis();
        System.out.println("testStream:" + (end - start) + "ms");
    }

    public static void testParallelStream(List<Integer> list) {
        long start = System.currentTimeMillis();

        Optional optional = list.parallelStream().max(Integer::compare);
        System.out.println(optional.get());

        long end = System.currentTimeMillis();
        System.out.println("testParallelStream:" + (end - start) + "ms");
    }

    public static void testForloop(List<Integer> list) {
        long start = System.currentTimeMillis();

        int max = Integer.MIN_VALUE;
        for(int i = 0; i < list.size(); i++) {
            int current = list.get(i);
            if (current > max) {
                max = current;
            }
        }
        System.out.println(max);

        long end = System.currentTimeMillis();
        System.out.println("testForloop:" + (end - start) + "ms");
    }

    public static void testStrongForloop(List<Integer> list) {
        long start = System.currentTimeMillis();

        int max = Integer.MIN_VALUE;
        for (Integer integer : list) {
            if(integer > max) {
                max = integer;
            }
        }
        System.out.println(max);

        long end = System.currentTimeMillis();
        System.out.println("testStrongForloop:" + (end - start) + "ms");
    }

    public static void testIterator(List<Integer> list) {
        long start = System.currentTimeMillis();

        Iterator<Integer> it = list.iterator();
        int max = it.next();

        while(it.hasNext()) {
            int current = it.next();
            if(current > max) {
                max = current;
            }
        }
        System.out.println(max);

        long end = System.currentTimeMillis();
        System.out.println("testIterator:" + (end - start) + "ms");
    }


    public static void testProductStream(List<Product> list) {
        long start = System.currentTimeMillis();

        Optional optional = list.stream().max((p1, p2)-> p1.hot - p2.hot);
        System.out.println(optional.get());

        long end = System.currentTimeMillis();
        System.out.println("testProductStream:" + (end - start) + "ms");
    }

    public static void testProductParallelStream(List<Product> list) {
        long start = System.currentTimeMillis();

        Optional optional = list.stream().max((p1, p2)-> p1.hot - p2.hot);
        System.out.println(optional.get());

        long end = System.currentTimeMillis();
        System.out.println("testProductParallelStream:" + (end - start) + "ms");
    }

    public static void testProductForloop(List<Product> list) {
        long start = System.currentTimeMillis();

        Product maxHot = list.get(0);
        for(int i = 0; i < list.size(); i++) {
            Product current = list.get(i);
            if (current.hot > maxHot.hot) {
                maxHot = current;
            }
        }
        System.out.println(maxHot);

        long end = System.currentTimeMillis();
        System.out.println("testProductForloop:" + (end - start) + "ms");
    }

    public static void testProductStrongForloop(List<Product> list) {
        long start = System.currentTimeMillis();

        Product maxHot = list.get(0);
        for (Product product : list) {
            if(product.hot > maxHot.hot) {
                maxHot = product;
            }
        }
        System.out.println(maxHot);

        long end = System.currentTimeMillis();
        System.out.println("testProductStrongForloop:" + (end - start) + "ms");
    }

    public static void testProductIterator(List<Product> list) {
        long start = System.currentTimeMillis();

        Iterator<Product> it = list.iterator();
        Product maxHot = it.next();

        while(it.hasNext()) {
            Product current = it.next();
            if (current.hot > maxHot.hot) {
                maxHot = current;
            }
        }
        System.out.println(maxHot);

        long end = System.currentTimeMillis();
        System.out.println("testProductIterator:" + (end - start) + "ms");
    }

}

class Product {
    String name;    // 名稱
    Integer stock;  // 庫存
    Integer hot;    // 熱度

    public Product(String name, Integer stock, Integer hot) {
        this.name = name;
        this.stock = stock;
        this.hot = hot;
    }
}

package com.imooc.performance;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class Test2 {

    public static void main(String[] args) {
        // 整數列表
        List<Integer> lists = new ArrayList<Integer>();
        
        // 增加數據
        for (int i = 0; i < 1000; i++){
            lists.add(i);
        }

        // 串行Stream
        List<Integer> list2 = new ArrayList<>();
        lists.stream().forEach(x->list2.add(x));
        System.out.println(lists.size());
        System.out.println(list2.size());
        
        // 並行Stream
        List<Integer> list3 = new ArrayList<>();
        lists.parallelStream().forEach(x-> list3.add(x));
        System.out.println(list3.size());

        List<Integer> list4 = lists.parallelStream().collect(Collectors.toList());
        System.out.println(list4.size());
    }
}