JDK 1.8 新特性实战：从接口默认方法到 Stream 流

定义接口 IFormula，calculate 为抽象方法，sqrt 为 default 方法：

javapublic interface IFormula {
    double calculate(int a);
    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}
// 使用匿名内部类
IFormula formula = new IFormula() {
    @Override
    public double calculate(int a) { return a * a; }
};
System.out.println(formula.calculate(2)); // 4
System.out.println(formula.sqrt(2));       // 1.414...

Collections.sort 的两种写法对比：

javaList<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
// 旧写法：匿名内部类
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return b.compareTo(a);
    }
});
// Lambda 写法：编译器推断 a, b 为 String
Collections.sort(names, (a, b) -> b.compareTo(a));

两种写法功能完全等价，但 Lambda 版去掉了模板代码。

自定义函数式接口并加约束注解：

java@FunctionalInterface
public interface IConverter<F, T> {
    T convert(F from);
}
// 用 Lambda 实现
IConverter<String, Integer> converter = from -> Integer.valueOf(from);
// 如果误加第二个抽象方法会编译报错：
// T convert2(F from); // 编译失败
Integer result = converter.convert("123"); // 123

方法引用四种形态的调用示例：

java// 静态方法引用
IConverter<Integer, String> c1 = String::valueOf;
// 实例方法引用（特定对象）
Something s = new Something();
IConverter<String, String> c2 = s::startsWith;
// 构造函数引用
interface PersonFactory<P> { P create(String name); }
PersonFactory<Person> pf = Person::new;
Person p = pf.create("小明");

注意：方法引用只适用于 Lambda 体只调用一个方法、不做其他操作的场景。

Function 链式组合与 Supplier 生产示例：

java// Function: compose 和 andThen 方向相反
Function<String, Integer> toInt = Integer::valueOf;
Function<String, String> back = toInt.andThen(String::valueOf);
// 执行顺序：先 toInt 再 String::valueOf
String r1 = back.apply("123"); // "123"

// Supplier: 无入参直接 get
Supplier<String> supplier = () -> "hi";
String r2 = supplier.get(); // "hi"

// Lambda 不能访问接口 default 方法：
// IFormula f = a -> sqrt(a * a); // 编译失败

Stream 链式过滤、排序、转换、输出：

javaList<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
// 中间操作链 + 终端操作
names.stream()
    .filter(n -> n.startsWith("a")) // Predicate 过滤
    .sorted(String::compareTo)       // Comparator 排序
    .map(String::toUpperCase)        // Function 转换
    .forEach(System.out::println);   // 终端操作
// 输出：ANNA
// 若不加 forEach 等，以上 filter/sorted/map 不会执行

Optional 空值安全与并行流对比：

java// Optional 安全处理
String maybeNull = null;
String result = Optional.ofNullable(maybeNull)
    .map(String::toUpperCase)
    .orElse("DEFAULT");
// result = "DEFAULT"
// Optional.of(null) 会直接 NPE

// 顺序流 vs 并行流
List<Integer> big = IntStream.range(0, 1_000_000)
    .boxed().collect(Collectors.toList());
long seq = big.stream().filter(x -> x % 2 == 0).count();
long par = big.parallelStream()
    .filter(x -> x % 2 == 0).count();
// 大数据集并行可能更快，小数据集反而更慢