Java 8 引入了许多新的特性和改进，显著增强了其函数式编程能力。函数式编程是一种编程范式，强调使用纯函数（没有副作用的函数）和不可变数据结构来构建程序。以下是 Java 中增强函数式编程能力的主要方面：

1. Lambda 表达式

Lambda 表达式允许你编写匿名函数，这些函数可以被当作对象传递。它们通常用于实现函数式接口。

基本语法

(parameters) -> expression

或者

(parameters) -> { statements; }

示例

// 使用 Lambda 表达式创建一个 Runnable 对象
Runnable runnable = () -> System.out.println("Hello, World!");
runnable.run(); // 输出: Hello, World!

// 使用 Lambda 表达式创建一个 Consumer 对象
Consumer<String> consumer = (name) -> System.out.println("Hello, " + name);
consumer.accept("Alice"); // 输出: Hello, Alice

// 使用 Lambda 表达式创建一个 BiFunction 对象
BiFunction<Integer, Integer, Integer> adder = (a, b) -> a + b;
int result = adder.apply(5, 3);
System.out.println(result); // 输出: 8

2. 方法引用

方法引用是 Lambda 表达式的一种特殊形式，用于直接引用已经存在的方法。方法引用使得代码更加简洁和易读。

基本语法

ClassName::staticMethodName
instanceReference::methodName
ClassName::methodName
ClassName::new

示例

// 静态方法引用
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(System.out::println); // 输出每个名字

// 实例方法引用
String prefix = "Hello, ";
Consumer<String> greeter = prefix::concat;
System.out.println(greeter.accept("Alice")); // 输出: Hello, Alice

// 特定类型的任意对象的实例方法引用
List<String> uppercasedNames = names.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());

// 构造方法引用
Supplier<List<String>> listFactory = ArrayList::new;
List<String> newList = listFactory.get();

3. 函数式接口

函数式接口是指只包含一个抽象方法的接口。Java 提供了许多内置的函数式接口，位于 java.util.function 包中。

常用函数式接口

• FunctionalInterface 注解：

• 用于标识该接口是一个函数式接口。

• 常用函数式接口：

• Consumer<T>：接受一个参数，不返回结果。

  Consumer<String> printName = name -> System.out.println(name);
  

• Supplier<T>：不接受参数，返回一个结果。

  Supplier<String> supplyGreeting = () -> "Hello, World!";
  

• Function<T, R>：接受一个参数，返回一个结果。

  Function<String, Integer> stringLength = str -> str.length();
  

• Predicate<T>：接受一个参数，返回一个布尔值。

  Predicate<Integer> isEven = num -> num % 2 == 0;
  

• BiFunction<T, U, R>：接受两个参数，返回一个结果。

  BiFunction<Integer, Integer, Integer> adder = (a, b) -> a + b;
  

• UnaryOperator<T>：特殊的 Function<T, T>，接受一个参数并返回相同类型的参数。

  UnaryOperator<Integer> square = x -> x * x;
  

• BinaryOperator<T>：特殊的 BiFunction<T, T, T>，接受两个相同类型的参数并返回相同类型的参数。

  BinaryOperator<Integer> multiply = (a, b) -> a * b;
  

4. Stream API

Stream API 提供了一种高效且易于使用的处理数据的方式。它支持通过管道（pipeline）对集合进行操作，如过滤、映射、排序等。

示例

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

publicclass StreamExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        List<String> filteredNames = names.stream()
            .filter(name -> name.length() > 5) // 使用 Lambda 表达式进行过滤
            .map(String::toUpperCase)         // 使用方法引用进行转换
            .collect(Collectors.toList());

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

5. Optional 类

Optional 类用于表示一个值可能存在也可能不存在的情况，避免空指针异常。

示例

import java.util.Optional;

publicclass OptionalExample {
    public static void main(String[] args) {
        Optional<String> optionalName = Optional.ofNullable(getName());

        String name = optionalName.orElse("Default Name");
        System.out.println(name); // 输出: Default Name 如果 getName() 返回 null
    }

    public static String getName() {
        returnnull; // 模拟获取名称的方法
    }
}

6. 默认方法和静态方法

Java 8 引入了默认方法（default methods）和静态方法（static methods），允许在接口中提供方法的具体实现。

默认方法

默认方法使用 default 关键字定义。

interface MyInterface {
    default void sayHello() {
        System.out.println("Hello from interface!");
    }
}

class MyClass implements MyInterface {}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.sayHello(); // 输出: Hello from interface!
    }
}

静态方法

静态方法使用 static 关键字定义。

interface MyInterface {
    static void sayStaticHello() {
        System.out.println("Static hello from interface!");
    }
}

public class Main {
    public static void main(String[] args) {
        MyInterface.sayStaticHello(); // 输出: Static hello from interface!
    }
}

7. 新日期时间 API

Java 8 引入了新的日期和时间 API，位于 java.time 包中，提供了更强大和易用的日期和时间处理功能。

示例

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

publicclass DateTimeExample {
    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);
    }
}

总结

Java 8 通过引入以下特性显著增强了其函数式编程能力：

1. Lambda 表达式：允许编写匿名函数。
2. 方法引用：简化对现有方法的引用。
3. 函数式接口：定义单个抽象方法的接口。
4. Stream API：提供高效的集合操作方式。
5. Optional 类：避免空指针异常。
6. 默认方法和静态方法：增强接口的功能。
7. 新日期时间 API：提供强大的日期和时间处理功能。

这些新特性不仅提高了代码的可读性和简洁性，还增强了程序的健壮性和性能

/// ***你们的关注是我一直写作的动力
System.out.println("请关注我的微信公众号：");
System.out.println("Java知识日历");