掌握Java 8核心特性，看这50个实用应用案例，轻松提升编程技能

Java 8作为Java编程语言的重要版本，引入了许多革命性的新特性，使得开发过程更加高效和优雅。以下将详细介绍Java 8的50个实用应用案例，帮助您快速掌握这些特性，提升编程技能。

一、Lambda表达式

1.1 计算列表中最大值

使用Lambda表达式简化对列表元素的最大值查找。

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        Integer max = numbers.stream().max(Integer::compare).get();
        System.out.println("最大值：" + max);
    }
}

1.2 多条件排序

Lambda表达式实现多条件排序。

List<String> strings = Arrays.asList("Java", "C++", "Python", "Scala");
strings.sort((s1, s2) -> {
    if (s1.length() > s2.length()) {
        return 1;
    } else if (s1.length() < s2.length()) {
        return -1;
    } else {
        return 0;
    }
});
System.out.println(strings);

二、Stream API

2.1 筛选特定元素

Stream API进行列表的筛选。

List<String> strings = Arrays.asList("Apple", "Banana", "Cherry", "Date", "Fig", "Grape");
strings.stream()
    .filter(s -> s.startsWith("B"))
    .forEach(System.out::println);

2.2 计算平均数

使用Stream API计算列表元素的平均数。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
double average = numbers.stream().mapToInt(Integer::intValue).average().orElse(0);
System.out.println("平均数：" + average);

三、函数式接口

3.1 Consumer接口

使用Consumer接口进行操作。

import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
        Consumer<String> printMessage = message -> System.out.println("消息：" + message);
        printMessage.accept("Hello, World!");
    }
}

3.2 Function接口

使用Function接口实现字符串转大写。

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, String> toUpperCase = String::toUpperCase;
        String result = toUpperCase.apply("hello world");
        System.out.println("转换为大写：" + result);
    }
}

四、日期时间API

4.1 解析日期时间

使用DateTimeFormatter解析日期时间。

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

public class Main {
    public static void main(String[] args) {
        LocalDateTime dateTime = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedDate = dateTime.format(formatter);
        System.out.println("当前日期时间：" + formattedDate);
    }
}

4.2 时间计算

计算两个日期之间的天数差。

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class Main {
    public static void main(String[] args) {
        LocalDate date1 = LocalDate.of(2021, 1, 1);
        LocalDate date2 = LocalDate.of(2021, 1, 5);
        long daysBetween = ChronoUnit.DAYS.between(date1, date2);
        System.out.println("两个日期之间的天数差：" + daysBetween);
    }
}

五、CompletableFuture

5.1 异步计算

使用CompletableFuture进行异步计算。

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(2000);
                System.out.println("异步执行任务");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        future.join();
    }
}

5.2 异步请求

使用CompletableFuture模拟异步请求。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                System.out.println("异步请求执行完毕");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        future.join();
    }
}

六、Optional类

6.1 处理null值

使用Optional处理可能的null值。

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> name = Optional.ofNullable(null);
        name.ifPresent(namePresent -> System.out.println("名字：" + namePresent));
    }
}

6.2 安全地访问属性

使用Optional安全地访问对象属性。

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional.of(new User("John", null)).ifPresent(user -> {
            System.out.println("用户名：" + user.getUsername());
        });
    }

    static class User {
        private String username;
        private String password;

        public User(String username, String password) {
            this.username = username;
            this.password = password;
        }

        public String getUsername() {
            return username;
        }
    }
}

七、Stream的收集器

7.1 收集元素到列表

使用Collectors.toList()将元素收集到列表。

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

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> evenNumbers = numbers.stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());
        System.out.println(evenNumbers);
    }
}

7.2 计算平均值

使用Collectors.averagingInt()计算平均值。

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

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        double average = numbers.stream()
                .collect(Collectors.averagingInt(Integer::intValue));
        System.out.println("平均值：" + average);
    }
}

八、Map和FlatMap

8.1 展开Map中的值

使用Map的值展开。

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

public class Main {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("John", "Jane", "Alice");
        Map<String, Integer> nameCountMap = names.stream()
                .collect(Collectors.toMap(String::toUpperCase, name -> 1, (v1, v2) -> v1 + v2));
        System.out.println(nameCountMap);
    }
}

8.2 展开扁平化的流

使用FlatMap处理嵌套的流。

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

public class Main {
    public static void main(String[] args) {
        List<List<String>> list = Arrays.asList(Arrays.asList("1"), Arrays.asList("2"), Arrays.asList("3", "4", "5"));
        List<String> flattenedList = list.stream()
                .flatMap(List::stream)
                .collect(Collectors.toList());
        System.out.println(flattenedList);
    }
}

九、Java 8的新特性

9.1 优化后的接口

使用Optional等接口优化代码结构。

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> name = Optional.ofNullable(null);
        name.ifPresent(namePresent -> System.out.println("名字：" + namePresent));
    }
}

9.2 Stream API的使用

使用Stream API提高代码的可读性和可维护性。

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

public class Main {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("John", "Jane", "Alice");
        List<String> uppercaseNames = names.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println(uppercaseNames);
    }
}

通过以上50个Java 8实用应用案例，您可以轻松掌握Java 8的核心特性，提高编程技能。不断实践和学习，相信您将能创作出更加优雅、高效的Java程序。