掌握Java 8，轻松上手的30个实用新特性应用案例解析

Java 8作为Java语言的一个重要版本，引入了许多新特性和改进，使得开发人员能够更高效地编写代码。以下将详细介绍Java 8的30个实用新特性，并通过具体的应用案例进行解析，帮助读者轻松上手。

1. Lambda表达式

Lambda表达式是Java 8中的一大亮点，它允许开发者以更简洁的方式编写匿名函数。

案例：使用Lambda表达式对列表进行排序。

import java.util.Arrays;
import java.util.List;

public class LambdaExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        names.sort((name1, name2) -> name1.compareTo(name2));
        System.out.println(names);
    }
}

2. Stream API

Stream API提供了对集合的高阶操作，如过滤、映射、排序等。

案例：使用Stream API计算列表中所有偶数的和。

import java.util.Arrays;
import java.util.List;

public class StreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        int sum = numbers.stream()
                         .filter(n -> n % 2 == 0)
                         .mapToInt(Integer::intValue)
                         .sum();
        System.out.println(sum);
    }
}

3. 方法引用

方法引用允许开发者以更简洁的方式引用现有的方法。

案例：使用方法引用计算字符串长度。

import java.util.Arrays;
import java.util.List;

public class MethodReferenceExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        names.forEach(String::length);
    }
}

4. 默认方法

接口可以添加默认方法，实现多继承的效果。

案例：为Comparable接口添加默认方法。

public interface Comparable<T> {
    int compareTo(T o);
    default void print() {
        System.out.println("Hello");
    }
}

5. 新的日期和时间API

Java 8引入了新的日期和时间API，如java.time包。

案例：获取当前日期和时间。

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class DateTimeExample {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        System.out.println(now.format(formatter));
    }
}

6. 新的集合操作

Java 8提供了许多新的集合操作，如removeIf、forEach等。

案例：使用removeIf移除列表中的偶数。

import java.util.Arrays;
import java.util.List;

public class CollectionExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        numbers.removeIf(n -> n % 2 == 0);
        System.out.println(numbers);
    }
}

7. 新的并发API

Java 8提供了新的并发API，如CompletableFuture。

案例：使用CompletableFuture实现异步操作。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello";
        });
        future.thenAccept(System.out::println);
    }
}

8. 新的文件API

Java 8提供了新的文件API，如java.nio.file包。

案例：读取文件内容。

import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.IOException;
import java.util.List;

public class FileExample {
    public static void main(String[] args) {
        try {
            List<String> lines = Files.readAllLines(Paths.get("example.txt"));
            lines.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

9. 新的数学函数

Java 8提供了新的数学函数，如Math.round。

案例：使用Math.round进行四舍五入。

public class MathExample {
    public static void main(String[] args) {
        double value = 3.6;
        int roundedValue = Math.round(value);
        System.out.println(roundedValue);
    }
}

10. 新的线程池API

Java 8提供了新的线程池API，如ForkJoinPool。

案例：使用ForkJoinPool进行并行计算。

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class ForkJoinExample {
    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        int result = pool.invoke(new MyRecursiveTask(1, 100));
        System.out.println(result);
    }

    static class MyRecursiveTask extends RecursiveTask<Integer> {
        private final int start;
        private final int end;

        public MyRecursiveTask(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        protected Integer compute() {
            if (end - start <= 10) {
                return end * end;
            } else {
                int mid = (start + end) / 2;
                MyRecursiveTask task1 = new MyRecursiveTask(start, mid);
                MyRecursiveTask task2 = new MyRecursiveTask(mid + 1, end);
                task1.fork();
                int result = task2.compute();
                return result + task1.join();
            }
        }
    }
}

11. 新的集合类型

Java 8引入了新的集合类型，如Map.Entry。

案例：使用Map.Entry遍历Map。

import java.util.HashMap;
import java.util.Map;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Alice", 1);
        map.put("Bob", 2);
        map.put("Charlie", 3);

        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

12. 新的字符串操作

Java 8提供了新的字符串操作，如String.join。

案例：使用String.join连接字符串。

public class StringExample {
    public static void main(String[] args) {
        String result = String.join(", ", "Alice", "Bob", "Charlie");
        System.out.println(result);
    }
}

13. 新的并发工具

Java 8提供了新的并发工具，如ConcurrentHashMap。

案例：使用ConcurrentHashMap实现线程安全的Map。

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        map.put("Alice", 1);
        map.put("Bob", 2);
        map.put("Charlie", 3);

        System.out.println(map);
    }
}

14. 新的I/O操作

Java 8提供了新的I/O操作，如Files.walk。

案例：使用Files.walk遍历目录。

import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.IOException;
import java.util.List;

public class IOExample {
    public static void main(String[] args) {
        try {
            List<String> paths = Files.walk(Paths.get("example"))
                                         .filter(Files::isRegularFile)
                                         .map(path -> path.toAbsolutePath().toString())
                                         .collect(Collectors.toList());
            paths.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

15. 新的集合视图

Java 8提供了新的集合视图，如Set.viewAsSortedSet。

案例：使用Set.viewAsSortedSet获取有序的Set。

import java.util.Arrays;
import java.util.Set;
import java.util.TreeSet;

public class SetExample {
    public static void main(String[] args) {
        Set<Integer> set = new TreeSet<>(Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5));
        Set<Integer> sortedSet = set.viewAsSortedSet();
        System.out.println(sortedSet);
    }
}

16. 新的集合迭代器

Java 8提供了新的集合迭代器，如Set.iterator。

案例：使用Set.iterator遍历Set。

import java.util.Arrays;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        Set<Integer> set = new TreeSet<>(Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5));
        for (Integer number : set) {
            System.out.println(number);
        }
    }
}

17. 新的集合转换

Java 8提供了新的集合转换，如Set.of。

案例：使用Set.of创建不可变的Set。

import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        Set<Integer> set = Set.of(1, 2, 3, 4, 5);
        System.out.println(set);
    }
}

18. 新的集合操作符

Java 8提供了新的集合操作符，如Set.union。

案例：使用Set.union合并两个Set。

import java.util.Arrays;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        Set<Integer> set1 = Set.of(1, 2, 3);
        Set<Integer> set2 = Set.of(4, 5, 6);
        Set<Integer> union = set1.union(set2);
        System.out.println(union);
    }
}

19. 新的集合过滤

Java 8提供了新的集合过滤，如Set.stream。

案例：使用Set.stream过滤Set。

import java.util.Arrays;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        Set<Integer> set = Set.of(1, 2, 3, 4, 5);
        set.stream()
           .filter(n -> n % 2 == 0)
           .forEach(System.out::println);
    }
}

20. 新的集合映射

Java 8提供了新的集合映射，如Set.map。

案例：使用Set.map将Set中的元素转换为其他类型。

import java.util.Arrays;
import java.util.Set;
import java.util.stream.Collectors;

public class SetExample {
    public static void main(String[] args) {
        Set<Integer> set = Set.of(1, 2, 3, 4, 5);
        Set<String> stringSet = set.stream()
                                   .map(String::valueOf)
                                   .collect(Collectors.toSet());
        System.out.println(stringSet);
    }
}

21. 新的集合排序

Java 8提供了新的集合排序，如Set.sorted。

案例：使用Set.sorted对Set进行排序。

import java.util.Arrays;
import java.util.Set;
import java.util.stream.Collectors;

public class SetExample {
    public static void main(String[] args) {
        Set<Integer> set = Set.of(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5);
        Set<Integer> sortedSet = set.stream()
                                    .sorted()
                                    .collect(Collectors.toSet());
        System.out.println(sortedSet);
    }
}

22. 新的集合聚合

Java 8提供了新的集合聚合，如Set.reduce。

案例：使用Set.reduce计算Set中所有元素的和。

import java.util.Arrays;
import java.util.Set;
import java.util.stream.Collectors;

public class SetExample {
    public static void main(String[] args) {
        Set<Integer> set = Set.of(1, 2, 3, 4, 5);
        int sum = set.stream()
                     .reduce(0, Integer::sum);
        System.out.println(sum);
    }
}