Java 8 是一次重大的发行版更新，引入了大量新特性和改进，以下是 Java 8 的主要特性：

1.Lambda 表达式

Lambda 允许在代码中直接定义匿名函数，简化了对函数式编程的支持。

1
2
3
4
5
6

// Lambda 表达式示例
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
nums.stream()
    .filter(num -> num % 2 == 0) // 过滤偶数
    .map(num -> num * 2) // 将每个元素乘以 2
    .forEach(System.out::println); // 打印结果
2.Stream API

通过 Stream API 可以轻松处理集合和数组等数据结构，提高了代码的可读性和可维护性。以下是Stream API中常用的方法：

  • filter(Predicate predicate)：过滤出所有符合条件的元素。

  • map(Function function)：将元素转换为另一种类型。

  • flatMap(Function function)：将嵌套的多个流扁平化成一个流。

  • distinct()：去除重复元素。

  • sorted()：排序。

  • boxed：将基本数据类型转换为对应的包装类类型。

  • peek(Consumer action)：对每个元素执行指定的操作。

  • limit(long maxSize)：限制元素数量。

  • skip(long n)：跳过前 n 个元素。

  • forEach(Consumer action)：对每个元素执行指定的操作。

  • count()：计数。

  • reduce(BinaryOperator accumulator)：将所有元素归约成一个结果。

  • collect(Collector collector)：收集结果到一个集合中。

  • allMatch(Predicate predicate)：判断是否所有元素都符合给定条件。

  • anyMatch(Predicate predicate)：判断是否任何一个元素符合给定条件。

  • noneMatch(Predicate predicate)：判断是否没有任何元素符合给定条件。

  • findFirst()：返回第一个元素。

  • findAny()：返回任意一个元素。

  • 这些操作可以通过链式调用的方式进行组合，形成一个完整的流处理链。如下是一个简单的例子：

    1
2
3
4
5
6
7
8

    List<String> list = Arrays.asList("apple", "banana", "orange", "peach");
​
long count = list.stream()  // 将 List 转换为 Stream
                 .filter(str -> str.startsWith("a"))  // 过滤出以 a 开头的字符串
                 .map(String::toUpperCase)  // 转换为大写
                 .count();  // 统计数量
​
System.out.println(count);  // 输出结果：1
3.Date/Time API

在 Java 8 中引入了全新的日期时间处理类库，使得处理日期时间变得更加方便和易于理解。以下是 java.time 包中最重要的一些类：

  • LocalDate：表示日期，如 2022 年 5 月 15 日。

  • LocalTime：表示时间，如 13:45:30。

  • LocalDateTime：代表日期和时间，比如 2022 年 5 月 15 日 13:45:30。

  • ZonedDateTime：代表带有时区的日期时间，在上述所有日期时间类型的基础上，还提供了时区信息。

  • Duration：在两个时间点之间表示时间量。

  • Period：在两个日期之间表示天、周、月或年的数量。

  • DateTimeFormatter：可以将日期时间对象按照指定的格式进行格式化或者解析。

  • 以下是使用 Java 8 新的日期时间 API 的一些示例代码：

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

    // 创建 LocalDate 对象,表示当前日期
LocalDate localDate = LocalDate.now();
​
// 创建 LocalTime 对象,表示下午 2:30 这个时间点
LocalTime localTime = LocalTime.of(14, 30, 0);
​
// 创建 LocalDateTime 对象,表示 2022 年 6 月 1 日上午 12:30 这个日期时间。
LocalDateTime localDateTime = LocalDateTime.of(2022, Month.JUNE, 1, 12, 30);
​
// 在当前日期时间上加上一小时
localDateTime = localDateTime.plusHours(1L);
​
// 创建 Duration 对象，并计算两个时间点之间的时间量
Duration duration = Duration.between(localTime, LocalTime.now());
​
// 使用 DateTimeFormatter 对象对日期时间进行格式化
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formattedDateTime = localDateTime.format(dateTimeFormatter);
4.接口中的默认方法：

允许在接口中添加默认方法的实现，大大提高了接口的灵活性和扩展性。需要注意的是，这些接口默认方法并不是强制实现的，也可以被继承类或实现类所覆盖和重写。但在没有其他需求时，通过使用默认方法，可以大幅简化代码，并保证 API 的向后兼容性。如下Collection 接口中新增的 stream()、parallelStream() 和 removeIf() 等默认方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

public interface Collection<E> extends Iterable<E> {
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
    default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        final Iterator<E> each = iterator();
        while (each.hasNext()) {
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }
}
5.函数式接口

函数式接口非常适合用于Lambda表达式和方法引用，因为它们可以将这些功能作为参数传递给方法或返回值，从而使代码更简洁、更具可读性。许多Java内置的函数式接口都在java.util.function包中定义，其中几个常用的接口如下：

  • Function<T, R>:接受一个参数并产生结果的函数。

    1
2
3
4

    // 接收一个字符串类型参数并返回对应整数长度值
Function<String, Integer> stringToLength = str -> str.length();
System.out.println(stringToLength.apply("Hello World!"));
// 输出结果：12

  • Predicate<T>: 接受一个参数并返回一个布尔值，表示断言函数。

    1
2
3
4

    // 判断一个数字是否是奇数
Predicate<Integer> isOdd = number -> number % 2 != 0;
System.out.println(isOdd.test(5));
// 输出结果：true

  • Consumer<T>:接受一个参数不返回结果，表示消费者函数。

    1
2
3
4

    // 输出一个字符串的大写形式
Consumer<String> printStringInUpperCase = str -> System.out.println(str.toUpperCase());
printStringInUpperCase.accept("hello world!");
// 输出结果：HELLO WORLD!

  • Supplier<T>:提供一个无参构造函数，返回任意类型结果。

    1
2
3
4

    // 产生随机数
Supplier<Integer> randomIntegerSupplier = () -> (int) (Math.random() * 100);
System.out.println(randomIntegerSupplier.get());
// 输出结果：一个0~99之间的随机整数
6.方法引用(::)

Java 8中的方法引用是一种简化Lambda表达式的方式，它允许我们直接引用已存在的 Java 类或对象的方法，而不需要通过 Lambda 表达式再去定义一个新的函数式接口实现。可以用两个冒号（::）来表示方法引用，其中左边是对象或类名，右边是方法名，语法如下：

  • 静态方法引用

    ClassName::staticMethodName

  • 实例方法引用

    objectReference::instanceMethodName

  • 对象超类方法引用

    SuperClassName::instanceMethodName

  • 构造函数引用

    ClassName::new

7.Optional 容器类型

Optional 类型是一种容器类型，表示一个值可能为空的情况，可以帮助我们避免 NullPointerException 异常,同时也可以让代码更加简洁明了。Optional 接口定义了一组方法，用于检测是否有值，获取值，处理值等操作。以下是一些常用方法：

  • of() 方法：创建一个包含指定非空值的 Optional 对象。

    1

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

  • ofNullable() 方法：创建一个可能包含 null 值的 Optional 对象。

    1

    Optional<String> optional = Optional.ofNullable(null);

  • isPresent() 方法：判断 Optional 中是否存在值。返回ture表示存在值 返回false表示为null

    1
2
3
4

    Optional<String> optional = Optional.ofNullable("Hello");
if (optional.isPresent()) {
    System.out.println("Value is " + optional.get());
}

  • get() 方法：如果 Optional 的值存在则返回该值，否则抛出 NoSuchElementException 异常。

    1
2

    Optional<String> optional = Optional.ofNullable("Hello");
String value = optional.get();

  • orElse() 方法：如果值存在则返回该值，否则返回参数中指定的默认值。

    1
2
3

    String defaultValue = "World";
Optional<String> optional = Optional.empty();
String value = optional.orElse(defaultValue); // value = "World"

  • orElseGet() 方法：如果值存在则返回该值，否则运行参数中的 Supplier 函数，并返回该函数的结果。

    1
2
3

    Supplier<String> supplier = () -> "World";
Optional<String> optional = Optional.empty();
String value = optional.orElseGet(supplier); // value = "World"

  • map() 方法：如果值存在则使用该值执行提供的 Function 函数，并返回包含其返回值的 Optional 对象；否则返回一个空的 Optional 对象。

    1
2
3

    Function<String, String> function = (s) -> s + " World!";
Optional<String> optional = Optional.of("Hello");
Optional<String> result = optional.map(function); // result = Optional[Hello World!]

  • filter() 方法：如果值存在并且满足指定的 Predicate 条件，则返回包含该值的 Optional 对象；否则返回一个空的 Optional 对象。

    1
2
3

    Predicate<String> predicate = (s) -> s.contains("l");
Optional<String> optional = Optional.of("Hello");
Optional<String> result = optional.filter(predicate); // result = Optional[Hello]
8.Parallel Streams

Java 8 中引入了并行流（Parallel Streams）的功能，能够有效地利用多核处理器处理大量数据集合。

并行流与普通流 API 几乎相同，但它会将操作分解成几个小块，在不同的 CPU 上进行处理，并最后将结果合并起来。因此，并行流可以显著提高大型数据集合的处理速度。下面是一个简单的例子。

假设我们需要对一个包含 1000 万个随机数的数组进行排序，然后筛选出其中所有能被 3 整除的元素。这个任务很复杂，因此可以考虑采用并行流来优化代码性能：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

//创建一个包含1000万个随机数的数组
int[] arr = new int[10000000];
Random random = new Random();
for (int i = 0; i < arr.length; i++) {
    arr[i] = random.nextInt(100);
}
​
// 串行方式
long start1 = System.currentTimeMillis();
List<Integer> list1 = Arrays.stream(arr).sorted().filter(n -> n % 3 == 0).boxed().collect(Collectors.toList());
long end1 = System.currentTimeMillis();
System.out.println("Serial time: " + (end1 - start1) + "ms");
​
// 并行方式
long start2 = System.currentTimeMillis();
List<Integer> list2 = Arrays.stream(arr).parallel().sorted().filter(n -> n % 3 == 0).boxed().collect(Collectors.toList());
long end2 = System.currentTimeMillis();
System.out.println("Parallel time: " + (end2 - start2) + "ms");

以上代码通过随机数生成器创建了一个包含 1000 万个随机数的数组，并参照条件对数组进行了排序和筛选过滤。

其中通过串行流（Stream）和并行流（Parallel Stream）两种方式，分别实现了对数据的操作，并在控制台输出操作所消耗的时间。

可以看出，在数据规模比较大时，使用并行流会更能发挥多核 CPU 的优势，减少整个操作过程的耗时。