Java8 - Stream和Optional超详解

方法	说明	示例
stream()	集合创建顺序流	list.stream()
Stream.of()	由一组元素创建流；还有IntStream、LongStream、DoubleStream	Stream.of(1, 2, 3) IntStream.of(1, 2, 3)
Stream.iterate()	创建无限流；	Stream.iterate(0, n -> n+2).limit(5)
Stream.generate()	创建无限流	Stream.generate(Math::random).limit(5)
parallelStream()	创建并行流	list.parallelStream()
Arrays.stream()	数组生成流	Arrays.stream(arr)

（2）示例代码

    public static void main(String[] args) {
        List<Integer> list = Stream.of(1, 2, 3).toList();
        List<Integer> list1 = Stream.iterate(0, n -> n + 2).limit(5).toList();
        List<Double> list2 = Stream.generate(Math::random).limit(5).toList();
        int[] array = IntStream.of(1, 2, 3).toArray();
        List<Integer> list3 = Arrays.asList(1, 2, 3).parallelStream().toList();
        List<String> list4 = Arrays.stream(new String[]{"1", "2", "3"}).toList();
        System.out.println(list);
        System.out.println(list1);
        System.out.println(list2);
        System.out.println(list3);
        System.out.println(list4);
        System.out.println(array.length);
    }

2、中间操作

（1）过滤与切片API

方法	作用	示例
filter()	过滤满足条件的元素	`stream.filter(s -> s.length() > 3)`
distinct()	去重（基于`equals()`）	`stream.distinct()`
linit(long maxSize)	截断流，保留前`maxSize`个数据	`stream.limit(5)`
skip(long n)	跳过前`n`个元素	`stream.skip(2)`

示例代码

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female"),
            new User(2L, "Bob", 30, "Male"),
            new User(3L, "Charlie", 25, "Male"),
            new User(4L, "David", 35, "Female"),
            new User(4L, "David", 35, "Female")
        );

        List<User> female = users.stream().filter(user -> user.getGender().equals("Female")).toList();
        List<User> male = users.stream().distinct().toList();
        List<User> list = users.stream().limit(2).toList();
        List<User> list1 = users.stream().skip(3).toList();

        System.out.println(female);
        System.out.println(male);
        System.out.println(list);
        System.out.println(list1);
    }

（2）映射

方法作用示例

map() 元素一对一转换 stream.map(String::length)

flatMap()

扁平化映射，将嵌套流合并

方法	作用	示例
map()	元素一对一转换	`stream.map(String::length)`
flatMap()	扁平化映射，将嵌套流合并	`stream.flatMap(List::stream)` （合并`List<List<String>>`为`List<String>`）
mapToInt()	转为`IntStream`（基本类型流，优化性能）	`stream.mapToInt(User::getAge)`

stream.flatMap(List::stream)

（合并List<List<String>>为List<String>）

mapToInt() 转为IntStream（基本类型流，优化性能） stream.mapToInt(User::getAge)

代码示例

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        List<Long> list = users.stream().map(User::getId).toList();
        List<String> list1 = users.stream().flatMap(item -> item.getFriendName().stream()).toList();
        int[] array = users.stream().mapToInt(User::getAge).toArray();

        System.out.println(list);
        System.out.println(list1);
        System.out.println(Arrays.toString(array));
    }

（3）排序

方法	作用	示例
sorted()	自然排序（元素需实现`Comparable`）	`stream.sorted()`
sorted(Comparator<T>)	自定义排序	`stream.sorted(Comparator.comparing(User::getAge).reversed())`

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        List<String> list = users.stream().map(User::getName).sorted().toList();
        // 升序
        List<User> list1 = users.stream().sorted(Comparator.comparing(User::getAge)).toList();
        // 降序
        List<User> list2 = users.stream().sorted(Comparator.comparing(User::getAge).reversed()).toList();

        System.out.println(list);
        System.out.println(list1);
        System.out.println(list2);
    }

（4）其他

方法	作用	示例
peek(Consumer<T>)	对元素执行操作，返回新流（调试用）	`stream.peek(System.out::println)`
takeWhile(Predicate<T>)	从开头取满足条件的元素（JDK 9+）	`stream.takeWhile(n -> n < 10)`
dropWhile(Predicate<t>)	从开头丢弃满足条件的元素（JDK 9+）	`stream.dropWhile(n -> n < 5)`

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        List<String> list = users.stream().peek(System.out::println).map(User::getName).toList();
    }

3、终止操作

（1）查找与匹配

方法	作用	返回值	示例
allMatch(Predicate<T>)	所有元素匹配	`boolean`	`stream.allMatch(u ->` `u.getAge() > 18)`
anyMatch(Predicate<T>)	任意元素匹配	`boolean`	`stream.anyMatch(u ->` `u.getName().equals("Alice"))`
noneMatch(Predicate<T>)	所有元素不匹配	`boolean`	`stream.noneMatch(u ->` `u.getAge() > 60)`
findFirst()	返回第一个元素	`Optional<T>`	`stream.findFirst()`
findAny()	返回任意元素（并行流更高效）	`Optional<T>`	`stream.findAny()`

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        boolean b = users.stream().allMatch(user -> user.getAge() > 30);
        boolean b1 = users.stream().anyMatch(user -> user.getAge() > 30);
        boolean b2 = users.stream().noneMatch(user -> user.getAge() > 30);
        User user = users.stream().findFirst().get();
        User user1 = users.stream().findAny().get();

        System.out.println(b);
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(user);
        System.out.println(user1);
    }

（2）归约与聚合

方法	作用	示例
count()	统计元素个数	`long count = stream.count()`
min(Comparator<T>)	最小值	`Optional<T> min = stream.min(Comparator.naturalOrder())`
max(Comparator<T>)	最大值	`Optional<T> max = stream.max(Comparator.naturalOrder())`
reduce(T identity, BinaryOperator<T>)	归约（初始值 + 累加器）	`int sum = stream.reduce(0, Integer::sum)`
reduce(BinaryOperator<T>)	归约（无初始值，返回`Optional`）	`Optional<Integer> sum = stream.reduce(Integer::sum)`

   public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        long count = users.stream().count();
        User min = users.stream().min(Comparator.comparing(User::getAge)).get();
        User max = users.stream().max(Comparator.comparing(User::getAge)).get();
        int sum = users.stream().map(User::getAge).reduce(0, Integer::sum);
        Integer i = users.stream().map(User::getAge).reduce(Integer::sum).get();

        System.out.println(count);
        System.out.println(min);
        System.out.println(max);
        System.out.println(sum);
        System.out.println(i);
    }

（3）遍历与转换

方法	作用	示例
forEach(Consumer<T>)	遍历元素（并行流无序）	`stream.forEach(System.out::println)`
forEachOrdered(Consumer<T>)	有序遍历（并行流保证顺序）	`stream.forEachOrdered(System.out::println)`
toArray()	转为数组	`User[] users = stream.toArray(User[]::new)`

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        users.stream().forEach(System.out::println);
        System.out.println("===========================");
        users.stream().forEachOrdered(System.out::println);
        System.out.println("===========================");
        User[] users1 = users.stream().toArray(User[]::new);
        System.out.println(Arrays.toString(users1));
    }

（4）收集（核心：collect）

collect(Collector<? super T, A, R> collector)是最常用终端操作，通过Collectors工具类实现复杂收集

收集器	作用	示例
toList()	收集为`List`	`List<User> list = stream.collect(Collectors.toList())`
toSet()	收集为`Set`（去重）	`Set<User> set = stream.collect(Collectors.toSet())`
toMap(Function, Function)	收集为`Map`（键值映射）	`Map<Long, User> map = stream.collect(Collectors.toMap(User::getId, Function.identity()))`
joining()	拼接字符串	`String str = stream.collect(Collectors.joining(","))`
groupingBy(Function)	分组（按属性分组为`Map<K, List<T>>`）	`Map<Integer, List<User>> groupByAge = stream.collect(Collectors.groupingBy(User::getAge))`
partitioningBy(Predicate)	分区（按布尔条件分为两组）	`Map<Boolean, List<User>> partition = stream.collect(Collectors.partitioningBy(u -> u.getAge() > 18))`
summarizingInt(ToIntFunction)	统计（总和、平均值、最大 / 最小值、数量）	`IntSummaryStatistics stats = stream.collect(Collectors.summarizingInt(User::getAge))`
collectingAndThen(Collector, Function)	收集后再处理	`List<User> unmodifiableList = stream.collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList))`
counting()	计数	stream.collect(Collectors.counting())
averagingInt()	平均值	stream.collect(Collectors.averagingInt(x -> x))
maxBy()	最大值	stream.collect(Collectors.maxBy(Comparator.naturalOrder()))
minBy()	最小值	stream.collect(Collectors.minBy(Comparator.naturalOrder()))

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        List<String> list = users.stream().map(User::getName).collect(Collectors.toList());
        Set<String> collect = users.stream().map(User::getName).collect(Collectors.toSet());
        Map<String, User> map = users.stream().collect(Collectors.toMap(User::getName, Function.identity()));
        String collect1 = users.stream().map(User::getName).collect(Collectors.joining(","));
        Map<Long, List<User>> collect2 = users.stream().collect(Collectors.groupingBy(User::getId));
        Map<Boolean, List<User>> collect3 = users.stream().collect(Collectors.partitioningBy(item -> item.getAge() > 30));
        IntSummaryStatistics collect4 = users.stream().collect(Collectors.summarizingInt(User::getAge));
        List<User> collect5 = users.stream().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
        Long collect6 = users.stream().collect(Collectors.counting());
        Double collect7 = users.stream().collect(Collectors.averagingDouble(User::getAge));
        User user = users.stream().collect(Collectors.maxBy(Comparator.comparing(User::getAge))).get();
        User user1 = users.stream().collect(Collectors.minBy(Comparator.comparing(User::getAge))).get();

        System.out.println(list);
        System.out.println(collect);
        System.out.println(map);
        System.out.println(collect1);
        System.out.println(collect2);
        System.out.println(collect3);
        System.out.println(collect4.getMax() + "===" + collect4.getMin());
        System.out.println(collect5);
        System.out.println(collect6);
        System.out.println(collect7);
        System.out.println(user);
        System.out.println(user1);
    }

4、核心技巧

（1）收集与转换

1）转换为 Map

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        // value 相加
        Map<String, Integer> map = users.stream()
            .collect(Collectors.toMap(
                User::getGender,
                User::getAge,
                Integer::sum // 合并函数
            ));

        System.out.println(map);
    }

2）收集为不可变集合

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        List<User> unmodifiableList = users.stream()
            .collect(Collectors.collectingAndThen(
                Collectors.toList(),
                Collections::unmodifiableList
            ));

        unmodifiableList.add(new User(5L, "Eve", 28, "Female", Arrays.asList("lisi5", "wangwu5", "zhaoliu5")));
    }

3）多字段分组

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        Map<String, Map<Integer, List<User>>> group = users.stream()
            .collect(Collectors.groupingBy(
                User::getGender,
                Collectors.groupingBy(User::getAge)
            ));
        System.out.println(group);
    }

（2）排序

1）单字段排序

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        List<User> collect = users.stream()
            .sorted(Comparator.comparing(User::getAge))
            .collect(Collectors.toList());
        System.out.println(collect);
    }

2）多字段排序

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        List<User> collect = users.stream()
            .sorted(Comparator.comparing(User::getAge).thenComparing(User::getName))
            .collect(Collectors.toList());

3）逆序排序

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        List<User> collect = users.stream()
            .sorted(Comparator.comparing(User::getAge).reversed())
            .collect(Collectors.toList());
        System.out.println(collect);
    }

（3）其他

1）找出重复元素


    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        Set<User> seen = new HashSet<>();
        Set<User> duplicates = users.stream()
            .filter(n -> !seen.add(n))
            .collect(Collectors.toSet());
        System.out.println(duplicates);
    }

2）分页功能

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        int page = 2, size = 2;
        List<User> pageList = users.stream()
            .skip((page - 1) * size)
            .limit(size)
            .collect(Collectors.toList());
        System.out.println(pageList);
    }

3）按条件统计数量

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        long count = users.stream().filter(x -> x.getAge() > 30).count();
        System.out.println(count);

    }

4）合并两个 List 并去重

List<Integer> merged = Stream.concat(list1.stream(), list2.stream())
    .distinct()
    .collect(Collectors.toList());

5）分组后对分组内元素做映射

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        Map<String, List<String>> g = users.stream()
            .collect(Collectors.groupingBy(
                User::getGender,
                Collectors.mapping(User::getName, Collectors.toList())
            ));
        System.out.println(g);
    }

二、Optional相关API详解

1、创建 Optional 对象

函数	说明
Optional.of(T value)	创建包含非空值的 Optional 对象。如果传入的是 null，则抛出 NullPointerException
Optional.ofNullable(T value)	创建一个可能为空的 Optional 对象。允许传入 null
Optional.empty()	创建一个空的 Optional 对象

   public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        Optional<List<User>> users1 = Optional.ofNullable(users);
        System.out.println(users1);

        Optional<Object> empty = Optional.empty();
        System.out.println(empty);

        Optional<Object> o = Optional.of(null);
        System.out.println(o);
    }

2、检查 Optional 内容

函数	说明
boolean isPresent()	判断Optional对象是否包含非空值，如果存在返回 true，否则返回 false
void ifPresent()	如果Optional非空值，则执行后续操作
void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction)	如果有值，则执行给定动作，否则执行给定的空动作。（在 JDK 9 引入）
boolean isEmpty()	创建一个可能为空的 Optional 对象。允许传入 null（此方法在 JDK 11 引入）

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        Optional<List<User>> users1 = Optional.ofNullable(users);

        boolean present = users1.isPresent();
        System.out.println(present);

        Optional<Object> empty = Optional.empty();
        boolean emptyPresent = empty.isPresent();
        System.out.println(emptyPresent);

        users1.ifPresent(System.out::println);
        System.out.println("----------------------");
        empty.ifPresent(System.out::println);
    }

3、获取 Optional 值

函数	说明
T get()	如果值存在，则返回该值，否则抛出 NoSuchElementException
T orElse(T other)	如果值存在，则返回该值，否则返回默认值
T orElseGet(Supplier<? extends T> supplier)	如果值存在，则返回该值，否则通过提供者函数生成并返回一个默认值
T orElseThrow()	如果有值则返回，否则抛出异常（在 JDK 10 引入）
<X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)	如果有值则返回，否则抛出由提供者生成的异常

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        Optional<List<User>> users1 = Optional.ofNullable(users);
        Optional<User> empty = Optional.empty();

        List<User> users2 = users1.get();
        System.out.println(users2);
        System.out.println("----------------------");
        User users3 = empty.orElse(new User());
        System.out.println(users3);

        User user = empty.orElseGet(() ->new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")));
        System.out.println(user);

        User user1 = empty.orElseThrow(() -> new IllegalArgumentException("用户不存在"));
        System.out.println(user1);

        Object o = empty.get();
        System.out.println(o);

    }

4、操作 Optional 值

函数	说明
<U> Optional<U> map(Function<? super T, ? extends U> mapper)	如果有值，则对其应用映射函数并返回新的 Optional，否则返回空 Optional
<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper)	类似于 map，但要求映射函数本身返回一个 Optional
Optional<T> filter(Predicate<? super T> predicate)	如果有值并且满足给定谓词，则返回包含该值的 Optional，否则返回空 Optional

    public static void main(String[] args) {
        // 模拟用户数据
        List<User> users = Arrays.asList(
            new User(1L, "Alice", 25, "Female", Arrays.asList("lisi", "wangwu", "zhaoliu")),
            new User(2L, "Bob", 30, "Male", Arrays.asList("lisi2", "wangwu2", "zhaoliu2")),
            new User(3L, "Charlie", 25, "Male", Arrays.asList("lisi3", "wangwu3", "zhaoliu3")),
            new User(4L, "David", 35, "Female", Arrays.asList("lisi4", "wangwu4", "zhaoliu4"))
        );

        Optional<List<User>> users1 = Optional.ofNullable(users);
        Optional<User> empty = Optional.empty();

        Optional<User> user = users1.map(item -> item.get(0));
        System.out.println(user);
        Optional<String> s = empty.map(User::getName);
        System.out.println(s);

        Optional<String> optionalUser = Optional.ofNullable(users.get(0)).filter(o->o.getName().equals("java")).map(User::getName);
        if(optionalUser.isPresent()){
            System.out.println(optionalUser.get());// 输出 java
        }else{
            System.out.println("Optiaon为空");
        }

    }

5、其他实用方法

函数	说明
Optional<T> or(Supplier<? extends Optional<? extends T>> supplier)	如果一个Optional包含值,则返回自己，否则返回由参数supplier获得的Optional，java11以上
Stream<T> stream()	将Optional转为一个Stream,如果Optional中包含值，那么就返回这个值的Stream,否则就返回一个空的Stream(Stream.empty())

    public static void main(String[] args) {
        User user = null;
        Optional<User> optionalUser = Optional.ofNullable(user).or(() -> {
            User user1 = new User();
            user1.setName("java");
            return Optional.of(user1);
        });
        if (optionalUser.isPresent()) {
            System.out.println(optionalUser.get().getName()); //输出 java
        } else {
            System.out.println("为空");
        }

        Stream<User> userStream = Optional.ofNullable(user).stream().filter(u->u.getName().equals("java"));
    }

https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

3分钟掌握Codex技能安装：一键部署你的AI助手工具库

想要为你的Codex AI助手安装新技能？不用再手动复制文件了！skill-installer为你提供了一套完整的解决方案，让你能够从GitHub仓库快速获取和安装各种实用的Codex技能。无论你是AI开发新手还是经验丰富的开发者，这个工具都能让你在几分钟内扩展Codex的功能边界。## 为什么选择skill-installer？ 🤔在AI辅助编程的时代，Codex技能已经成为提升开发效

AI编程社区

DB-GPT分布式AI数据引擎：企业级智能分析平台架构解析

DB-GPT作为新一代AI数据助手，通过分布式架构和智能代理引擎重构了传统数据分析范式。该平台将大型语言模型的自然语言理解能力与企业级数据处理需求深度融合，构建了面向生产环境的可扩展AI数据平台。其核心价值在于将复杂的SQL生成、数据分析和可视化任务转化为简单的自然语言交互，同时确保系统安全性、可追溯性和企业级可靠性。## 技术定位与生态分析在当前数据智能生态中，DB-GPT填补了传统BI

AI编程社区

如何用Awesome Claude Skills将AI助手打造成你的全能创作伙伴和职业顾问

你是否曾想过，如果有一个AI伙伴能帮你完成从专业文章撰写到完美简历定制的所有工作，工作效率会提升多少倍？Awesome Claude Skills正是这样一个神奇的AI技能宝库，它汇集了1000+个精心筛选的Claude技能，覆盖内容创作、职业发展、文档处理等各个方面，让你在AI的帮助下轻松应对各种工作挑战。## 痛点分析：传统工作流程的三大瓶颈在内容创作和职业发展中，我们常常面临这样的困