// Function 接口的泛型，第一個(gè)參數(shù)是入?yún)㈩愋?，第二個(gè)參數(shù)是出參類型
// Function 接口只有一個(gè)抽象方法，就是 apply()，下面利用 Lambda 表達(dá)式實(shí)現(xiàn)這個(gè)抽象方法并創(chuàng)建 Function 對象
Function<Integer, String> function = num -> "GTA" + num;
// 將5這個(gè)參數(shù)傳遞給function，得到返回結(jié)果
String result = function.apply(5);
System.out.println(result); // 打?。篏TA5

// 定義兩個(gè) Function 對象進(jìn)行相關(guān)轉(zhuǎn)換操作
Function<String, String> upperCase = s -> s.toUpperCase();
Function<String, String> addPostfix = s -> s + "5";
// 鏈?zhǔn)秸{(diào)用，將 gta 這個(gè)字符串參數(shù)先傳遞 upperCase 這個(gè)函數(shù)進(jìn)行操作，然后將得到的結(jié)果傳遞給 addPostfix 函數(shù)進(jìn)行操作，得到返回結(jié)果
String str = upperCase.andThen(addPostfix).apply("gta");
System.out.println(str); // 打?。篏TA5

Function<String, String> identity = Function.identity();
String result = identity.apply("hello"); // result is "hello"

// Consumer 接口，泛型參數(shù)是入?yún)㈩愋停邮芤粋€(gè)參數(shù)，并不返回結(jié)果，相當(dāng)于消費(fèi)了這個(gè)參數(shù)
Consumer<String> consumer = s -> System.out.println(s);
consumer.accept("我輸入什么就打印什么"); // 打?。何逸斎胧裁淳痛蛴∈裁?

Consumer<String> first = s -> System.out.println(s + 5);
Consumer<String> second = s -> System.out.println(s + 6);
// 先執(zhí)行 first 這個(gè) Consumer，接著執(zhí)行 second 這個(gè) Consumer
Consumer<String> combination = first.andThen(second);
combination.accept("GTA"); // 打印：GTA5 GTA6

// Supplier 接口，泛型參數(shù)是出參類型，不接受參數(shù)，但是會(huì)提供結(jié)果，相當(dāng)于生產(chǎn)了某個(gè)東西
Supplier<String> supplier = () -> "提供一個(gè)我隨便打的字符串給調(diào)用方";
String text = supplier.get();
System.out.println(text); // 打印：提供一個(gè)我隨便打的字符串給調(diào)用方

// Predicate 接口，泛型參數(shù)是入?yún)㈩愋?，返回布爾?
Predicate<String> predicate = s -> s.contains("god23bin");
boolean flag = predicate.test("god23bin能給你帶來收獲嗎？");
System.out.println("god23bin能給你帶來收獲嗎？" + flag); // 打?。篻od23bin能給你帶來收獲嗎？true

Predicate<String> startsWithA = (str) -> str.startsWith("A"); // 如果傳入的字符串是A開頭，則返回 true
Predicate<String> endsWithZ = (str) -> str.endsWith("Z"); // 如果傳入的字符串是Z結(jié)尾，則返回 true

Predicate<String> startsWithAAndEndsWithZ = startsWithA.and(endsWithZ);
System.out.println(startsWithAAndEndsWithZ.test("ABCDEFZ")); // true
System.out.println(startsWithAAndEndsWithZ.test("BCDEFGH")); // false

Predicate<String> notStartsWithA = startsWithA.negate();
System.out.println(notStartsWithA.test("ABCDEF")); // false
System.out.println(notStartsWithA.test("BCDEFGH")); // true

Predicate<String> startsWithAOrEndsWithZ = startsWithA.or(endsWithZ);
System.out.println(startsWithAOrEndsWithZ.test("ABCDEF")); // true
System.out.println(startsWithAOrEndsWithZ.test("BCDEFGH")); // false

// map 方法，將 T 類型的值轉(zhuǎn)換成 R 類型的值
// R 是返回的 Stream 流的元素類型，T 是原先 Stream 流的元素類型
<R> Stream<R> map(Function<? super T, ? extends R> mapper);

// forEach 方法，遍歷 Stream 流中的元素，T 類型是 Stream 流的元素類型
void forEach(Consumer<? super T> action);

// 生成一個(gè)無限長度的 Stream 流
public static<T> Stream<T> generate(Supplier<T> s) {
    Objects.requireNonNull(s);
    return StreamSupport.stream(
        new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s), false);
}

// 過濾出 Stream 流中，判斷結(jié)果為 true 的元素
Stream<T> filter(Predicate<? super T> predicate);