Lambda 與函數式程式設計

/** * 把「要執行的工作」包成一個具名類別。 * 缺點：為了一段簡單邏輯，卻要多寫一個完整類別，非常囉嗦。 */ public class NamedClassDemo

// 實作 Runnable 介面的具名類別 static class PrintTask implements Runnable @Override public void run() // 唯一要實作的抽象方法 System.out.println("以具名類別執行工作");

public static void main(String[] args) Runnable task = new PrintTask(); // 先建立物件 task.run(); // 再呼叫其行為

/** * 匿名類別：就地實作介面並建立物件，不必替類別命名。 * 缺點：new Runnable、@Override、run() 這些樣板仍然佔滿版面。 */ public class AnonymousClassDemo public static void main(String[] args) // 一次完成「實作介面」與「建立物件」 Runnable task = new Runnable() @Override public void run() System.out.println("以匿名類別執行工作"); ; task.run();

/** * Lambda 運算式：只保留參數列與主體，其餘由編譯器推斷。 * run 沒有參數，所以左側是一對空括號。 */ public class LambdaDemo public static void main(String[] args) // () 對應 run 的空參數列，-> 右側是方法主體 Runnable task = () -> System.out.println("以 Lambda 執行工作"); task.run();

/** * 自訂函數式介面：代表「對兩個整數做某種運算」。 * @FunctionalInterface 讓編譯器強制檢查：有且僅有一個抽象方法。 */ @FunctionalInterface interface Calculator

int apply(int a, int b); // 唯一的抽象方法

// 函數式介面「可以」有預設方法與靜態方法，不影響其函數式本質 default Calculator andThenNegate() // 先做原運算，再把結果取負號；回傳一個新的 Calculator return (a, b) -> -this.apply(a, b);

public class CalculatorDemo

public static void main(String[] args)

// 同一個介面，用不同 Lambda 表達不同運算邏輯 Calculator add = (a, b) -> a + b; Calculator multiply = (a, b) -> a * b;

System.out.println("3 + 5 = " + add.apply(3, 5)); System.out.println("3 * 5 = " + multiply.apply(3, 5)); // 呼叫預設方法，得到「相乘後取負」的新運算 System.out.println("-(3 * 5) = " + multiply.andThenNegate().apply(3, 5));

import java.util.function.Function;

/** * 示範 Function 的轉換與兩種組合方向。 * andThen(g)：先 this 再 g；compose(g)：先 g 再 this。 */ public class FunctionDemo

public static void main(String[] args)

Function<Integer, Integer> timesTwo = x -> x * 2; // 乘以 2 Function<Integer, Integer> plusTen = x -> x + 10; // 加 10

// 直接套用 System.out.println("timesTwo(5) = " + timesTwo.apply(5));

// andThen：先乘 2（5->10）再加 10（10->20） Function<Integer, Integer> f1 = timesTwo.andThen(plusTen); System.out.println("先乘2再加10：" + f1.apply(5));

// compose：先加 10（5->15）再乘 2（15->30） Function<Integer, Integer> f2 = timesTwo.compose(plusTen); System.out.println("先加10再乘2：" + f2.apply(5));

import java.util.function.Predicate;

/** * 用 Predicate 表達條件，並用 and/or/negate 組合。 */ public class PredicateDemo

public static void main(String[] args)

Predicate<Integer> isPositive = n -> n > 0; // 是否為正 Predicate<Integer> isEven = n -> n

// and：兩者皆成立 Predicate<Integer> positiveEven = isPositive.and(isEven); // or：任一成立；negate：反向 Predicate<Integer> positiveOrEven = isPositive.or(isEven); Predicate<Integer> notPositive = isPositive.negate();

System.out.println("6 是正偶數？" + positiveEven.test(6)); System.out.println("-4 是正數或偶數？" + positiveOrEven.test(-4)); System.out.println("-4 非正數？" + notPositive.test(-4));

import java.util.function.Consumer; import java.util.function.Supplier;

/** * Consumer 消費值、Supplier 供應值。 * Supplier 的「延遲」特性在需要昂貴運算時特別有用。 */ public class ConsumerSupplierDemo

public static void main(String[] args)

// Consumer：接收字串並印出；andThen 串接第二個動作 Consumer<String> print = s -> System.out.println("內容：" + s); Consumer<String> printLen = s -> System.out.println("長度：" + s.length()); print.andThen(printLen).accept("Java");

// Supplier：呼叫 get() 時才真正產生值（此處為目前時間毫秒） Supplier<Long> now = () -> System.currentTimeMillis(); System.out.println("時間戳記非空？" + (now.get() > 0));

import java.util.ArrayList; import java.util.List; import java.util.function.BiFunction; import java.util.function.Function; import java.util.function.Supplier;

/** * 完整示範四種方法參考，並附上等價的 Lambda 對照。 */ public class MethodRefDemo

public static void main(String[] args)

// 1. 靜態方法參考：Integer.parseInt(String) Function<String, Integer> parse = Integer::parseInt; System.out.println("parse(4̈2)̈ = " + parse.apply("42"));

// 2. 特定物件的實體方法：對 System.out 呼叫 println java.io.PrintStream out = System.out; java.util.function.Consumer<String> printer = out::println; printer.accept("特定物件的方法參考");

// 3. 任意物件的實體方法：把輸入字串當接收者呼叫 length Function<String, Integer> length = String::length; System.out.println("length(J̈ava)̈ = " + length.apply("Java"));

// 4. 建構子參考：() -> new ArrayList<>() Supplier<List<String>> maker = ArrayList::new; List<String> list = maker.get(); list.add("由建構子參考產生的清單"); System.out.println(list);

// 補充：兩參數方法可用 BiFunction，如 Integer::sum BiFunction<Integer, Integer, Integer> sum = Integer::sum; System.out.println("sum(3, 4) = " + sum.apply(3, 4));

import java.util.function.Supplier;

/** * Lambda 捕獲外部區域變數 prefix。 * prefix 宣告後未再被指派，屬於 effectively final，合法。 */ public class CaptureDemo

public static void main(String[] args)

String prefix = "編號-"; // 之後不再更動，實質不可變 int base = 100; // 同上

// Lambda 捕獲 prefix 與 base，記住它們當下的值 Supplier<String> gen = () -> prefix + (base + 1); System.out.println(gen.get());

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

/** * 用 Comparator 的函數式組合，對員工做多鍵排序： * 先依部門升冪，同部門再依薪資降冪。 */ public class ComparatorDemo

// record 是不可變資料載體，第 8 章會深入介紹 record Employee(String name, String dept, int salary)

public static void main(String[] args)

List<Employee> staff = new ArrayList<>(List.of( new Employee("Alice", "研發", 90000), new Employee("Bob", "研發", 85000), new Employee("Cathy", "行銷", 95000), new Employee("David", "行銷", 95000)));

// 主鍵：部門升冪；次鍵：薪資降冪；末鍵：姓名升冪 Comparator<Employee> order = Comparator.comparing(Employee::dept) .thenComparing( Comparator.comparingInt(Employee::salary) .reversed()) .thenComparing(Employee::name);

staff.sort(order); // 就地排序 staff.forEach(e -> System.out.println( e.dept() + " | " + e.salary() + " | " + e.name()));

import java.util.Optional;

/** * 示範 Optional 的建立與 map/filter/orElse。 */ public class OptionalBasics

/** 模擬「依 id 查使用者名稱」，查無資料時回傳空 Optional */ static Optional<String> findName(int id) // ofNullable：把可能為 null 的結果安全包起來 return Optional.ofNullable(id == 1 ? "Alice" : null);

public static void main(String[] args)

// map：有值才轉換（轉大寫）；filter：有值且符合條件才保留 String r1 = findName(1) .map(String::toUpperCase) .filter(s -> s.length() > 3) .orElse("（不符合條件）"); System.out.println("id=1：" + r1);

// 查無資料時，整條鏈路都被跳過，最後回傳預設值 String r2 = findName(99) .map(String::toUpperCase) .orElse("（查無此人）"); System.out.println("id=99：" + r2);

import java.util.Optional;

/** * 對比 orElse 與 orElseGet 的求值時機。 * 即使 Optional 有值，orElse 的參數仍會被求值（副作用照樣發生）。 */ public class OrElseVsOrElseGet

/** 模擬昂貴的預設值運算，順便印出以觀察是否被呼叫 */ static String expensiveDefault() System.out.println(">> 產生預設值（昂貴運算被呼叫了）"); return "預設值";

public static void main(String[] args)

Optional<String> present = Optional.of("實際值");

System.out.println("— 使用 orElse —"); // 即使有值，expensiveDefault() 仍被呼叫（浪費） System.out.println("結果：" + present.orElse(expensiveDefault()));

System.out.println("— 使用 orElseGet —"); // 有值，所以 Supplier 完全不會被呼叫（高效） System.out.println("結果：" + present.orElseGet( OrElseVsOrElseGet::expensiveDefault));

import java.util.function.Predicate;

/** * 用 Predicate 組合打造密碼驗證器。 * 每條規則獨立、可重用、可自由組合，體現「開放封閉原則」。 */ public class PasswordValidator

public static void main(String[] args)

// 三條獨立規則 Predicate<String> longEnough = p -> p.length() >= 8; Predicate<String> hasDigit = p -> p.chars().anyMatch(Character::isDigit); Predicate<String> hasUpper = p -> p.chars().anyMatch(Character::isUpperCase);

// 用 and 把三條規則組合成一條完整規則 Predicate<String> valid = longEnough.and(hasDigit).and(hasUpper);

// 逐一驗證測試資料 for (String pwd : new String[]"abc", "abcdefgh", "Abcdef12") System.out.println(pwd + " → " + (valid.test(pwd) ? "通過" : "不通過"));