Java 8 是自 Java 5 以来最重要的一次版本升级，它引入了大量新特性，极大地改变了 Java 开发的方式，尤其是在函数式编程、集合处理、并发编程和 API 设计方面，Java 7 则主要是对 Java 6 进行了一些增量改进。

下面我将从几个核心方面进行详细对比。

核心新特性对比

详细特性解读

核心语法与语言改进

Java 7 的改进 (准备阶段)

这些改进让代码更简洁,但尚未触及编程范式。

• try-with-resources (自动资源管理)

  • 问题: 在 Java 7 之前，必须手动关闭 InputStream, Connection 等资源，否则可能导致资源泄漏，通常使用 try-finally，代码冗长且容易出错。
  • 解决方案: 只要在 try 语句中声明的资源实现了 AutoCloseable 接口，try 语句块执行完毕后，close() 方法会自动被调用。
  • Java 7 代码示例:

    try (BufferedReader br = new BufferedReader(new FileReader("path/to/file.txt"))) {
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    // br.close() 会自动执行，无需在 finally 中手动关闭

• switch 支持 String

  • 问题: 之前 switch 只支持 int, byte, short, char 等基本类型及其包装类。
  • 解决方案: Java 7 允许在 switch 语句中使用 String，其内部是通过 String.hashCode() 和 equals() 方法实现的。
  • Java 7 代码示例:

    String type = "B";
    switch (type) {
        case "A":
            System.out.println("Type A");
            break;
        case "B":
            System.out.println("Type B");
            break;
        default:
            System.out.println("Unknown type");
    }

• 多异常捕获

  • 问题: 如果多个 catch 块处理的异常代码逻辑相同，需要重复编写。
  • 解决方案: 可以在一个 catch 块中捕获多个异常，用 分隔。
  • Java 7 代码示例:

    try {
        // 可能抛出 IOException 或 SQLException
    } catch (IOException | SQLException e) {
        // 处理两种异常
        e.printStackTrace();
    }

Java 8 的革命性飞跃 (范式改变)

Java 8 的特性彻底改变了 Java 开发者编写代码的方式。

• Lambda 表达式 (函数式编程核心)

  • 问题: 匿名内部类（Runnable, Comparator 等）代码冗长，可读性差。

  • 解决方案: 引入 Lambda 表达式，允许将函数作为方法参数传递，使代码更简洁、更灵活。

  • Java 8 代码示例:

    // Java 7: 使用匿名内部类
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("Hello from Java 7");
        }
    }).start();
    // Java 8: 使用 Lambda 表达式
    new Thread(() -> System.out.println("Hello from Java 8")).start();

  • 语法: (parameters) -> { statements; }，当只有一个参数且方法体只有一行时，可以进一步简化。

• Stream API (集合处理的革命)

  • 问题: 对集合进行复杂的查询、过滤、转换等操作时，传统的 for 循环代码冗长且难以并行化。

  • 解决方案: Stream API 提供了一种声明式的方式来处理集合数据，支持链式调用和并行处理。

  • Java 8 代码示例:

    List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
    // Java 7: 使用 for 循环
    List<String> longNames = new ArrayList<>();
    for (String name : names) {
        if (name.length() > 4) {
            longNames.add(name.toUpperCase());
        }
    }
    // Java 8: 使用 Stream API
    List<String> longNamesStream = names.stream() // 创建流
                                      .filter(name -> name.length() > 4) // 过滤
                                      .map(String::toUpperCase) // 转换
                                      .collect(Collectors.toList()); // 收集结果

• 接口的默认方法和静态方法

  • 问题: 在 Java 8 之前，接口中只能有抽象方法和常量，一旦接口发布，为其添加新方法会破坏所有现有的实现类。
  • 解决方案: 接口中可以添加 default 方法和 static 方法。default 方法为接口提供了默认实现，实现类可以选择覆盖；static 方法则属于接口本身，不能被实现类继承。
  • 意义: 这是为集合框架（如 Collection.forEach()）和 Java 8 新特性（如 Stream）向后兼容而设计的。

• Optional<T> 类 (优雅处理 null)

  • 问题: NullPointerException 是 Java 开发中最常见的异常之一，显式的 null 检查让代码变得臃肿。

  • 解决方案: Optional 是一个容器类，它可以包含或者不包含一个非 null 的值，它提供了一系列方法来优雅地处理可能为 null 的值。

  • Java 8 代码示例:

    String name = findName(); // 这个方法可能返回 null
    // Java 7: 显式 null 检查
    if (name != null) {
        System.out.println(name.length());
    }
    // Java 8: 使用 Optional
    Optional<String> nameOpt = Optional.ofNullable(findName());
    nameOpt.ifPresent(n -> System.out.println(n.length()));

API 库的增强

Java 7

• diamond 操作符 (泛型类型推断)
  • 在创建泛型实例时,编译器可以从变量的声明中推断出泛型类型，因此右侧可以省略。
  • Java 7 之前: List<String> list = new ArrayList<String>();
  • Java 7 之后: List<String> list = new ArrayList<>();

Java 8

• 全新的日期时间 API (java.time 包)

  • 问题: 旧的日期时间 API (java.util.Date, java.util.Calendar) 存在诸多问题，如线程不安全、设计混乱、API 不直观等。

  • 解决方案: 引入了 Joda-Time 框架的设计者开发的 java.time 包，提供了不可变、线程安全的日期和时间类。

  • 核心类:

    • LocalDate: 只包含日期 (年-月-日)。
    • LocalTime: 只包含时间 (时-分-秒-纳秒)。
    • LocalDateTime: 包含日期和时间。
    • ZonedDateTime: 包含时区的日期和时间。

  • Java 8 代码示例:

    LocalDate today = LocalDate.now();
    LocalTime time = LocalTime.now();
    LocalDateTime dateTime = LocalDateTime.now();
    System.out.println("Today: " + today);
    System.out.println("Time: " + time);

• CompletableFuture (异步编程)

  • 问题: Future 虽然可以表示异步计算的结果，但它提供的功能非常有限，无法进行复杂的链式调用和异常处理。
  • 解决方案: CompletableFuture 实现了 Future 和 CompletionStage 接口，提供了强大的函数式编程能力，可以轻松组合多个异步任务。
  • Java 8 代码示例:

    CompletableFuture.supplyAsync(() -> "Hello")
                    .thenApply(s -> s + " World")
                    .thenAccept(System.out::println); // 输出: Hello World

总结与对比表格

• 如果你还在使用 Java 7，强烈建议升级到 Java 8 或更高版本，Java 8 引入的特性已经成为现代 Java 开发的标准实践。
• Java 7 是一个优秀的版本，但它更像是一个“垫脚石”，为 Java 8 的巨大飞跃铺平了道路。
• Java 8 的 Lambda 表达式 和 Stream API 是其最核心、最耀眼的新特性，它们让 Java 代码第一次具备了其他函数式编程语言（如 Scala, Kotlin）的简洁性和表达能力。

可以说,Java 8 是现代 Java 的起点，之后的所有版本（Java 9, 10, 11, 17 LTS...）都是在 Java 8 奠定的基础上进行演进和完善。