/**
 * 傳統(tǒng)方式：過(guò)濾數(shù)組
 * 問(wèn)題：邏輯相似但行為不同時(shí)，需重復(fù)編寫(xiě)代碼
 */
public class ArrayHandler {
    // 過(guò)濾偶數(shù)
    public static int[] filterEvenNumbers(int[] array) {
        int[] result = new int[array.length];
        int index = 0;
        for (int num : array) {
            if (num % 2 == 0) { // 核心判斷：偶數(shù)
                result[index++] = num;
            }
        }
        return Arrays.copyOf(result, index);
    }
    // 過(guò)濾大于10的數(shù)
    public static int[] filterNumbersGreaterThan10(int[] array) {
        int[] result = new int[array.length];
        int index = 0;
        for (int num : array) {
            if (num > 10) { // 核心判斷：大于10
                result[index++] = num;
            }
        }
        return Arrays.copyOf(result, index);
    }
}

// 框架方法：接收“判斷邏輯”作為參數(shù)
public static int[] filter(int[] array, FilterRule rule) {
    // 框架邏輯（遍歷、存儲(chǔ)）
    int[] result = new int[array.length];
    int index = 0;
    for (int num : array) {
        if (rule.test(num)) { // 調(diào)用傳遞進(jìn)來(lái)的“判斷邏輯”
            result[index++] = num;
        }
    }
    return Arrays.copyOf(result, index);
}

// 過(guò)濾偶數(shù)：傳遞“偶數(shù)判斷”邏輯
int[] evens = filter(array, num -> num % 2 == 0);
// 過(guò)濾大于10的數(shù)：傳遞“大于10判斷”邏輯
int[] greaterThan10 = filter(array, num -> num > 10);

/**
 * 函數(shù)式接口示例：定義“過(guò)濾規(guī)則”
 * 只包含一個(gè)抽象方法test，用于封裝“判斷邏輯”
 */
@FunctionalInterface // 標(biāo)記為函數(shù)式接口（可選，編譯器會(huì)校驗(yàn)）
interface FilterRule {
    // 抽象方法：接收int參數(shù)，返回boolean（判斷結(jié)果）
    boolean test(int num);
    // 允許包含默認(rèn)方法（非抽象）
    default void printRule() {
        System.out.println("執(zhí)行過(guò)濾規(guī)則");
    }
}

// 函數(shù)式接口：封裝“字符串處理”邏輯
@FunctionalInterface
interface StringProcessor {
    String process(String str);
}

/**
 * 框架方法：接收StringProcessor對(duì)象（封裝了處理邏輯）
 */
public static String handleString(String str, StringProcessor processor) {
    // 調(diào)用接口方法（執(zhí)行傳遞進(jìn)來(lái)的函數(shù)邏輯）
    return processor.process(str);
}

public static void main(String[] args) {
    String str = "  hello world  ";
    // 1. 傳遞“去除空格”邏輯（匿名內(nèi)部類）
    String trimmed = handleString(str, new StringProcessor() {
        @Override
        public String process(String s) {
            return s.trim(); // 去除首尾空格
        }
    });
    // 2. 傳遞“轉(zhuǎn)大寫(xiě)”邏輯（匿名內(nèi)部類）
    String upper = handleString(str, new StringProcessor() {
        @Override
        public String process(String s) {
            return s.toUpperCase(); // 轉(zhuǎn)為大寫(xiě)
        }
    });
    System.out.println(trimmed); // 輸出：hello world
    System.out.println(upper);   // 輸出：  HELLO WORLD  
}

(參數(shù)列表) -> { 函數(shù)體 }

public static void main(String[] args) {
    String str = "  hello world  ";
    // 1. 傳遞“去除空格”邏輯（Lambda簡(jiǎn)化）
    String trimmed = handleString(str, s -> s.trim());
    // 2. 傳遞“轉(zhuǎn)大寫(xiě)”邏輯（Lambda簡(jiǎn)化）
    String upper = handleString(str, s -> s.toUpperCase());
    // 3. 復(fù)雜邏輯（多行代碼）：需加{}和return
    String processed = handleString(str, s -> {
        String temp = s.trim();
        return temp.substring(0, 5); // 截取前5個(gè)字符
    });
    System.out.println(processed); // 輸出：hello
}

import java.util.function.Consumer;
public class ConsumerDemo {
    // 框架方法：接收數(shù)據(jù)和處理邏輯
    public static void processData(String data, Consumer<String> consumer) {
        consumer.accept(data); // 執(zhí)行傳遞的處理邏輯
    }
    public static void main(String[] args) {
        // 1. 傳遞“打印數(shù)據(jù)”邏輯
        processData("hello", s -> System.out.println("打?。? + s));
        // 2. 傳遞“拼接前綴”邏輯（無(wú)返回值，僅處理）
        processData("world", s -> {
            String result = "前綴_" + s;
            System.out.println("處理后：" + result);
        });
    }
}

import java.util.function.Function;
public class FunctionDemo {
    // 框架方法：接收數(shù)據(jù)和轉(zhuǎn)換邏輯
    public static <R> R transform(String data, Function<String, R> function) {
        return function.apply(data); // 執(zhí)行轉(zhuǎn)換邏輯
    }
    public static void main(String[] args) {
        // 1. 轉(zhuǎn)換為Integer（字符串轉(zhuǎn)數(shù)字）
        Integer num = transform("123", s -> Integer.parseInt(s));
        // 2. 轉(zhuǎn)換為長(zhǎng)度（字符串→整數(shù)）
        Integer length = transform("hello", s -> s.length());
        // 3. 轉(zhuǎn)換為大寫(xiě)（字符串→字符串）
        String upper = transform("hello", s -> s.toUpperCase());
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
public class PredicateDemo {
    // 框架方法：過(guò)濾集合
    public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
        List<T> result = new ArrayList<>();
        for (T item : list) {
            if (predicate.test(item)) { // 執(zhí)行判斷邏輯
                result.add(item);
            }
        }
        return result;
    }
    public static void main(String[] args) {
        List<String> list = List.of("a", "bb", "ccc", "dddd");
        // 1. 過(guò)濾長(zhǎng)度>2的字符串
        List<String> longStrs = filter(list, s -> s.length() > 2);
        System.out.println(longStrs); // 輸出：[ccc, dddd]
        // 2. 過(guò)濾包含"c"的字符串
        List<String> hasC = filter(list, s -> s.contains("c"));
        System.out.println(hasC); // 輸出：[ccc]
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamDemo {
    public static void main(String[] args) {
        List<User> users = Arrays.asList(
            new User("張三", 20),
            new User("李四", 17),
            new User("王五", 25)
        );
        // 1. 過(guò)濾成年用戶（年齡≥18）：傳遞Predicate<User>
        List<User> adults = users.stream()
            .filter(user -> user.getAge() >= 18) // 傳遞過(guò)濾邏輯
            .collect(Collectors.toList());
        // 2. 提取用戶名（轉(zhuǎn)換為String列表）：傳遞Function<User,String>
        List<String> names = users.stream()
            .map(user -> user.getName()) // 傳遞轉(zhuǎn)換邏輯
            .collect(Collectors.toList());
        // 3. 打印用戶信息：傳遞Consumer<User>
        users.forEach(user -> System.out.println(user.getName() + "：" + user.getAge()));
    }
    // 實(shí)體類
    static class User {
        private String name;
        private int age;
        // 構(gòu)造器、getter
        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public String getName() { return name; }
        public int getAge() { return age; }
    }
}

import java.util.Scanner;
/**
 * 模擬按鈕點(diǎn)擊事件：點(diǎn)擊后執(zhí)行傳遞的邏輯
 */
public class EventDemo {
    // 按鈕類：接收“點(diǎn)擊事件處理邏輯”
    static class Button {
        // 存儲(chǔ)回調(diào)函數(shù)（點(diǎn)擊時(shí)執(zhí)行）
        private Runnable onClick;
        // 設(shè)置點(diǎn)擊事件邏輯（接收Runnable函數(shù)式接口）
        public void setOnClick(Runnable onClick) {
            this.onClick = onClick;
        }
        // 模擬點(diǎn)擊（觸發(fā)回調(diào)）
        public void click() {
            if (onClick != null) {
                onClick.run(); // 執(zhí)行傳遞的邏輯
            }
        }
    }
    public static void main(String[] args) {
        Button button = new Button();
        // 設(shè)置點(diǎn)擊邏輯（傳遞Runnable函數(shù)）
        button.setOnClick(() -> {
            System.out.println("按鈕被點(diǎn)擊！");
            System.out.println("執(zhí)行提交表單邏輯...");
        });
        // 模擬用戶點(diǎn)擊
        System.out.println("請(qǐng)輸入任意字符模擬點(diǎn)擊：");
        new Scanner(System.in).next(); // 等待輸入
        button.click(); // 輸出點(diǎn)擊邏輯
    }
}

import java.util.function.Predicate;
/**
 * 通用校驗(yàn)工具：支持不同校驗(yàn)規(guī)則
 */
public class Validator<T> {
    // 校驗(yàn)數(shù)據(jù)：接收數(shù)據(jù)和校驗(yàn)規(guī)則
    public boolean validate(T data, Predicate<T> rule) {
        return rule.test(data);
    }
    public static void main(String[] args) {
        Validator<String> stringValidator = new Validator<>();
        // 1. 校驗(yàn)字符串非空
        boolean notEmpty = stringValidator.validate("test", s -> s != null && !s.isEmpty());
        // 2. 校驗(yàn)字符串長(zhǎng)度≥6
        boolean minLength6 = stringValidator.validate("123456", s -> s.length() >= 6);
        // 3. 校驗(yàn)手機(jī)號(hào)（簡(jiǎn)單規(guī)則）
        boolean isPhone = stringValidator.validate("13800138000", 
            s -> s.matches("1[3-9]\\d{9}"));
    }
}

// 錯(cuò)誤：包含兩個(gè)抽象方法，不是函數(shù)式接口
interface MyInterface {
    void method1();
    void method2(); // 第二個(gè)抽象方法
}
// 編譯報(bào)錯(cuò)：Lambda表達(dá)式無(wú)法匹配多個(gè)抽象方法
MyInterface obj = () -> System.out.println("test");

public class LambdaVariableDemo {
    public static void main(String[] args) {
        int count = 0; // 外部變量
        // 錯(cuò)誤：在Lambda中修改外部變量
        Runnable runnable = () -> {
            count++; // 編譯報(bào)錯(cuò)：變量count必須是final或有效final
        };
    }
}

// 不推薦：復(fù)雜邏輯用Lambda，可讀性差
Function<String, String> complexFunction = s -> {
    String temp = s.trim();
    if (temp.length() > 10) {
        temp = temp.substring(0, 10);
    }
    return temp.toUpperCase();
};

// 推薦：復(fù)雜邏輯單獨(dú)定義
public static String processString(String s) {
    String temp = s.trim();
    if (temp.length() > 10) {
        temp = temp.substring(0, 10);
    }
    return temp.toUpperCase();
}
// 通過(guò)方法引用傳遞（::表示引用方法）
Function<String, String> complexFunction = LambdaDemo::processString;

// 函數(shù)式接口：接收String，返回int
interface StringToInt {
    int convert(String s);
}
public class MethodReferenceDemo {
    // 方法：簽名（String→int）與StringToInt匹配
    public static int stringToLength(String s) {
        return s.length();
    }
    public static void main(String[] args) {
        // 方法引用：直接引用stringToLength方法
        StringToInt converter = MethodReferenceDemo::stringToLength;
        int length = converter.convert("hello"); // 輸出：5
    }
}