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

public class Java8Features {
    // Lambda表达式
    public void lambdaDemo() {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // 使用lambda过滤和转换
        numbers.stream()
               .filter(n -> n % 2 == 0)
               .map(n -> n * n)
               .forEach(System.out::println);
    }
    
    // Stream API
    public void streamApiDemo() {
        List<String> words = Arrays.asList("hello", "world", "java", "stream");
        
        // 统计长度>3的单词
        long count = words.stream()
                          .filter(w -> w.length() > 3)
                          .count();
        System.out.println("Count: " + count);
        
        // 转换成包含长度的map
        Map<String, Integer> wordLengths = words.stream()
                                               .collect(Collectors.toMap(
                                                   Function.identity(),
                                                   String::length
                                               ));
    }
    
    // Optional处理null
    public void optionalDemo() {
        Optional<String> optional = Optional.of("Java");
        
        optional.ifPresent(System.out::println);
        String result = optional.orElse("Default");
        String mapped = optional.map(String::toUpperCase)
                               .orElse("EMPTY");
    }
}

Java 11/ 17特性

// Java 10+ - var类型推导
public class ModernJavaFeatures {
    public void varDemo() {
        var name = "Java";      // 推导为String
        var numbers = List.of(1, 2, 3);  // 推导为List<Integer>
        var map = new HashMap<String, Integer>();  // 推导为HashMap
        
        // 在循环中使用
        for (var num : numbers) {
            System.out.println(num);
        }
    }
    
    // Java 13+ - 文本块
    public String textBlockDemo() {
        String json = """
            {
                "name": "John",
                "age": 30,
                "city": "New York"
            }
            """;
        return json;
    }
    
    // Java 14+ - Records（数据类）
    public record Person(String name, int age, String email) {
        // 自动生成构造器、equals、hashCode、toString
        // 可以添加验证逻辑
        public Person {
            if (age < 0) throw new IllegalArgumentException("Age cannot be negative");
        }
    }
}

并发编程

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class ConcurrencyDemo {
    // 线程安全的计数器
    private AtomicInteger counter = new AtomicInteger(0);
    
    // 使用线程池
    public void threadPoolDemo() {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("Task " + taskId + " running");
                counter.incrementAndGet();
            });
        }
        
        executor.shutdown();
        try {
            executor.awaitTermination(1, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    
    // 使用CountDownLatch等待多个任务
    public void countDownLatchDemo() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        
        for (int i = 0; i < 3; i++) {
            final int taskId = i;
            new Thread(() -> {
                System.out.println("Task " + taskId + " starting");
                try {
                    Thread.sleep(100);
                    System.out.println("Task " + taskId + " done");
                } finally {
                    latch.countDown();
                }
            }).start();
        }
        
        latch.await();  // 等待所有任务完成
        System.out.println("All tasks completed");
    }
    
    // 同步化访问
    public synchronized void synchronizedMethod() {
        counter.incrementAndGet();
    }
    
    // Lock接口
    private final Object lock = new Object();
    public void lockDemo() {
        synchronized (lock) {
            counter.incrementAndGet();
        }
    }
}

资源管理和异常处理

import java.io.*;
import java.nio.file.*;

public class ResourceManmentation {
    // try-with-resources 自动管理资源
    public String readFileModern(String filename) throws IOException {
        try (BufferedReader reader = new BufferedReader(new FileReader(filename))) {
            return reader.lines()
                        .collect(Collectors.joining("\n"));
        }
    }
    
    // 多个资源管理
    public void multipleResourcesDemo() throws IOException {
        try (
            FileReader reader = new FileReader("input.txt");
            FileWriter writer = new FileWriter("output.txt")
        ) {
            // 使用reader和writer
            char[] buffer = new char[1024];
            int bytesRead;
            while ((bytesRead = reader.read(buffer)) != -1) {
                writer.write(buffer, 0, bytesRead);
            }
        }
        // 资源自动关闭
    }
    
    // 自定义AutoCloseable资源
    public static class DatabaseConnection implements AutoCloseable {
        private String connectionString;
        
        public DatabaseConnection(String connStr) {
            this.connectionString = connStr;
            System.out.println("Opening connection to " + connStr);
        }
        
        @Override
        public void close() {
            System.out.println("Closing connection");
        }
        
        public void execute(String sql) {
            System.out.println("Executing: " + sql);
        }
    }
    
    // 使用自定义资源
    public void customResource (final int taskId = i;
            executor.execute(() -> {
                System.out.println("Task " + taskId + " running");
                counter.incrementAndGet();
            });
        }
        
        executor.shutdown();
    }
    
    public static void main(String[] args) throws Exception {
        try (DatabaseConnection conn = new DatabaseConnection("jdbc:mysql://localhost/mydb")) {
            conn.execute("SELECT * FROM users");
        }
        // 连接自动关闭
    }
}

集合框架性能考虑

import java.util.*;

public class CollectionPerformance {
    // 选择合适的集合类
    public void collectionChoiceDemo() {
        // List - 有序，可重复
        List<String> list = new ArrayList<>(100);  // 指定容量避免扩容
        list.add("item1");
        list.add("item2");
        
        // Set - 无序，不重复
        Set<String> set = new HashSet<>(100);  // 指定容量
        set.add("item1");
        set.add("item2");
        
        // Map - 键值对
        Map<String, Integer> map = new HashMap<>(100);
        map.put("key1", 1);
        map.put("key2", 2);
        
        // 线程安全的集合
        Map<String, Integer> concurrent = new ConcurrentHashMap<>();
        concurrent.putIfAbsent("key", 1);
    }
    
    // 迭代方式的性能考虑
    public void iterationDemo(List<String> items) {
        // 最快 - 直接索引
        for (int i = 0; i < items.size(); i++) {
            System.out.println(items.get(i));
        }
        
        // 推荐 - 增强for循环
        for (String item : items) {
            System.out.println(item);
        }
        
        // 通用 - 迭代器
        for (Iterator<String> it = items.iterator(); it.hasNext(); ) {
            System.out.println(it.next());
        }
        
        // 函数式 - 可读性好但可能有额外开销
        items.forEach(System.out::println);
    }
}