Java8新特性

最新推荐文章于 2024-08-30 18:40:43 发布

学Java的skyyyyyyyy

最新推荐文章于 2024-08-30 18:40:43 发布

阅读量885

点赞数 8

文章标签：开发语言 java

本文链接：https://blog.csdn.net/weixin_61669379/article/details/141686980

版权

Java8是Java语言的一次重要更新，引入了许多新特性，使得编写代码更简洁，易于维护和功能更强大

1.Lambda表达式

Lambda表达式是Java8最重要的特性之一，它引入了一种简洁的方式来表示匿名函数
语法：

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

示例：

// 传统方式
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello, World!");
    }
};

// Lambda 表达式方式
Runnable lambdaRunnable = () -> System.out.println("Hello, World!");

2.函数式接口

函数式接口是只有一个抽象方法的接口，Java8中引入了@FunctionalInterface注解来显式声明函数式接口。Lambda表达式通常与函数式接口一起使用。
示例：

@FunctionalInterface
public interface MyFunctionalInterface {
    void execute();
}

// 使用Lambda表达式实现接口
MyFunctionalInterface myFunction = () -> System.out.println("执行功能");
myFunction.execute();

3.方法引用（Method References）

方法引用是Lambda表达式的一种简写形式，可以直接引用现有的方法。
语法：

ClassName::methodName

示例：

// 使用Lambda表达式
Consumer<String> print = x -> System.out.println(x);

// 使用方法引用
Consumer<String> printMethodRef = System.out::println;

4. Stream API

Stream API提供了一种功能强大的操作集合数据的新方式，可以轻松实现过滤、排序、映射和减少等操作，Stream API支持顺序流和并行流。
示例：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// 使用 Stream API 进行过滤和转换
List<String> filteredNames = names.stream()
                                  .filter(name -> name.startsWith("A"))
                                  .map(String::toUpperCase)
                                  .collect(Collectors.toList());

System.out.println(filteredNames); // 输出: [ALICE]

5.默认方法（Default Methods）

Java8允许在接口中定义默认方法，即带有实现的接口方法。这使得接口的演化更加灵活，而无需破坏现有的实现。
示例：

interface MyInterface {
    void existingMethod();

    // 默认方法
    default void newDefaultMethod() {
        System.out.println("这是一个默认方法");
    }
}

class MyClass implements MyInterface {
    @Override
    public void existingMethod() {
        System.out.println("实现现有方法");
    }
}

MyClass myClass = new MyClass();
myClass.newDefaultMethod(); // 调用默认方法

6.Optional类

Optional 类是 Java 8 中引入的一个非常有用的工具，用于处理可能为 null 的值。它的主要目的是减少空指针异常 (NullPointerException)，使得代码更加健壮和可读。通过使用 Optional，开发者可以明确地表达某些值可能不存在（即 null），并提供安全的方式来处理这些情况。
Optional的基本概念
Optional 是一个容器类，它可以保存类型为 T 的值，或者保存的是 null。Optional<T> 实际上是对可能存在的 T 类型值的包装器。
创建Optional对象
Optional 提供了几种静态方法来创建实例：
1.Optional.of(T value)
用于创建一个包含非 null 值的 Optional 对象。如果传入的值为 null，则会抛出 NullPointerException。
示例：

Optional<String> nonEmptyOptional = Optional.of("Hello, World!");

2.Optional.ofNullable(T value)
用于创建一个可能包含 null 值的 Optional 对象。如果传入的值为 null，则创建一个空的 Optional 对象。
示例：

Optional<String> nullableOptional = Optional.ofNullable(null); // 创建空的 Optional
Optional<String> nonEmptyOptional = Optional.ofNullable("Hello, World!"); // 创建包含值的 Optional

3.Optional.empty():
用于创建一个空的 Optional 对象。
示例：

Optional<String> emptyOptional = Optional.empty();

常用的Optional方法
1.isPresent() 和 isEmpty():
isPresent() 用于检查 Optional 中是否有值，如果有则返回 true，否则返回 false。
isEmpty() 是 Java 11 中引入的，用于检查 Optional 中是否没有值（即为空），如果为空则返回 true。
示例：

Optional<String> optional = Optional.of("Hello");
if(optional.isPresent()) {
    System.out.println("有值: " + optional.get());
}

2.get()
如果 Optional 中有值，则返回该值；如果为空，则抛出 NoSuchElementException。
示例：

Optional<String> optional = Optional.of("Hello");
String value = optional.get(); // 如果 optional 为空，这里会抛出异常

3.orElse(T other):
如果 Optional 中有值，返回该值；否则返回 orElse() 方法传入的默认值。

Optional<String> optional = Optional.ofNullable(null);
String value = optional.orElse("默认值");
System.out.println(value); // 输出: "默认值"

4.orElseGet(Supplier<? extends T> other):
与 orElse() 类似，但 orElseGet() 是在 Optional 为空时，通过 Supplier 接口提供的函数来生成默认值。
示例:

Optional<String> optional = Optional.ofNullable(null);
String value = optional.orElseGet(() -> "通过 Supplier 生成的值");
System.out.println(value); // 输出: "通过 Supplier 生成的值"

5.orElseThrow() 和 orElseThrow(Supplier<? extends X> exceptionSupplier):
orElseThrow() 如果 Optional 为空，抛出 NoSuchElementException。
orElseThrow(Supplier) 可以自定义抛出的异常类型。
示例：

Optional<String> optional = Optional.ofNullable(null);
String value = optional.orElseThrow(() -> new IllegalArgumentException("值不存在"));

6.ifPresent(Consumer<? super T> action):
如果 Optional 中有值，则对其执行给定的操作（传递一个 Consumer 函数）。
示例：

Optional<String> optional = Optional.of("Hello");
optional.ifPresent(System.out::println); // 如果有值，输出: "Hello"

7.map(Function<? super T, ? extends U> mapper):
如果 Optional 中有值，对该值进行转换操作，并返回一个包含转换后值的新 Optional 对象。
示例

Optional<String> optional = Optional.of("Hello");
Optional<Integer> lengthOptional = optional.map(String::length);
System.out.println(lengthOptional.get()); // 输出: 5

8.flatMap(Function<? super T, Optional<U>>mapper):
与 map() 类似，但 flatMap() 传递的函数返回值必须是 Optional 类型，并且 flatMap 不会对嵌套的 Optional 进行包装。
示例

Optional<String> optional = Optional.of("Hello");
Optional<Integer> lengthOptional = optional.flatMap(s -> Optional.of(s.length()));
System.out.println(lengthOptional.get()); // 输出: 5

Optional的常用场景

1.处理可能为 null 的返回值:
当你在处理方法返回值时，如果该值可能为空，使用 Optional 可以显式地处理这种情况，而不是让调用者直接处理 null。

public Optional<String> findNameById(String id) {
    if ("123".equals(id)) {
        return Optional.of("Alice");
    }
    return Optional.empty();
}

Optional<String> nameOptional = findNameById("123");
nameOptional.ifPresent(name -> System.out.println("找到的名字: " + name));

2.防止 null 检查的嵌套代码:
在代码中常见的 null 检查通常会导致嵌套的 if 语句，而使用 Optional 可以将这种检查链简化。

// 不使用 Optional 的代码
if (user != null && user.getAddress() != null) {
    Address address = user.getAddress();
    // 继续操作
}

// 使用 Optional 简化后
Optional.ofNullable(user)
        .map(User::getAddress)
        .ifPresent(address -> {
            // 继续操作
        });

3.流式处理链式调用：
tional 可以与 map()、flatMap() 等方法结合，形成流式处理链，简化代码逻辑。

Optional<User> userOptional = Optional.of(new User("Alice", "New York"));
String city = userOptional.map(User::getAddress)
                          .map(Address::getCity)
                          .orElse("Unknown");
System.out.println(city); // 输出: "New York"

7.新的日期和时间API(java.time)

Java8引入了新的日期和时间API，提供了更好的一致性和更简单的操作。
示例：

// 创建 LocalDate 实例
LocalDate date = LocalDate.now();
System.out.println(date); // 输出当前日期

// 解析字符串为日期
LocalDate parsedDate = LocalDate.parse("2023-08-29");
System.out.println(parsedDate);

// 日期运算
LocalDate nextWeek = date.plus(1, ChronoUnit.WEEKS);
System.out.println(nextWeek);

8.Collectors和Collect

Stream API提供了Collectors类用于汇聚流元素，最常用的colect()方法用于将流中的元素收集到不同的集合中。
示例：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// 使用 Collectors.toList() 收集流元素
List<String> upperNames = names.stream()
                               .map(String::toUpperCase)
                               .collect(Collectors.toList());

System.out.println(upperNames); // 输出: [ALICE, BOB, CHARLIE]

9. 并行数组（Parallel Arrays）

Java8引入了Arrays.parallelSort()方法，允许在多线程中对大型数组进行排序。
示例：

int[] numbers = {5, 3, 8, 1, 9, 7};

// 并行排序
Arrays.parallelSort(numbers);

System.out.println(Arrays.toString(numbers)); // 输出: [1, 3, 5, 7, 8, 9]

10 Base64加密

Java8内置了Base64编码和解码功能，位于java.util.Base64类中。
示例：

String originalInput = "Hello, World!";
String encodedString = Base64.getEncoder().encodeToString(originalInput.getBytes());
System.out.println(encodedString); // 输出: "SGVsbG8sIFdvcmxkIQ=="

byte[] decodedBytes = Base64.getDecoder().decode(encodedString);
String decodedString = new String(decodedBytes);
System.out.println(decodedString); // 输出: "Hello, World!"