第二阶段：Java进阶技能③Java新特性-优快云博客

🚀 第二阶段：Java进阶技能③Java新特性

💡 学习目标：掌握Java 8+的现代特性，包括Lambda表达式、Stream API、新日期时间API和模块化系统，提升编程效率和代码质量

🔗 Lambda表达式与函数式编程

🎯 Lambda表达式概述

🌟 Lambda表达式：Java 8引入的函数式编程特性，允许将函数作为参数传递，简化代码编写

✨ Lambda表达式的核心优势

优势	说明	示例
📝 简化代码	减少样板代码	`(x, y) -> x + y` 替代匿名内部类
🚀 提高可读性	代码更加简洁明了	函数式风格更直观
🔧 支持函数式编程	函数作为一等公民	高阶函数、函数组合
⚡ 性能优化	编译器优化	避免创建多余的匿名类

🏗️ Lambda表达式语法

📋 基本语法格式

// 完整格式
(参数列表) -> {
    // 方法体
    return 结果;
}

// 简化格式（单表达式）
(参数列表) -> 表达式

// 单参数可省略括号
参数 -> 表达式

// 无参数
() -> 表达式

💻 Lambda表达式实战

🎯 基础Lambda示例

🎯 示例1：Lambda表达式基础用法

import java.util.*;
import java.util.function.*;

public class LambdaBasicsDemo {
    
    public static void main(String[] args) {
        System.out.println("=== Lambda表达式基础演示 ===");
        
        // 1. 替代匿名内部类
        System.out.println("\n1. 线程创建对比:");
        
        // 传统方式
        Thread oldThread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("传统方式创建线程");
            }
        });
        
        // Lambda方式
        Thread newThread = new Thread(() -> {
            System.out.println("Lambda方式创建线程");
        });
        
        oldThread.start();
        newThread.start();
        
        // 2. 集合操作
        System.out.println("\n2. 集合排序对比:");
        List<String> names = Arrays.asList("张三", "李四", "王五", "赵六");
        
        // 传统方式排序
        List<String> traditionalSort = new ArrayList<>(names);
        Collections.sort(traditionalSort, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        });
        System.out.println("传统排序结果: " + traditionalSort);
        
        // Lambda方式排序
        List<String> lambdaSort = new ArrayList<>(names);
        lambdaSort.sort((s1, s2) -> s1.length() - s2.length());
        System.out.println("Lambda排序结果: " + lambdaSort);
        
        // 3. 函数式接口使用
        System.out.println("\n3. 函数式接口演示:");
        
        // Predicate - 判断条件
        Predicate<String> isLongName = name -> name.length() > 2;
        System.out.println("张三 是长名字吗? " + isLongName.test("张三"));
        System.out.println("张三丰 是长名字吗? " + isLongName.test("张三丰"));
        
        // Function - 转换函数
        Function<String, Integer> getLength = String::length;
        System.out.println("'Hello World' 的长度: " + getLength.apply("Hello World"));
        
        // Consumer - 消费者
        Consumer<String> printer = System.out::println;
        names.forEach(printer);
        
        // Supplier - 供应者
        Supplier<String> randomName = () -> {
            String[] namePool = {"小明", "小红", "小刚", "小丽"};
            return namePool[new Random().nextInt(namePool.length)];
        };
        System.out.println("随机名字: " + randomName.get());
    }
}

🔧 高级Lambda应用

🎯 示例2：高级Lambda特性

import java.util.*;
import java.util.function.*;

public class AdvancedLambdaDemo {
    
    // 自定义函数式接口
    @FunctionalInterface
    interface Calculator {
        double calculate(double a, double b);
        
        // 默认方法
        default String getDescription() {
            return "数学计算器";
        }
    }
    
    // 高阶函数示例
    public static Function<Integer, Integer> createMultiplier(int factor) {
        return x -> x * factor;
    }
    
    // 函数组合示例
    public static void demonstrateFunctionComposition() {
        System.out.println("=== 函数组合演示 ===");
        
        Function<String, String> addPrefix = s -> "前缀-" + s;
        Function<String, String> addSuffix = s -> s + "-后缀";
        Function<String, String> toUpper = String::toUpperCase;
        
        // 函数组合
        Function<String, String> combined = addPrefix
            .andThen(addSuffix)
            .andThen(toUpper);
        
        String result = combined.apply("测试");
        System.out.println("组合函数结果: " + result);
    }
    
    public static void main(String[] args) {
        System.out.println("=== 高级Lambda特性演示 ===");
        
        // 1. 自定义函数式接口
        System.out.println("\n1. 自定义函数式接口:");
        Calculator add = (a, b) -> a + b;
        Calculator multiply = (a, b) -> a * b;
        Calculator power = Math::pow;
        
        System.out.println("5 + 3 = " + add.calculate(5, 3));
        System.out.println("5 * 3 = " + multiply.calculate(5, 3));
        System.out.println("5 ^ 3 = " + power.calculate(5, 3));
        System.out.println("描述: " + add.getDescription());
        
        // 2. 高阶函数
        System.out.println("\n2. 高阶函数:");
        Function<Integer, Integer> doubler = createMultiplier(2);
        Function<Integer, Integer> tripler = createMultiplier(3);
        
        System.out.println("10 * 2 = " + doubler.apply(10));
        System.out.println("10 * 3 = " + tripler.apply(10));
        
        // 3. 函数组合
        demonstrateFunctionComposition();
        
        // 4. 闭包示例
        System.out.println("\n4. 闭包示例:");
        int baseValue = 100;
        Function<Integer, Integer> addBase = x -> x + baseValue; // 捕获外部变量
        System.out.println("50 + 100 = " + addBase.apply(50));
        
        // 5. 方法引用
        System.out.println("\n5. 方法引用:");
        List<String> words = Arrays.asList("apple", "banana", "cherry", "date");
        
        // 静态方法引用
        words.sort(String::compareToIgnoreCase);
        System.out.println("排序后: " + words);
        
        // 实例方法引用
        words.forEach(System.out::println);
        
        // 构造器引用
        Supplier<List<String>> listSupplier = ArrayList::new;
        List<String> newList = listSupplier.get();
        System.out.println("新列表: " + newList);
    }
}

🌊 Stream API详解

🎯 Stream API概述

🌟 Stream API：Java 8引入的数据处理API，提供声明式的数据操作方式，支持函数式编程风格

✨ Stream API核心特性

🌊 Stream API特性
│
├── 🔄 声明式编程
│   ├── 描述"做什么"而非"怎么做"
│   └── 代码更简洁易读
│
├── 🔗 链式操作
│   ├── 中间操作(Intermediate)
│   └── 终端操作(Terminal)
│
├── ⚡ 延迟执行
│   ├── 中间操作不立即执行
│   └── 终端操作触发计算
│
└── 🚀 并行处理
    ├── 自动并行化
    └── 充分利用多核CPU

💻 Stream基础操作

🎯 创建Stream和基本操作

🎯 示例3：Stream基础操作

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

public class StreamBasicsDemo {
    
    public static void main(String[] args) {
        System.out.println("=== Stream基础操作演示 ===");
        
        // 1. 创建Stream的多种方式
        System.out.println("\n1. 创建Stream:");
        
        // 从集合创建
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Stream<Integer> fromList = numbers.stream();
        
        // 从数组创建
        String[] words = {"apple", "banana", "cherry"};
        Stream<String> fromArray = Arrays.stream(words);
        
        // 使用Stream.of()
        Stream<String> fromValues = Stream.of("Java", "Python", "JavaScript");
        
        // 无限流
        Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 2);
        Stream<Double> randomStream = Stream.generate(Math::random);
        
        // 2. 过滤操作(filter)
        System.out.println("\n2. 过滤操作:");
        List<Integer> evenNumbers = numbers.stream()
            .filter(n -> n % 2 == 0)
            .collect(Collectors.toList());
        System.out.println("偶数: " + evenNumbers);
        
        // 3. 映射操作(map)
        System.out.println("\n3. 映射操作:");
        List<Integer> squares = numbers.stream()
            .map(n -> n * n)
            .collect(Collectors.toList());
        System.out.println("平方数: " + squares);
        
        // 4. 排序操作(sorted)
        System.out.println("\n4. 排序操作:");
        List<String> sortedWords = Arrays.stream(words)
            .sorted()
            .collect(Collectors.toList());
        System.out.println("排序后: " + sortedWords);
        
        // 5. 去重操作(distinct)
        System.out.println("\n5. 去重操作:");
        List<Integer> duplicates = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 5);
        List<Integer> unique = duplicates.stream()
            .distinct()
            .collect(Collectors.toList());
        System.out.println("去重后: " + unique);
        
        // 6. 限制操作(limit/skip)
        System.out.println("\n6. 限制操作:");
        List<Integer> first5 = numbers.stream()
            .limit(5)
            .collect(Collectors.toList());
        System.out.println("前5个: " + first5);
        
        List<Integer> skip5 = numbers.stream()
            .skip(5)
            .collect(Collectors.toList());
        System.out.println("跳过前5个: " + skip5);
    }
}

🔧 Stream高级操作

🎯 示例4：Stream高级特性

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

public class AdvancedStreamDemo {
    
    // 学生类
    static class Student {
        private String name;
        private int age;
        private String major;
        private double score;
        
        public Student(String name, int age, String major, double score) {
            this.name = name;
            this.age = age;
            this.major = major;
            this.score = score;
        }
        
        // getter方法
        public String getName() { return name; }
        public int getAge() { return age; }
        public String getMajor() { return major; }
        public double getScore() { return score; }
        
        @Override
        public String toString() {
            return String.format("Student{name='%s', age=%d, major='%s', score=%.1f}", 
                               name, age, major, score);
        }
    }
    
    public static void main(String[] args) {
        System.out.println("=== Stream高级操作演示 ===");
        
        // 创建学生数据
        List<Student> students = Arrays.asList(
            new Student("张三", 20, "计算机", 85.5),
            new Student("李四", 21, "数学", 92.0),
            new Student("王五", 19, "计算机", 78.5),
            new Student("赵六", 22, "物理", 88.0),
            new Student("钱七", 20, "数学", 95.5),
            new Student("孙八", 21, "计算机", 82.0)
        );
        
        // 1. 分组操作(groupingBy)
        System.out.println("\n1. 按专业分组:");
        Map<String, List<Student>> byMajor = students.stream()
            .collect(Collectors.groupingBy(Student::getMajor));
        byMajor.forEach((major, studentList) -> {
            System.out.println(major + ": " + studentList.size() + "人");
        });
        
        // 2. 分区操作(partitioningBy)
        System.out.println("\n2. 按成绩分区(>=90分):");
        Map<Boolean, List<Student>> byScore = students.stream()
            .collect(Collectors.partitioningBy(s -> s.getScore() >= 90));
        System.out.println("优秀学生: " + byScore.get(true).size() + "人");
        System.out.println("普通学生: " + byScore.get(false).size() + "人");
        
        // 3. 统计操作
        System.out.println("\n3. 成绩统计:");
        DoubleSummaryStatistics scoreStats = students.stream()
            .mapToDouble(Student::getScore)
            .summaryStatistics();
        System.out.println("平均分: " + scoreStats.getAverage());
        System.out.println("最高分: " + scoreStats.getMax());
        System.out.println("最低分: " + scoreStats.getMin());
        System.out.println("总人数: " + scoreStats.getCount());
        
        // 4. 查找操作
        System.out.println("\n4. 查找操作:");
        Optional<Student> topStudent = students.stream()
            .max(Comparator.comparing(Student::getScore));
        topStudent.ifPresent(s -> System.out.println("最高分学生: " + s));
        
        boolean hasExcellent = students.stream()
            .anyMatch(s -> s.getScore() >= 95);
        System.out.println("是否有95分以上学生: " + hasExcellent);
        
        // 5. 归约操作(reduce)
        System.out.println("\n5. 归约操作:");
        double totalScore = students.stream()
            .mapToDouble(Student::getScore)
            .reduce(0.0, Double::sum);
        System.out.println("总分: " + totalScore);
        
        Optional<Student> oldestStudent = students.stream()
            .reduce((s1, s2) -> s1.getAge() > s2.getAge() ? s1 : s2);
        oldestStudent.ifPresent(s -> System.out.println("年龄最大学生: " + s));
        
        // 6. 并行流
        System.out.println("\n6. 并行流性能对比:");
        List<Integer> largeList = IntStream.rangeClosed(1, 1000000)
            .boxed()
            .collect(Collectors.toList());
        
        long startTime = System.currentTimeMillis();
        long sequentialSum = largeList.stream()
            .mapToLong(Integer::longValue)
            .sum();
        long sequentialTime = System.currentTimeMillis() - startTime;
        
        startTime = System.currentTimeMillis();
        long parallelSum = largeList.parallelStream()
            .mapToLong(Integer::longValue)
            .sum();
        long parallelTime = System.currentTimeMillis() - startTime;
        
        System.out.println("顺序流耗时: " + sequentialTime + "ms, 结果: " + sequentialSum);
        System.out.println("并行流耗时: " + parallelTime + "ms, 结果: " + parallelSum);
    }
}

⏰ 新日期时间API

🎯 新日期时间API概述

🌟 新日期时间API：Java 8引入的java.time包，解决了传统Date和Calendar类的诸多问题

✨ 新API的核心优势

特性	传统API问题	新API解决方案
🔒 不可变性	Date类可变，线程不安全	所有类都是不可变的
🎯 类型安全	月份从0开始，容易出错	月份从1开始，更直观
📅 功能完整	功能分散在多个类中	职责明确，功能集中
🌍 时区支持	时区处理复杂	内置完善的时区支持
📖 可读性	API设计不够直观	链式调用，语义清晰

💻 核心日期时间类

🎯 基础日期时间操作

🎯 示例5：新日期时间API基础

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;

public class DateTimeBasicsDemo {
    
    public static void main(String[] args) {
        System.out.println("=== 新日期时间API演示 ===");
        
        // 1. 基本日期时间类
        System.out.println("\n1. 基本日期时间类:");
        
        // LocalDate - 日期
        LocalDate today = LocalDate.now();
        LocalDate birthday = LocalDate.of(1990, 5, 15);
        System.out.println("今天: " + today);
        System.out.println("生日: " + birthday);
        
        // LocalTime - 时间
        LocalTime now = LocalTime.now();
        LocalTime meetingTime = LocalTime.of(14, 30, 0);
        System.out.println("现在时间: " + now);
        System.out.println("会议时间: " + meetingTime);
        
        // LocalDateTime - 日期时间
        LocalDateTime currentDateTime = LocalDateTime.now();
        LocalDateTime appointmentTime = LocalDateTime.of(2024, 12, 25, 10, 30);
        System.out.println("当前日期时间: " + currentDateTime);
        System.out.println("预约时间: " + appointmentTime);
        
        // 2. 日期计算
        System.out.println("\n2. 日期计算:");
        LocalDate nextWeek = today.plusWeeks(1);
        LocalDate lastMonth = today.minusMonths(1);
        LocalDate nextYear = today.plusYears(1);
        
        System.out.println("下周: " + nextWeek);
        System.out.println("上个月: " + lastMonth);
        System.out.println("明年: " + nextYear);
        
        // 3. 时间间隔计算
        System.out.println("\n3. 时间间隔:");
        long daysBetween = ChronoUnit.DAYS.between(birthday, today);
        long yearsBetween = ChronoUnit.YEARS.between(birthday, today);
        
        System.out.println("距离生日已过: " + daysBetween + " 天");
        System.out.println("年龄: " + yearsBetween + " 岁");
        
        // 4. 日期比较
        System.out.println("\n4. 日期比较:");
        LocalDate date1 = LocalDate.of(2024, 1, 1);
        LocalDate date2 = LocalDate.of(2024, 12, 31);
        
        System.out.println("date1 在 date2 之前: " + date1.isBefore(date2));
        System.out.println("date1 在 date2 之后: " + date1.isAfter(date2));
        System.out.println("date1 等于 today: " + date1.isEqual(today));
        
        // 5. 获取日期信息
        System.out.println("\n5. 日期信息:");
        System.out.println("年份: " + today.getYear());
        System.out.println("月份: " + today.getMonth() + " (" + today.getMonthValue() + ")");
        System.out.println("日期: " + today.getDayOfMonth());
        System.out.println("星期: " + today.getDayOfWeek());
        System.out.println("一年中的第几天: " + today.getDayOfYear());
    }
}

🌍 时区和格式化

🎯 示例6：时区处理和格式化

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.Locale;

public class DateTimeAdvancedDemo {
    
    public static void main(String[] args) {
        System.out.println("=== 高级日期时间操作演示 ===");
        
        // 1. 时区处理
        System.out.println("\n1. 时区处理:");
        
        // 带时区的日期时间
        ZonedDateTime beijingTime = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
        ZonedDateTime newYorkTime = ZonedDateTime.now(ZoneId.of("America/New_York"));
        ZonedDateTime londonTime = ZonedDateTime.now(ZoneId.of("Europe/London"));
        
        System.out.println("北京时间: " + beijingTime);
        System.out.println("纽约时间: " + newYorkTime);
        System.out.println("伦敦时间: " + londonTime);
        
        // 时区转换
        ZonedDateTime beijingToNewYork = beijingTime.withZoneSameInstant(ZoneId.of("America/New_York"));
        System.out.println("北京时间转纽约时间: " + beijingToNewYork);
        
        // 2. 日期格式化
        System.out.println("\n2. 日期格式化:");
        LocalDateTime now = LocalDateTime.now();
        
        // 预定义格式
        System.out.println("ISO格式: " + now.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
        System.out.println("基本ISO格式: " + now.format(DateTimeFormatter.BASIC_ISO_DATE));
        
        // 本地化格式
        System.out.println("中文长格式: " + now.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL).withLocale(Locale.CHINA)));
        System.out.println("中文短格式: " + now.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT).withLocale(Locale.CHINA)));
        
        // 自定义格式
        DateTimeFormatter customFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
        System.out.println("自定义格式: " + now.format(customFormatter));
        
        DateTimeFormatter englishFormatter = DateTimeFormatter.ofPattern("EEEE, MMMM dd, yyyy 'at' HH:mm", Locale.ENGLISH);
        System.out.println("英文格式: " + now.format(englishFormatter));
        
        // 3. 字符串解析
        System.out.println("\n3. 字符串解析:");
        String dateString = "2024-12-25 15:30:45";
        LocalDateTime parsed = LocalDateTime.parse(dateString, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println("解析结果: " + parsed);
        
        // 4. Period和Duration
        System.out.println("\n4. 时间段计算:");
        
        // Period - 日期间隔
        LocalDate startDate = LocalDate.of(2020, 1, 1);
        LocalDate endDate = LocalDate.of(2024, 12, 31);
        Period period = Period.between(startDate, endDate);
        System.out.println("时间间隔: " + period.getYears() + "年" + period.getMonths() + "月" + period.getDays() + "天");
        
        // Duration - 时间间隔
        LocalTime startTime = LocalTime.of(9, 0);
        LocalTime endTime = LocalTime.of(17, 30);
        Duration duration = Duration.between(startTime, endTime);
        System.out.println("工作时长: " + duration.toHours() + "小时" + (duration.toMinutes() % 60) + "分钟");
        
        // 5. 实用工具方法
        System.out.println("\n5. 实用工具:");
        
        // 判断闰年
        System.out.println("2024年是闰年: " + Year.of(2024).isLeap());
        System.out.println("2023年是闰年: " + Year.of(2023).isLeap());
        
        // 月份天数
        YearMonth yearMonth = YearMonth.of(2024, 2);
        System.out.println("2024年2月有 " + yearMonth.lengthOfMonth() + " 天");
        
        // 一年的天数
        Year year2024 = Year.of(2024);
        System.out.println("2024年有 " + year2024.length() + " 天");
    }
}

🔧 Optional类详解

🎯 Optional概述

🌟 Optional：Java 8引入的容器类，用于优雅地处理可能为null的值，避免NullPointerException

✨ Optional的核心优势

优势	传统方式问题	Optional解决方案
🛡️ 空值安全	容易出现NPE	强制处理空值情况
📖 代码可读性	大量null检查	链式调用更清晰
🎯 意图明确	不知道是否可能为null	明确表示可能为空
🔧 函数式风格	命令式编程	支持函数式操作

💻 Optional实战应用

🎯 Optional基础操作

🎯 示例7：Optional基础用法

import java.util.*;
import java.util.function.Predicate;

public class OptionalBasicsDemo {
    
    // 用户类
    static class User {
        private String name;
        private String email;
        private Integer age;
        
        public User(String name, String email, Integer age) {
            this.name = name;
            this.email = email;
            this.age = age;
        }
        
        public String getName() { return name; }
        public String getEmail() { return email; }
        public Integer getAge() { return age; }
        
        @Override
        public String toString() {
            return String.format("User{name='%s', email='%s', age=%d}", name, email, age);
        }
    }
    
    // 模拟数据库查询
    public static Optional<User> findUserById(int id) {
        Map<Integer, User> users = Map.of(
            1, new User("张三", "zhangsan@example.com", 25),
            2, new User("李四", "lisi@example.com", 30),
            3, new User("王五", null, 28) // 邮箱为空
        );
        return Optional.ofNullable(users.get(id));
    }
    
    public static void main(String[] args) {
        System.out.println("=== Optional基础操作演示 ===");
        
        // 1. 创建Optional
        System.out.println("\n1. 创建Optional:");
        
        // 创建空Optional
        Optional<String> empty = Optional.empty();
        System.out.println("空Optional: " + empty);
        
        // 创建非空Optional
        Optional<String> nonEmpty = Optional.of("Hello");
        System.out.println("非空Optional: " + nonEmpty);
        
        // 创建可能为空的Optional
        Optional<String> nullable = Optional.ofNullable(null);
        System.out.println("可能为空的Optional: " + nullable);
        
        // 2. 检查值是否存在
        System.out.println("\n2. 检查值:");
        System.out.println("empty.isPresent(): " + empty.isPresent());
        System.out.println("nonEmpty.isPresent(): " + nonEmpty.isPresent());
        System.out.println("empty.isEmpty(): " + empty.isEmpty()); // Java 11+
        
        // 3. 获取值
        System.out.println("\n3. 获取值:");
        
        // 安全获取值
        if (nonEmpty.isPresent()) {
            System.out.println("值: " + nonEmpty.get());
        }
        
        // 提供默认值
        String value1 = empty.orElse("默认值");
        String value2 = nonEmpty.orElse("默认值");
        System.out.println("empty.orElse(): " + value1);
        System.out.println("nonEmpty.orElse(): " + value2);
        
        // 延迟计算默认值
        String value3 = empty.orElseGet(() -> "计算得到的默认值");
        System.out.println("empty.orElseGet(): " + value3);
        
        // 4. 条件执行
        System.out.println("\n4. 条件执行:");
        nonEmpty.ifPresent(s -> System.out.println("值存在: " + s));
        empty.ifPresent(s -> System.out.println("这不会执行"));
        
        // Java 9+ ifPresentOrElse
        nonEmpty.ifPresentOrElse(
            s -> System.out.println("存在值: " + s),
            () -> System.out.println("值不存在")
        );
        
        // 5. 实际应用示例
        System.out.println("\n5. 实际应用:");
        
        // 查找用户
        Optional<User> user1 = findUserById(1);
        Optional<User> user999 = findUserById(999);
        
        // 传统方式处理
        System.out.println("传统方式:");
        User u1 = user1.orElse(null);
        if (u1 != null) {
            System.out.println("找到用户: " + u1.getName());
        } else {
            System.out.println("用户不存在");
        }
        
        // Optional方式处理
        System.out.println("Optional方式:");
        user1.ifPresentOrElse(
            user -> System.out.println("找到用户: " + user.getName()),
            () -> System.out.println("用户不存在")
        );
        
        user999.ifPresentOrElse(
            user -> System.out.println("找到用户: " + user.getName()),
            () -> System.out.println("用户不存在")
        );
    }
}

🔧 Optional高级操作

🎯 示例8：Optional高级特性

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

public class OptionalAdvancedDemo {

    static class Address {
        private String street;
        private String city;
        private String country;

        public Address(String street, String city, String country) {
            this.street = street;
            this.city = city;
            this.country = country;
        }

        public String getStreet() { return street; }
        public String getCity() { return city; }
        public String getCountry() { return country; }

        @Override
        public String toString() {
            return String.format("%s, %s, %s", street, city, country);
        }
    }

    static class Person {
        private String name;
        private Optional<Address> address;
        private Optional<String> phone;

        public Person(String name, Address address, String phone) {
            this.name = name;
            this.address = Optional.ofNullable(address);
            this.phone = Optional.ofNullable(phone);
        }

        public String getName() { return name; }
        public Optional<Address> getAddress() { return address; }
        public Optional<String> getPhone() { return phone; }
    }

    public static void main(String[] args) {
        System.out.println("=== Optional高级操作演示 ===");

        // 创建测试数据
        Person person1 = new Person("张三",
            new Address("中关村大街1号", "北京", "中国"),
            "13800138000");
        Person person2 = new Person("李四", null, null);

        // 1. map操作 - 转换值
        System.out.println("\n1. map操作:");
        Optional<String> city1 = Optional.of(person1)
            .map(Person::getAddress)
            .flatMap(addr -> addr)
            .map(Address::getCity);

        System.out.println("张三的城市: " + city1.orElse("未知"));

        Optional<String> city2 = Optional.of(person2)
            .map(Person::getAddress)
            .flatMap(addr -> addr)
            .map(Address::getCity);

        System.out.println("李四的城市: " + city2.orElse("未知"));

        // 2. flatMap操作 - 扁平化嵌套Optional
        System.out.println("\n2. flatMap操作:");
        Optional<String> phone1 = Optional.of(person1)
            .flatMap(Person::getPhone);

        Optional<String> phone2 = Optional.of(person2)
            .flatMap(Person::getPhone);

        System.out.println("张三的电话: " + phone1.orElse("无电话"));
        System.out.println("李四的电话: " + phone2.orElse("无电话"));

        // 3. filter操作 - 条件过滤
        System.out.println("\n3. filter操作:");
        Optional<Person> beijingPerson = Optional.of(person1)
            .filter(p -> p.getAddress()
                .map(Address::getCity)
                .orElse("")
                .equals("北京"));

        beijingPerson.ifPresentOrElse(
            p -> System.out.println(p.getName() + " 住在北京"),
            () -> System.out.println("不住在北京")
        );

        // 4. 链式操作组合
        System.out.println("\n4. 链式操作:");
        String result = Optional.of(person1)
            .flatMap(Person::getAddress)
            .map(Address::getCountry)
            .filter(country -> country.equals("中国"))
            .map(country -> "国内用户")
            .orElse("国外用户");

        System.out.println("用户类型: " + result);

        // 5. Optional与Stream结合
        System.out.println("\n5. Optional与Stream:");
        List<Person> people = Arrays.asList(person1, person2);

        // 获取所有有效的城市
        List<String> cities = people.stream()
            .map(Person::getAddress)
            .filter(Optional::isPresent)
            .map(Optional::get)
            .map(Address::getCity)
            .distinct()
            .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);

        System.out.println("所有城市: " + cities);

        // Java 9+ Optional.stream()
        List<String> phones = people.stream()
            .map(Person::getPhone)
            .flatMap(Optional::stream)
            .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);

        System.out.println("所有电话: " + phones);

        // 6. 异常处理
        System.out.println("\n6. 异常处理:");
        Optional<Integer> number = parseInteger("123");
        Optional<Integer> invalid = parseInteger("abc");

        System.out.println("解析 '123': " + number.orElse(-1));
        System.out.println("解析 'abc': " + invalid.orElse(-1));

        // 7. Optional最佳实践
        System.out.println("\n7. 最佳实践示例:");
        demonstrateBestPractices();
    }

    // 安全的字符串转整数
    public static Optional<Integer> parseInteger(String str) {
        try {
            return Optional.of(Integer.parseInt(str));
        } catch (NumberFormatException e) {
            return Optional.empty();
        }
    }

    // Optional最佳实践
    public static void demonstrateBestPractices() {
        // ✅ 好的做法
        Optional<String> goodExample = Optional.ofNullable(getValue())
            .filter(s -> !s.isEmpty())
            .map(String::toUpperCase);

        goodExample.ifPresentOrElse(
            value -> System.out.println("处理值: " + value),
            () -> System.out.println("值为空或无效")
        );

        // ❌ 避免的做法
        // 不要这样做：
        // if (optional.isPresent()) {
        //     return optional.get();
        // } else {
        //     return defaultValue;
        // }
        // 应该这样做：
        String result = goodExample.orElse("默认值");
        System.out.println("最终结果: " + result);
    }

    private static String getValue() {
        return Math.random() > 0.5 ? "hello" : null;
    }
}

📦 模块化系统(Java 9+)

🎯 模块化系统概述

🌟 模块化系统(JPMS)：Java 9引入的模块化系统，提供更好的封装性、可靠性和可维护性

✨ 模块化的核心优势

📦 模块化系统特性
│
├── 🔒 强封装
│   ├── 明确的API边界
│   └── 隐藏内部实现
│
├── 🎯 可靠配置
│   ├── 编译时依赖检查
│   └── 避免运行时错误
│
├── 🚀 性能优化
│   ├── 更小的运行时镜像
│   └── 启动时间优化
│
└── 🛠️ 工具支持
    ├── jlink创建自定义运行时
    └── 更好的IDE支持

💻 模块化实战

🎯 基础模块定义

🎯 示例9：模块化项目结构

// 项目结构示例
/*
my-modular-app/
├── src/
│   ├── com.example.utils/
│   │   ├── module-info.java
│   │   └── com/example/utils/
│   │       ├── StringUtils.java
│   │       └── MathUtils.java
│   ├── com.example.service/
│   │   ├── module-info.java
│   │   └── com/example/service/
│   │       ├── UserService.java
│   │       └── impl/
│   │           └── UserServiceImpl.java
│   └── com.example.app/
│       ├── module-info.java
│       └── com/example/app/
│           └── Application.java
*/

// 1. 工具模块 (com.example.utils)
// module-info.java
module com.example.utils {
    // 导出包，使其他模块可以访问
    exports com.example.utils;
}

// StringUtils.java
package com.example.utils;

public class StringUtils {

    public static boolean isEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }

    public static String capitalize(String str) {
        if (isEmpty(str)) {
            return str;
        }
        return str.substring(0, 1).toUpperCase() + str.substring(1).toLowerCase();
    }

    public static String reverse(String str) {
        if (isEmpty(str)) {
            return str;
        }
        return new StringBuilder(str).reverse().toString();
    }
}

// MathUtils.java
package com.example.utils;

public class MathUtils {

    public static boolean isPrime(int number) {
        if (number < 2) return false;
        for (int i = 2; i <= Math.sqrt(number); i++) {
            if (number % i == 0) return false;
        }
        return true;
    }

    public static int gcd(int a, int b) {
        while (b != 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }
}

// 2. 服务模块 (com.example.service)
// module-info.java
module com.example.service {
    // 依赖工具模块
    requires com.example.utils;

    // 导出服务接口
    exports com.example.service;

    // 不导出实现包，保持封装性
    // com.example.service.impl 包对外不可见
}

// UserService.java
package com.example.service;

import java.util.List;
import java.util.Optional;

public interface UserService {
    Optional<User> findById(Long id);
    List<User> findAll();
    User save(User user);
    void deleteById(Long id);
}

// User.java
package com.example.service;

public class User {
    private Long id;
    private String name;
    private String email;

    public User(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    // getter和setter方法
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }

    @Override
    public String toString() {
        return String.format("User{id=%d, name='%s', email='%s'}", id, name, email);
    }
}

// UserServiceImpl.java (内部实现，不对外暴露)
package com.example.service.impl;

import com.example.service.User;
import com.example.service.UserService;
import com.example.utils.StringUtils;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

public class UserServiceImpl implements UserService {
    private final Map<Long, User> users = new ConcurrentHashMap<>();
    private final AtomicLong idGenerator = new AtomicLong(1);

    public UserServiceImpl() {
        // 初始化一些测试数据
        save(new User(null, "张三", "zhangsan@example.com"));
        save(new User(null, "李四", "lisi@example.com"));
    }

    @Override
    public Optional<User> findById(Long id) {
        return Optional.ofNullable(users.get(id));
    }

    @Override
    public List<User> findAll() {
        return new ArrayList<>(users.values());
    }

    @Override
    public User save(User user) {
        if (user.getId() == null) {
            user.setId(idGenerator.getAndIncrement());
        }

        // 使用工具模块的方法
        if (!StringUtils.isEmpty(user.getName())) {
            user.setName(StringUtils.capitalize(user.getName()));
        }

        users.put(user.getId(), user);
        return user;
    }

    @Override
    public void deleteById(Long id) {
        users.remove(id);
    }
}

// 3. 应用模块 (com.example.app)
// module-info.java
module com.example.app {
    // 依赖服务模块
    requires com.example.service;
    requires com.example.utils;

    // 如果需要使用反射访问，需要opens声明
    // opens com.example.app to some.framework;
}

// Application.java
package com.example.app;

import com.example.service.User;
import com.example.service.UserService;
import com.example.service.impl.UserServiceImpl;
import com.example.utils.StringUtils;

public class Application {

    public static void main(String[] args) {
        System.out.println("=== 模块化应用演示 ===");

        // 创建服务实例
        UserService userService = new UserServiceImpl();

        // 1. 查询所有用户
        System.out.println("\n1. 所有用户:");
        userService.findAll().forEach(System.out::println);

        // 2. 添加新用户
        System.out.println("\n2. 添加新用户:");
        User newUser = new User(null, "王五", "wangwu@example.com");
        User savedUser = userService.save(newUser);
        System.out.println("保存的用户: " + savedUser);

        // 3. 查询特定用户
        System.out.println("\n3. 查询用户:");
        userService.findById(1L).ifPresentOrElse(
            user -> System.out.println("找到用户: " + user),
            () -> System.out.println("用户不存在")
        );

        // 4. 使用工具类
        System.out.println("\n4. 字符串工具演示:");
        String text = "hello world";
        System.out.println("原文: " + text);
        System.out.println("首字母大写: " + StringUtils.capitalize(text));
        System.out.println("反转: " + StringUtils.reverse(text));

        // 5. 删除用户
        System.out.println("\n5. 删除用户:");
        userService.deleteById(2L);
        System.out.println("删除后的用户列表:");
        userService.findAll().forEach(System.out::println);
    }
}

🆕 其他重要新特性

🎯 接口默认方法和静态方法

💻 接口增强特性

🎯 示例10：接口新特性

import java.util.*;
import java.util.function.Predicate;

// 增强的接口定义
public interface EnhancedCollection<T> {

    // 抽象方法
    List<T> getItems();

    // 默认方法 - 提供默认实现
    default int size() {
        return getItems().size();
    }

    default boolean isEmpty() {
        return getItems().isEmpty();
    }

    default void forEach(java.util.function.Consumer<? super T> action) {
        getItems().forEach(action);
    }

    default List<T> filter(Predicate<T> predicate) {
        return getItems().stream()
            .filter(predicate)
            .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
    }

    // 静态方法 - 工具方法
    static <T> EnhancedCollection<T> of(T... items) {
        return new SimpleEnhancedCollection<>(Arrays.asList(items));
    }

    static <T> EnhancedCollection<T> empty() {
        return new SimpleEnhancedCollection<>(Collections.emptyList());
    }

    // 私有方法 (Java 9+) - 辅助默认方法
    private void logOperation(String operation) {
        System.out.println("执行操作: " + operation);
    }
}

// 简单实现
class SimpleEnhancedCollection<T> implements EnhancedCollection<T> {
    private final List<T> items;

    public SimpleEnhancedCollection(List<T> items) {
        this.items = new ArrayList<>(items);
    }

    @Override
    public List<T> getItems() {
        return items;
    }

    // 可以重写默认方法
    @Override
    public int size() {
        System.out.println("自定义size方法");
        return items.size();
    }
}

// 使用示例
public class InterfaceEnhancementsDemo {

    public static void main(String[] args) {
        System.out.println("=== 接口增强特性演示 ===");

        // 1. 使用静态方法创建集合
        EnhancedCollection<String> fruits = EnhancedCollection.of("苹果", "香蕉", "橙子", "葡萄");

        System.out.println("水果数量: " + fruits.size());
        System.out.println("是否为空: " + fruits.isEmpty());

        // 2. 使用默认方法
        System.out.println("\n所有水果:");
        fruits.forEach(fruit -> System.out.println("- " + fruit));

        // 3. 使用过滤功能
        List<String> filteredFruits = fruits.filter(fruit -> fruit.contains("果"));
        System.out.println("\n包含'果'的水果: " + filteredFruits);

        // 4. 空集合
        EnhancedCollection<String> empty = EnhancedCollection.empty();
        System.out.println("\n空集合大小: " + empty.size());
    }
}

🔧 var关键字(Java 10+)

💻 局部变量类型推断

🎯 示例11：var关键字使用

import java.util.*;
import java.util.stream.Collectors;

public class VarKeywordDemo {

    public static void main(String[] args) {
        System.out.println("=== var关键字演示 ===");

        // 1. 基本类型推断
        System.out.println("\n1. 基本类型推断:");
        var number = 42;                    // int
        var text = "Hello World";           // String
        var decimal = 3.14;                 // double
        var flag = true;                    // boolean

        System.out.println("number类型: " + ((Object)number).getClass().getSimpleName());
        System.out.println("text类型: " + text.getClass().getSimpleName());
        System.out.println("decimal类型: " + ((Object)decimal).getClass().getSimpleName());
        System.out.println("flag类型: " + ((Object)flag).getClass().getSimpleName());

        // 2. 集合类型推断
        System.out.println("\n2. 集合类型推断:");
        var list = new ArrayList<String>();
        var map = new HashMap<String, Integer>();
        var set = new HashSet<String>();

        list.add("Java");
        list.add("Python");
        map.put("Java", 25);
        map.put("Python", 30);
        set.add("编程语言");

        System.out.println("list: " + list);
        System.out.println("map: " + map);
        System.out.println("set: " + set);

        // 3. 复杂表达式类型推断
        System.out.println("\n3. 复杂表达式:");
        var filteredList = list.stream()
            .filter(lang -> lang.startsWith("J"))
            .collect(Collectors.toList());

        var upperCaseList = list.stream()
            .map(String::toUpperCase)
            .collect(Collectors.toList());

        System.out.println("过滤后: " + filteredList);
        System.out.println("大写后: " + upperCaseList);

        // 4. 循环中使用var
        System.out.println("\n4. 循环中使用var:");
        var numbers = Arrays.asList(1, 2, 3, 4, 5);

        for (var num : numbers) {
            System.out.print(num + " ");
        }
        System.out.println();

        // 5. var的限制
        System.out.println("\n5. var使用注意事项:");

        // ✅ 正确使用
        var validExample = "这是有效的";
        var anotherValid = new ArrayList<String>();

        // ❌ 错误使用（这些会编译错误）
        // var invalid;                    // 必须初始化
        // var nullValue = null;           // 不能推断null
        // var lambda = x -> x * 2;        // 不能推断lambda
        // var array = {1, 2, 3};          // 不能推断数组字面量

        System.out.println("var使用建议:");
        System.out.println("- 在类型明显时使用，提高代码简洁性");
        System.out.println("- 避免在类型不明确时使用，保持代码可读性");
        System.out.println("- 主要用于局部变量，不能用于字段、方法参数或返回类型");
    }
}

🔄 Switch表达式(Java 12+)

💻 增强的Switch语法

🎯 示例12：Switch表达式

public class SwitchExpressionDemo {

    enum Day {
        MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
    }

    enum Season {
        SPRING, SUMMER, AUTUMN, WINTER
    }

    public static void main(String[] args) {
        System.out.println("=== Switch表达式演示 ===");

        // 1. 传统switch vs 新switch表达式
        System.out.println("\n1. 语法对比:");
        Day today = Day.FRIDAY;

        // 传统switch语句
        String dayType1;
        switch (today) {
            case MONDAY:
            case TUESDAY:
            case WEDNESDAY:
            case THURSDAY:
            case FRIDAY:
                dayType1 = "工作日";
                break;
            case SATURDAY:
            case SUNDAY:
                dayType1 = "周末";
                break;
            default:
                dayType1 = "未知";
        }
        System.out.println("传统switch: " + dayType1);

        // 新switch表达式
        String dayType2 = switch (today) {
            case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> "工作日";
            case SATURDAY, SUNDAY -> "周末";
        };
        System.out.println("新switch表达式: " + dayType2);

        // 2. 带yield的switch表达式
        System.out.println("\n2. 使用yield:");
        String description = switch (today) {
            case MONDAY -> "周一，新的开始";
            case FRIDAY -> "周五，即将周末";
            case SATURDAY, SUNDAY -> {
                String weekend = "周末";
                yield weekend + "，休息时间";
            }
            default -> {
                yield "普通的" + today.name().toLowerCase();
            }
        };
        System.out.println("描述: " + description);

        // 3. 实际应用示例
        System.out.println("\n3. 实际应用:");
        demonstrateCalculator();
        demonstrateSeasonInfo();
    }

    // 计算器示例
    public static void demonstrateCalculator() {
        System.out.println("计算器示例:");

        double result = calculate(10, 5, "+");
        System.out.println("10 + 5 = " + result);

        result = calculate(10, 5, "*");
        System.out.println("10 * 5 = " + result);

        result = calculate(10, 0, "/");
        System.out.println("10 / 0 = " + result);
    }

    public static double calculate(double a, double b, String operator) {
        return switch (operator) {
            case "+" -> a + b;
            case "-" -> a - b;
            case "*" -> a * b;
            case "/" -> {
                if (b == 0) {
                    System.out.println("警告: 除数不能为0");
                    yield Double.NaN;
                }
                yield a / b;
            }
            case "%" -> a % b;
            default -> {
                System.out.println("不支持的操作符: " + operator);
                yield Double.NaN;
            }
        };
    }

    // 季节信息示例
    public static void demonstrateSeasonInfo() {
        System.out.println("\n季节信息:");

        for (Season season : Season.values()) {
            String info = getSeasonInfo(season);
            System.out.println(season + ": " + info);
        }
    }

    public static String getSeasonInfo(Season season) {
        return switch (season) {
            case SPRING -> "春天，万物复苏，气温回暖";
            case SUMMER -> "夏天，炎热多雨，适合游泳";
            case AUTUMN -> "秋天，天高气爽，收获季节";
            case WINTER -> "冬天，寒冷干燥，注意保暖";
        };
    }
}

🎯 综合实战练习

📊 练习1：函数式编程数据处理器 ⭐⭐⭐⭐

📝 练习描述

使用Lambda表达式和Stream API构建一个数据处理系统，支持复杂的数据查询、统计和转换操作。

🎯 学习目标

熟练运用Lambda表达式
掌握Stream API的高级用法
理解函数式编程思想
学会设计流畅的API

📋 具体要求

基础要求：

支持多种数据源（文件、数据库、API）
提供丰富的过滤和转换操作
实现数据统计和聚合功能
支持自定义处理函数

进阶要求：
5. 支持并行处理提升性能
6. 实现数据缓存机制
7. 提供数据验证和清洗功能
8. 支持多种输出格式

💡 实现提示

public class DataProcessor<T> {
    private final Stream<T> dataStream;

    public static <T> DataProcessor<T> of(Collection<T> data) {
        return new DataProcessor<>(data.stream());
    }

    public <R> DataProcessor<R> map(Function<T, R> mapper) {
        return new DataProcessor<>(dataStream.map(mapper));
    }

    public DataProcessor<T> filter(Predicate<T> predicate) {
        return new DataProcessor<>(dataStream.filter(predicate));
    }

    public <K> Map<K, List<T>> groupBy(Function<T, K> classifier) {
        return dataStream.collect(Collectors.groupingBy(classifier));
    }
}

⏰ 练习2：现代化日期时间管理系统 ⭐⭐⭐⭐

📝 练习描述

使用新的日期时间API构建一个完整的时间管理系统，支持多时区、定时任务和时间计算。

🎯 学习目标

掌握新日期时间API的使用
理解时区处理机制
学会时间间隔计算
掌握日期格式化和解析

📋 具体要求

基础要求：

支持多时区时间显示和转换
实现定时任务调度功能
提供时间间隔计算工具
支持多种日期格式

进阶要求：
5. 实现工作日计算（排除节假日）
6. 支持重复事件的时间计算
7. 提供时间统计和分析功能
8. 支持时间数据的导入导出

🔧 练习3：Optional最佳实践重构 ⭐⭐⭐

📝 练习描述

将传统的null检查代码重构为使用Optional的现代化代码，提升代码的安全性和可读性。

🎯 学习目标

掌握Optional的正确使用方式
学会重构遗留代码
理解函数式编程的优势
提升代码质量

📋 具体要求

基础要求：

识别和重构null检查代码
使用Optional链式操作
实现安全的数据访问
提供默认值处理机制

进阶要求：
5. 设计Optional友好的API
6. 实现复杂的条件逻辑
7. 优化性能和内存使用
8. 编写完整的测试用例

✅ 完成标准

🎯 基础完成标准

正确使用Lambda表达式和方法引用
熟练运用Stream API进行数据处理
掌握新日期时间API的核心功能
理解Optional的使用场景和最佳实践
代码风格符合现代Java规范

🚀 进阶完成标准

能够设计函数式风格的API
性能优化合理，充分利用并行流
错误处理优雅，使用Optional避免NPE
代码可读性高，充分利用新特性简化逻辑
通过完整的单元测试验证

🏆 专家级标准

深入理解函数式编程思想
能够在实际项目中推广新特性使用
设计出优雅且高效的解决方案
具备重构遗留代码的能力
能够指导团队使用现代Java特性

📝 本章小结

🎯 核心知识点回顾

🔗 Lambda表达式与函数式编程

✅ 掌握Lambda表达式的语法和使用场景
✅ 理解函数式接口和方法引用
✅ 学会函数组合和高阶函数
✅ 熟练使用内置函数式接口

🌊 Stream API

✅ 掌握Stream的创建和基本操作
✅ 熟练使用中间操作和终端操作
✅ 理解并行流的使用和性能优化
✅ 掌握复杂的数据处理和统计操作

⏰ 新日期时间API

✅ 掌握LocalDate、LocalTime、LocalDateTime的使用
✅ 理解时区处理和ZonedDateTime
✅ 熟练进行日期计算和格式化
✅ 掌握Period和Duration的时间间隔计算

🔧 Optional类

✅ 理解Optional的设计目的和使用场景
✅ 掌握Optional的创建和基本操作
✅ 熟练使用map、flatMap、filter等方法
✅ 学会Optional与Stream的结合使用

📦 模块化系统

✅ 理解模块化的概念和优势
✅ 掌握module-info.java的编写
✅ 学会模块间的依赖管理
✅ 了解模块化项目的构建和部署

🆕 其他新特性

✅ 掌握接口的默认方法和静态方法
✅ 理解var关键字的使用和限制
✅ 熟练使用Switch表达式
✅ 了解Java版本演进和新特性趋势

📈 学习成果检验

🎯 自我检测清单

能够使用Lambda表达式简化代码
熟练运用Stream API处理集合数据
掌握新日期时间API替代传统Date类
正确使用Optional避免空指针异常
理解模块化系统的基本概念
了解Java新版本的重要特性

🚀 进阶学习方向

方向	内容	推荐资源
🔧 函数式编程深入	Vavr库、响应式编程	RxJava、Project Reactor
🌊 大数据处理	并行计算、分布式处理	Apache Spark、Flink
⏰ 时间处理进阶	复杂时区、历法系统	Joda-Time迁移指南
📦 模块化实践	大型项目模块化、OSGi	Spring Boot模块化

🗺️ 专栏学习路径图

📈 Java程序员从0到1成长路径

🎯 第一阶段：Java基础入门 (4-6周) - ✅ 已完成
┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│ 1.开发环境   │───▶│ 2.基础语法   │───▶│ 3.面向对象   │───▶│ 4.核心API   │
│   搭建      │    │             │    │   编程基础   │    │             │
│ ✅ 已完成    │    │ ✅ 已完成    │    │ ✅ 已完成    │    │ ✅ 已完成    │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘

🚀 第二阶段：Java进阶技能 (4-6周)
┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│ 1.高级特性   │    │ 2.I/O与网络  │    │ 3.新特性     │    │ 4.工具框架   │
│             │    │   编程      │    │             │    │   入门      │
│ ✅ 已完成    │    │ ✅ 已完成    │    │ ✅ 已完成    │    │ 🎯 下一步    │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘

🎓 第三阶段：企业级开发 (6-8周)
┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│ 1.Spring     │    │ 2.数据库     │    │ 3.Web开发    │    │ 4.微服务     │
│   框架      │    │   技术      │    │             │    │   架构      │
│ 📅 计划中    │    │ 📅 计划中    │    │ 📅 计划中    │    │ 📅 计划中    │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘

📊 第二阶段详细进度

章节	主要内容	预计时间	难度	状态
🔧 1.Java高级特性	泛型、反射、注解、枚举	1-2周	⭐⭐⭐⭐	✅ 已完成
📁 2.I/O与网络编程	文件操作、网络通信、多线程	1-2周	⭐⭐⭐⭐	✅ 已完成
🆕 3.Java新特性	Lambda、Stream API、新日期API	1周	⭐⭐⭐⭐	✅ 已完成
🛠️ 4.工具与框架入门	Maven/Gradle、JUnit、日志框架	1周	⭐⭐⭐	🎯 下一步