Java8的新特性有哪些 举代码例子说明

时间：2024-11-13 08:32:16

Java 8 引入了许多新特性，极大地扩展了 Java 的功能并改善了开发体验。以下是 Java 8 中一些主要的新特性及代码示例：

1. Lambda 表达式

Lambda 表达式是一种简洁的函数式编程方式，可以用来简化代码，特别适合集合操作和流操作。

// 原来方式：使用匿名内部类
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(new Consumer<String>() {
    @Override
    public void accept(String name) {
        System.out.println(name);
    }
});

// Lambda 表达式
names.forEach(name -> System.out.println(name));

2. 方法引用

方法引用是一种简化 Lambda 表达式的方式，特别适合一些直接调用现有方法的场景。它用 :: 表示，可以引用静态方法、实例方法和构造方法。

// 方法引用的例子
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// 使用 Lambda 表达式
names.forEach(name -> System.out.println(name));

// 使用方法引用
names.forEach(System.out::println);

3. Stream API

Stream API 用于处理集合数据，可以执行诸如过滤、映射、规约等操作，支持链式调用和并行处理。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// 使用 Stream 过滤并求和
int sum = numbers.stream()
                 .filter(n -> n % 2 == 0)  // 过滤偶数
                 .mapToInt(Integer::intValue)  // 转换为 int
                 .sum();  // 求和
System.out.println(sum);  // 输出 30

4. 接口的默认方法和静态方法

Java 8 允许在接口中定义默认方法和静态方法，使接口可以有一些默认实现。

interface MyInterface {
    // 默认方法
    default void defaultMethod() {
        System.out.println("This is a default method");
    }
    
    // 静态方法
    static void staticMethod() {
        System.out.println("This is a static method");
    }
}

class MyClass implements MyInterface {}

public class Test {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.defaultMethod();  // 调用默认方法
        MyInterface.staticMethod();  // 调用接口的静态方法
    }
}

5. Optional 类

Optional 类是一个容器类，用于表示可能包含或不包含值，常用于避免 NullPointerException。

Optional<String> optional = Optional.of("Hello");

// 使用 ifPresent 检查并执行操作
optional.ifPresent(value -> System.out.println(value));

// 使用 orElse 提供默认值
String result = optional.orElse("Default Value");
System.out.println(result);

// 使用 map 转换值
Optional<Integer> length = optional.map(String::length);
length.ifPresent(System.out::println);

6. 新的日期和时间 API

Java 8 引入了全新的 java.time 包，提供了更完善的日期和时间支持，包括不可变类型和更直观的 API。

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

public class Test {
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();  // 获取当前日期
        LocalTime time = LocalTime.now();  // 获取当前时间
        LocalDateTime dateTime = LocalDateTime.now();  // 获取当前日期时间
        
        System.out.println("Date: " + date);
        System.out.println("Time: " + time);
        System.out.println("DateTime: " + dateTime);

        // 自定义格式化日期时间
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedDateTime = dateTime.format(formatter);
        System.out.println("Formatted DateTime: " + formattedDateTime);
    }
}

7. 重复注解

Java 8 支持在同一位置使用多个相同类型的注解，称为重复注解。

import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Repeatable(Schedules.class)
@interface Schedule {
    String day();
}

@Retention(RetentionPolicy.RUNTIME)
@interface Schedules {
    Schedule[] value();
}

@Schedule(day = "Monday")
@Schedule(day = "Wednesday")
public class Test {
    public static void main(String[] args) {
        Schedule[] schedules = Test.class.getAnnotationsByType(Schedule.class);
        for (Schedule schedule : schedules) {
            System.out.println(schedule.day());
        }
    }
}

8. 类型推断改进

Java 8 在泛型类型推断方面有所改进，允许在泛型类的构造中使用空的尖括号 <>，称为菱形操作符，进一步简化代码。

Map<String, List<String>> map = new HashMap<>();  // <> 代表推断类型
List<String> list = new ArrayList<>();

9. CompletableFuture

CompletableFuture 是 Java 8 中提供的异步编程新工具，允许更简洁地处理异步任务并组合多个任务的结果。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);  // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello, CompletableFuture!";
        });
        
        future.thenAccept(result -> System.out.println("Result: " + result));  // 异步处理结果
        System.out.println("Main thread continues...");
    }
}

总结

Java 8 引入的这些特性极大地提高了开发的灵活性和代码的简洁性，同时也为函数式编程和异步编程提供了更强大的支持。

相关文章