package com.example.notes.entity;

/**
 * 用户角色枚举
 */
public enum Role {
    ADMIN,
    MEMBER
}

package com.example.notes.entity;

import lombok.Value;
import java.time.LocalDateTime;

/**
 * 用户数据类 (使用 Lombok 简化的 POJO)
 * POJO: Plain Old Java Object
 */
@Value
// 使用@Value注解创建不可变的集合
public class User {
    long id;
    String name;
    int age;
    Role role;
    LocalDateTime registrationDate;
}

package com.example.notes.data;

import cn.hutool.core.date.DateUtil;
import com.example.notes.entity.Role;
import com.example.notes.entity.User;
import java.util.List;

/**
 * 模拟数据库，提供用户数据源
 */
public class UserDataSource {
    public static List<User> getUsers() {
        return List.of(
                new User(1L, "Alice", 28, Role.ADMIN, DateUtil.parseLocalDateTime("2023-09-15 00:00:00")),
                new User(2L, "Bob", 35, Role.MEMBER, DateUtil.parseLocalDateTime("2024-08-22 00:00:00")),
                new User(3L, "Charlie", 22, Role.MEMBER, DateUtil.parseLocalDateTime("2025-03-10 00:00:00")),
                new User(4L, "Diana", 42, Role.ADMIN, DateUtil.parseLocalDateTime("2023-11-05 00:00:00")),
                new User(5L, "Ethan", 31, Role.MEMBER, DateUtil.parseLocalDateTime("2025-06-20 00:00:00")),
                new User(6L, "Fiona", 29, Role.ADMIN, DateUtil.parseLocalDateTime("2024-02-15 00:00:00")));
    }
}

package com.example.notes.ch01;

import com.example.notes.data.UserDataSource;
import com.example.notes.entity.User;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class LambdaIntroduction {
    public static void main(String[] args) {
        // 必须拷贝一份，因为 Collections.sort 会修改原列表，而 List.of() 创建的是不可变列表
        List<User> userList = new ArrayList<>(UserDataSource.getUsers());

        // 排序行为：通过匿名内部类定义
        Comparator<User> sortByAge = new Comparator<User>() {
            @Override
            public int compare(User u1, User u2) {
                return Integer.compare(u1.getAge(), u2.getAge());
            }
        };

        Collections.sort(userList, sortByAge);
        System.out.println("按年龄排序后:");
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

// Lambda 表达式的不同形式：

// 1. 标准形式
(User u1, User u2) -> { return u1.getAge() - u2.getAge(); }
// - 完整的参数类型、大括号和 return。

// 2. 类型推断 (常用)
(u1, u2) -> { return u1.getAge() - u2.getAge(); }
// - 省略参数类型，编译器可根据上下文推断。

// 3. 单行方法体 (简洁)
(u1, u2) -> u1.getAge() - u2.getAge()
// - 方法体只有一行 return 语句时，省略大括号和 return。

// 4. 单参数 (更简洁)
user -> user.getAge() > 30
// - 只有一个参数时，省略参数列表的圆括号 ()。

package com.example.notes.ch01;

import cn.hutool.core.util.StrUtil;
import com.example.notes.data.UserDataSource;
import com.example.notes.entity.User;

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

public class LambdaIntroduction {
    public static void main(String[] args) {
        List<User> userList = new ArrayList<>(UserDataSource.getUsers());

        userList.sort((u1,u2) -> u1.getAge() - u2.getAge());

        System.out.println("使用 Lambda 按年龄排序后:");
        // 使用 forEach 和 Lambda 遍历输出
        userList.forEach(user -> System.out.println(user));
    }
}

package com.example.notes.ch01;


import com.example.notes.entity.Role;
import com.example.notes.entity.User;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class FunctionalInterfaceExample {

    public static void main(String[] args) {
        User testUser = new User(1L, "Alice", 28, Role.ADMIN, LocalDateTime.now());

        // 1. Predicate: 判断用户是否是管理员
        Predicate<User> isAdmin = user -> Role.ADMIN.equals(user.getRole());
        System.out.println("Alice 是管理员吗? " + isAdmin.test(testUser));

        // 2. Function: 获取用户名
        Function<User, String> getName = user -> user.getName();
        System.out.println("用户的姓名是: " + getName.apply(testUser));

        // 3. Consumer: 打印用户信息
        Consumer<User> printUser = user -> System.out.println("正在消费用户: " + user);
        printUser.accept(testUser);

        // 4. Supplier: 创建一个“游客”用户
        Supplier<User> guestFactory = () -> new User(0L, "Guest", 0, Role.MEMBER, LocalDateTime.now());
        System.out.println("创建的游客用户: " + guestFactory.get());

    }

}

package com.example.notes.ch01;

import com.example.notes.data.UserDataSource;
import com.example.notes.entity.User;

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

public class LambdaIntroduction {
    public static void main(String[] args) {
        List<User> userList = new ArrayList<>(UserDataSource.getUsers());

        // 最终优化版本：使用方法引用，代码意图最清晰
        userList.sort(Comparator.comparing(User::getAge));

        System.out.println("使用 Lambda 按年龄排序后:");
        // 使用 forEach 和 Lambda 遍历输出
        userList.forEach(user -> System.out.println(user));
    }
}

// 传统方式实现
List<User> adminUsers = new ArrayList<>();
for (User user : userList) {
    if (Role.ADMIN.equals(user.getRole())) {
        adminUsers.add(user);
    }
}
Collections.sort(adminUsers, new Comparator<User>() {
    @Override
    public int compare(User u1, User u2) {
        return Integer.compare(u2.getAge(), u1.getAge()); // 降序
    }
});
List<String> adminNames = new ArrayList<>();
for (User user : adminUsers) {
    adminNames.add(user.getName());
}

package com.example.notes.ch01;

import com.example.notes.data.UserDataSource;
import com.example.notes.entity.Role;
import com.example.notes.entity.User;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class StreamExample {
    public static void main(String[] args) {
        List<User> userList = UserDataSource.getUsers();

        // 使用 Stream API 一气呵成
        List<String> adminNames = userList.stream() // 1. 获取数据源
            .filter(user -> Role.ADMIN.equals(user.getRole())) // 2. 过滤：只保留 ADMIN
            .sorted(Comparator.comparingInt(User::getAge).reversed()) // 3. 排序：按年龄降序
            .map(User::getName) // 4. 映射：提取用户姓名
            .collect(Collectors.toList()); // 5. 收集：将结果汇集成 List

        System.out.println("排序后的管理员姓名: " + adminNames);
    }
}
// 输出: 
// 排序后的管理员姓名: [Diana, Fiona, Alice]

package com.example.notes.ch01;

import cn.hutool.core.collection.CollUtil;
import com.example.notes.data.UserDataSource;
import com.example.notes.entity.Role;
import com.example.notes.entity.User;
import java.util.List;
import java.util.Optional;

public class OptionalExample {
    public static Optional<User> findUserByName(List<User> users, String name) {
        // 通过 Hutool 封装一个 findOne 方法,用于查找列表中的其中一个用户
        return Optional.ofNullable(CollUtil.findOne(users, user -> user.getName().equalsIgnoreCase(name)));
    }

    public static void main(String[] args) {
        List<User> userList = UserDataSource.getUsers();

        // 场景1: 查找存在的用户 'Diana'
        System.out.println("--- 查找 'Diana' ---");
        Optional<User> dianaOpt = findUserByName(userList, "Diana");
        dianaOpt.ifPresent(user -> System.out.println("找到了! 年龄: " + user.getAge()));

        // 场景2: 查找不存在的用户 'Tom'
        System.out.println("\n--- 查找 'Tom' ---");
        User tom = findUserByName(userList, "Tom")
                .orElse(new User(0L, "Guest", 0, Role.MEMBER, null));
        System.out.println("查找结果: " + tom.getName());

        // 场景3: 链式调用获取可能不存在的属性
        Integer age = findUserByName(userList, "Bob")
                .map(User::getAge)
                .orElse(-1);
        System.out.println("\nBob 的年龄是: " + age);
    }
}
// 输出:
// --- 查找 'Diana' ---
// 找到了! 年龄: 42
// 
// --- 查找 'Tom' ---
// 查找结果: Guest
// 
// Bob 的年龄是: 35

package com.example.notes.entity;

import java.time.LocalDateTime;

/**
 * 用户数据类 (使用 Record 重构)
 * Record 提供了一种语言级的、用于创建不可变数据聚合的简洁语法。
 */
public record User(
    long id,
    String name,
    int age,
    Role role,
    LocalDateTime registrationDate
) {}

package com.example.notes.ch02;

import com.example.notes.data.UserDataSource;
import com.example.notes.entity.Role;
import com.example.notes.entity.User;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class VarExample {
    public static void main(String[] args) {
        // 场景1: 简化普通变量声明
        var userList = UserDataSource.getUsers();
        System.out.println("userList 的类型是 List: " + (userList instanceof List));

        // 场景2: 极大地简化复杂的泛型类型声明
        // 传统写法: Map<Role, List<User>> usersByRole = ...
        var usersByRole = userList.stream()
                .collect(Collectors.groupingBy(User::role));

        System.out.println("usersByRole 的类型是 Map: " + (usersByRole instanceof Map));
        
        // 场景3: 在 for-each 循环中使用
        System.out.println("\n管理员信息:");
        for (var user : usersByRole.get(Role.ADMIN)) {
            // 此处 user 的类型被正确推断为 User
            System.out.println(" - " + user.name());
        }
    }
}
// 输出:
// userList 的类型是 List: true
// usersByRole 的类型是 Map: true
//
// 管理员信息:
// - Alice
// - Diana
// - Fiona

package com.example.notes.entity;

/**
 * 定义一个密封接口 PaymentResult,
 * 它只允许 Success, Failure, 和 Pending 这三个类来实现。
 */
public sealed interface PaymentResult permits PaymentResult.Success, PaymentResult.Failure, PaymentResult.Pending {

    /**
     * 成功状态：使用 record 定义，包含交易ID和金额
     */
    record Success(String transactionId, long amount) implements PaymentResult {}

    /**
     * 失败状态：使用 record 定义，包含失败原因
     */
    record Failure(String reason) implements PaymentResult {}

    /**
     * 处理中状态：使用 record 定义，包含一个提示信息
     */
    record Pending(String message) implements PaymentResult {}
}

// 传统方式处理支付结果
PaymentResult result = ...;
if (result instanceof PaymentResult.Success) {
    PaymentResult.Success s = (PaymentResult.Success) result; // 手动强制转换
    System.out.println("支付成功，交易号: " + s.transactionId());
} else if (result instanceof PaymentResult.Failure) {
    PaymentResult.Failure f = (PaymentResult.Failure) result; // 手动强制转换
    System.err.println("支付失败，原因: " + f.reason());
} else if (result instanceof PaymentResult.Pending) {
    // ...
}

package com.example.notes.ch02;

import com.example.notes.entity.PaymentResult;

public class SwitchPatternExample {

    public static String handlePayment(PaymentResult result) {
        // 使用 switch 表达式进行模式匹配
        return switch (result) {
            // case 1: 匹配 Success 类型，并将结果绑定到变量 s
            case PaymentResult.Success s -> "支付成功! 交易号: " + s.transactionId() + ", 金额: " + s.amount();
            
            // case 2: 匹配 Failure 类型，并将结果绑定到变量 f
            case PaymentResult.Failure f -> "支付失败! 原因: " + f.reason();
            
            // case 3: 匹配 Pending 类型，并将结果绑定到变量 p
            case PaymentResult.Pending p -> "支付处理中... 信息: " + p.message();
            
            // case 4: 直接处理 null 输入
            case null -> "支付结果未知 (null)";
            
            // 由于 PaymentResult 是 sealed 类型，且我们已覆盖所有子类和 null,
            // 因此编译器知道这是“穷尽的”，无需 default 分支。
        };
    }

    public static void main(String[] args) {
        PaymentResult r1 = new PaymentResult.Success("TXN12345", 500L);
        PaymentResult r2 = new PaymentResult.Failure("余额不足");
        PaymentResult r3 = new PaymentResult.Pending("银行确认中");
        PaymentResult r4 = null;

        System.out.println(handlePayment(r1));
        System.out.println(handlePayment(r2));
        System.out.println(handlePayment(r3));
        System.out.println(handlePayment(r4));
    }
}
// 输出:
// 支付成功! 交易号: TXN12345, 金额: 500
// 支付失败! 原因: 余额不足
// 支付处理中... 信息: 银行确认中
// 支付结果未知 (null)

package com.example.notes.service;

import com.example.notes.entity.Role;
import com.example.notes.entity.User;
import java.util.Optional;

public interface UserService {

    /**
     * 这是一个抽象方法，任何实现类都必须提供自己的实现。
     * @param id 用户ID
     * @return 一个包含用户的 Optional，如果找不到则为空
     */
    Optional<User> findById(long id);

    /**
     * 这是一个默认方法，它依赖于上面的抽象方法 findById。
     * 它为所有实现类提供了一个开箱即用的、判断用户是否为管理员的功能。
     * @param id 用户ID
     * @return 如果是管理员则返回 true, 否则返回 false
     */
    default boolean isUserAdmin(long id) {
        // 直接调用接口内的抽象方法
        return findById(id)
                .map(user -> user.role() == Role.ADMIN) // 如果用户存在，检查其角色
                .orElse(false); // 如果用户不存在，默认为 false
    }
}

package com.example.notes.service;

import com.example.notes.data.UserDataSource;
import com.example.notes.entity.User;
import java.util.List;
import java.util.Optional;

/**
 * UserService 的一个基于内存的实现类
 */
public class InMemoryUserService implements UserService {
    private final List<User> users = UserDataSource.getUsers();

    @Override
    public Optional<User> findById(long id) {
        return users.stream()
                .filter(user -> user.id() == id)
                .findFirst();
    }
}

package com.example.notes.ch03;

import com.example.notes.service.InMemoryUserService;
import com.example.notes.service.UserService;

public class InterfaceExample {

    // 在 UserService 接口中添加一个静态工厂方法
    public interface UserService {
        // ... (原有的 findById 和 default isUserAdmin 方法)

        /**
         * 静态工厂方法，用于创建 UserService 的一个内存实现实例。
         * 调用方无需关心具体的实现类是哪个。
         * @return UserService 的一个实例
         */
        static UserService createInMemoryInstance() {
            return new InMemoryUserService();
        }
    }

    public static void main(String[] args) {
        // 通过接口的静态方法直接获取服务实例
        UserService service = UserService.createInMemoryInstance();

        // 调用实例方法
        System.out.println("查找ID为1的用户: " + service.findById(1L).orElse(null));

        // 调用从接口继承的 default 方法，无需在实现类中编写任何代码
        System.out.println("ID为1的用户是管理员吗? " + service.isUserAdmin(1L));
        System.out.println("ID为2的用户是管理员吗? " + service.isUserAdmin(2L));
    }
}
// 输出:
// 查找ID为1的用户: User[id=1, name=Alice, age=28, role=ADMIN, registrationDate=2023-09-15T00:00]
// ID为1的用户是管理员吗? true
// ID为2的用户是管理员吗? false

package com.example.notes.ch03;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class CollectionFactoryExample {
    public static void main(String[] args) {
        // 创建不可变 List
        List<String> names = List.of("Alice", "Bob", "Charlie");
        System.out.println("Immutable List: " + names);

        // 创建不可变 Set
        Set<Integer> numbers = Set.of(10, 20, 30);
        System.out.println("Immutable Set: " + numbers);
        
        // 创建不可变 Map
        Map<String, String> config = Map.of("version", "v1.2", "env", "prod");
        System.out.println("Immutable Map: " + config);

        // 尝试修改会抛出异常
        try {
            names.add("David");
        } catch (UnsupportedOperationException e) {
            System.out.println("\n尝试修改 List... 捕获到异常: " + e.getClass().getSimpleName());
        }
    }
}
// 输出:
// Immutable List: [Alice, Bob, Charlie]
// Immutable Set: [30, 20, 10]
// Immutable Map: {env=prod, version=v1.2}
//
// 尝试修改 List... 捕获到异常: UnsupportedOperationException

package com.example.notes.ch03;

import java.util.stream.Collectors;

public class StringExample {
    public static void main(String[] args) {
        // 1. isBlank()
        System.out.println("'  '.isBlank() = " + "  ".isBlank()); // true
        System.out.println("''.isBlank() = " + "".isBlank());   // true

        // 2. lines() 和 strip()
        String multiline = " \n  line 1 \n  line 2 \n ";
        List<String> lines = multiline.lines()
                .filter(line -> !line.isBlank())
                .map(String::strip)
                .collect(Collectors.toList());
        System.out.println("处理后的行: " + lines);

        // 3. 文本块
        String welcomeEmail = """
            Hello, {userName}!
                Thank you for registering.
                Your account is now active.
            
            Best Regards,
            The Team
            """;
        System.out.println("\n--- 邮件模板 ---");
        System.out.println(welcomeEmail.replace("{userName}", "Alice"));
    }
}
// 输出:
// '  '.isBlank() = true
// ''.isBlank() = true
// 处理后的行: [line 1, line 2]
//
// --- 邮件模板 ---
// Hello, Alice!
//     Thank you for registering.
//     Your account is now active.
// 
// Best Regards,
// The Team

package com.example.notes.ch03;

import cn.hutool.json.JSONUtil;
import com.example.notes.entity.Role;
import com.example.notes.entity.User;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDateTime;

public class FilesExample {
    public static void main(String[] args) throws IOException {
        User user = new User(100L, "TempUser", 99, Role.MEMBER, LocalDateTime.now());
        
        // 1. 定义文件路径
        Path userFile = Path.of("user_data.json");
        System.out.println("文件将保存在: " + userFile.toAbsolutePath());
        
        // 2. 将 User 对象转为 JSON 字符串 (使用 Hutool)
        String userJson = JSONUtil.toJsonPrettyStr(user);
        
        // 3. 使用 Files.writeString() 一行代码写入文件
        Files.writeString(userFile, userJson);
        System.out.println("\n用户信息已写入文件。");

        // 4. 使用 Files.readString() 一行代码读取文件
        String readJson = Files.readString(userFile);
        System.out.println("\n从文件中读回的内容:");
        System.out.println(readJson);

        // 5. 将 JSON 字符串转回 User 对象 (使用 Hutool)
        User userReadFromFile = JSONUtil.toBean(readJson, User.class);
        System.out.println("\n从 JSON 解析回的对象: " + userReadFromFile);
        
        // 6. 清理临时文件
        Files.delete(userFile);
        System.out.println("\n临时文件已删除。");
    }
}