Java面试必备：JDK 8 新特性详解

Java基础面试题 - JDK8有哪些新特性?

一、Lambda 表达式

Lambda 表达式是 JDK 8 最引人注目的特性之一，它允许我们将函数作为方法参数传递，使代码更加简洁。

基本语法

(parameters) -> expression
或
(parameters) -> { statements; }

示例代码

// 旧方式 - 匿名内部类
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World 1");
    }
};

// 新方式 - Lambda 表达式
Runnable r2 = () -> System.out.println("Hello World 2");

// 执行
r1.run();
r2.run();

Lambda 表达式流程图

二、函数式接口

函数式接口是只包含一个抽象方法的接口，可以使用 @FunctionalInterface 注解标记。

示例代码

@FunctionalInterface
interface MathOperation {
    int operate(int a, int b);
}

public class FunctionalInterfaceExample {
    public static void main(String[] args) {
        MathOperation addition = (a, b) -> a + b;
        MathOperation subtraction = (a, b) -> a - b;
        
        System.out.println("10 + 5 = " + operate(10, 5, addition));
        System.out.println("10 - 5 = " + operate(10, 5, subtraction));
    }
    
    private static int operate(int a, int b, MathOperation mathOperation) {
        return mathOperation.operate(a, b);
    }
}

三、Stream API

Stream API 提供了一种高效处理集合数据的方式，支持顺序和并行处理。

Stream 操作流程图

示例代码

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

public class StreamExample {
    public static void main(String[] args) {
        List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
        
        // 过滤空字符串
        List<String> filtered = strings.stream()
            .filter(string -> !string.isEmpty())
            .collect(Collectors.toList());
        
        System.out.println("过滤后的列表: " + filtered);
        
        // 并行处理
        long count = strings.parallelStream()
            .filter(string -> string.isEmpty())
            .count();
            
        System.out.println("空字符串数量: " + count);
    }
}

四、方法引用

方法引用是 Lambda 表达式的简化写法，用于直接引用已有方法。

四种方法引用类型

1. 静态方法引用：ClassName::staticMethod
2. 实例方法引用：instance::instanceMethod
3. 特定类型的任意对象方法引用：ClassName::instanceMethod
4. 构造方法引用：ClassName::new

示例代码

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

public class MethodReferenceExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        
        // Lambda 表达式
        names.forEach(s -> System.out.println(s));
        
        // 方法引用
        names.forEach(System.out::println);
    }
}

五、默认方法和静态方法

JDK 8 允许接口中包含具有实现的方法（默认方法和静态方法）。

示例代码

interface Vehicle {
    // 默认方法
    default void print() {
        System.out.println("我是一辆车!");
    }
    
    // 静态方法
    static void blowHorn() {
        System.out.println("按喇叭!!!");
    }
}

class Car implements Vehicle {}

public class DefaultMethodExample {
    public static void main(String[] args) {
        Vehicle vehicle = new Car();
        vehicle.print();    // 调用默认方法
        Vehicle.blowHorn();  // 调用静态方法
    }
}

六、新的日期时间 API

JDK 8 引入了全新的日期时间 API (java.time 包)，解决了旧 API 的线程安全和设计问题。

示例代码

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.Month;
import java.time.format.DateTimeFormatter;

public class DateTimeExample {
    public static void main(String[] args) {
        // 获取当前日期和时间
        LocalDateTime currentTime = LocalDateTime.now();
        System.out.println("当前时间: " + currentTime);
        
        // 格式化日期
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formatted = currentTime.format(formatter);
        System.out.println("格式化时间: " + formatted);
        
        // 创建特定日期
        LocalDate date = LocalDate.of(2023, Month.JANUARY, 1);
        System.out.println("特定日期: " + date);
    }
}

七、Optional 类

Optional 类是一个容器对象，可以包含或不包含非空值，用于更优雅地处理 null 值。

Optional 使用流程图

示例代码

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> optional = Optional.of("Hello");
        
        // 检查值是否存在
        System.out.println("值是否存在: " + optional.isPresent());
        
        // 如果存在值则执行操作
        optional.ifPresent(System.out::println);
        
        // 如果值为空则返回默认值
        System.out.println(optional.orElse("默认值"));
        
        // 使用 map 转换值
        System.out.println(optional.map(String::toUpperCase).orElse("默认值"));
    }
}

八、Nashorn JavaScript 引擎

JDK 8 引入了新的 JavaScript 引擎 Nashorn，替代了旧的 Rhino 引擎。

示例代码

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class NashornExample {
    public static void main(String[] args) {
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("nashorn");
        
        try {
            // 执行 JavaScript 代码
            engine.eval("print('Hello from JavaScript!')");
            
            // 调用 JavaScript 函数
            engine.eval("function sum(a, b) { return a + b; }");
            Object result = engine.eval("sum(10, 20);");
            System.out.println("结果: " + result);
        } catch (ScriptException e) {
            e.printStackTrace();
        }
    }
}

九、Base64 支持

JDK 8 在标准库中增加了 Base64 编码解码的支持。

示例代码

import java.util.Base64;

public class Base64Example {
    public static void main(String[] args) {
        // 基本编码
        String original = "Hello World!";
        String encoded = Base64.getEncoder().encodeToString(original.getBytes());
        System.out.println("编码后: " + encoded);
        
        // 解码
        byte[] decoded = Base64.getDecoder().decode(encoded);
        System.out.println("解码后: " + new String(decoded));
    }
}

十、并行数组排序

JDK 8 新增了 Arrays.parallelSort() 方法，利用多核处理器并行排序大数组。

示例代码

import java.util.Arrays;

public class ParallelSortExample {
    public static void main(String[] args) {
        int[] numbers = new int[1000000];
        
        // 填充随机数
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = (int) (Math.random() * 1000000);
        }
        
        // 并行排序
        long start = System.currentTimeMillis();
        Arrays.parallelSort(numbers);
        long end = System.currentTimeMillis();
        
        System.out.println("并行排序耗时: " + (end - start) + " 毫秒");
    }
}

总结

JDK 8 的这些新特性极大地提升了 Java 的表达能力和开发效率，特别是 Lambda 表达式和 Stream API 的引入，使得函数式编程风格在 Java 中成为可能。这些特性不仅使代码更加简洁，还能更好地利用多核处理器的优势，提高程序性能。