Java 8 - java.util.stream - Stream接口

川长思鸟来 2024-03-22 18:42 20阅读 0赞

### Stream接口：Stream是流式处理的核心接口，定义了对数据进行流式操作的方法。它提供了许多中间操作和终端操作，用于处理、转换和聚合数据流。 ###

确切地说，Stream接口定义了对数据进行流式操作的方法，并提供了中间操作和终端操作，用于处理、转换和聚合数据流。

以下是Stream接口中一些常用的方法：

**中间操作方法：**

#### filter(Predicate<? super T> predicate)：根据指定的条件筛选元素。 ####

package com.lfsun.java8study.mystream;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.function.Predicate;
    import java.util.stream.Collectors;
    
    /**
     * 创建了一个整数列表numbers，然后定义了一个evenPredicate，它是一个Predicate，用于判断一个整数是否为偶数。
     * 接下来，我们使用自定义的filter方法来筛选出列表中的偶数。最后，我们打印筛选后的结果。
     *
     * 请注意，filter方法是一个通用的方法，可以用于筛选任何类型的列表。
     * 在方法内部，我们使用了Predicate的test方法来判断列表中的元素是否满足给定的条件。
     * 如果满足条件，就将元素添加到filteredList中。最后，我们返回筛选后的列表。
     */
    public class MyFilterExample {
        
        public static void main(String[] args) {
        
            // 创建一个包含整数的列表
            List<Integer> numbers = new ArrayList<>();
            numbers.add(1);
            numbers.add(2);
            numbers.add(3);
            numbers.add(4);
            numbers.add(5);
    
            // 创建一个Predicate来筛选偶数
            Predicate<Integer> evenPredicate = num -> num % 2 == 0;
    
            // 使用filter方法筛选偶数
            List<Integer> evenNumbers = filter(numbers, evenPredicate);
            
            // 当然也可以直接使用
            List<Integer> collect = numbers.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());
    
            // 输出筛选后的结果
            System.out.println("Even numbers: " + evenNumbers);
            System.out.println("Even numbers: " + collect.size());
        }
    
        public static <T> List<T> filter(List<T> list, Predicate<? super T> predicate) {
        
            List<T> filteredList = new ArrayList<>();
            for (T item : list) {
        
                if (predicate.test(item)) {
        
                    filteredList.add(item);
                }
            }
            return filteredList;
        }
    }

#### map(Function<? super T, ? extends R> mapper)：将元素映射为另一种类型。 ####

package com.lfsun.java8study.mystream;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
    
    /**
     * map方法是Java Stream API中提供的一种数据转换方法，可以将一个Stream中的元素根据指定的转换规则映射成为另一种类型，返回一个新的Stream。
     *
     * map方法是一个中间操作，它不会立即执行，而是返回一个新的Stream对象，该对象包含了映射后的元素。
     * 只有在终止操作（如collect）被调用时，才会执行实际的转换操作。这种惰性求值的特性可以帮助提高程序的性能和效率。
     */
    public class MyMapExample {
        
        public static void main(String[] args) {
        
            List<String> words = Arrays.asList("hello", "world", "java");
            List<String> upperCaseWords = words.stream()
                                                .map(String::toUpperCase)
                                                .collect(Collectors.toList());
            System.out.println(upperCaseWords);
        }
    }

#### flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)：将元素映射为流，并将多个流合并成一个流。 ####

package com.lfsun.java8study.mystream;
    
    import java.util.Arrays;
    import java.util.Collection;
    import java.util.List;
    import java.util.stream.Stream;
    
    /**
     * 它接受一个函数作为参数，将当前Stream中的每个元素映射为另一个Stream，然后将所有Stream合并成一个新的Stream。
     *
     * 以下使用flatMap()方法将多个Stream合并为一个Stream：
     */
    public class MyFlatMapExample {
        
        public static void main(String[] args) {
        
            // 创建一个包含多个List的List
            List<List<String>> nestedList = Arrays.asList(
                    Arrays.asList("apple", "banana", "cherry"),
                    Arrays.asList("date", "elderberry", "fig"),
                    Arrays.asList("grape", "honeydew", "kiwi")
            );
    
            // 将多个List合并为一个Stream
            Stream<String> flatStream = nestedList.stream()
                    .flatMap(Collection::stream);
    
            // 打印合并后的Stream中的元素
            flatStream.forEach(System.out::println);
        }
    }

#### distinct()：去除重复的元素。 ####

package com.lfsun.java8study.mystream;
    
    import java.util.stream.Stream;
    
    /**
     * 用于去除流中的重复元素，返回一个去重后的新流。
     */
    public class MyDistinctExample {
        
        public static void main(String[] args) {
        
            // 创建一个包含重复元素的Stream
            Stream<String> stream = Stream.of("apple", "banana", "cherry", "apple", "banana");
    
            // 去除重复元素
            Stream<String> distinctStream = stream.distinct();
    
            // 打印去重后的Stream中的元素
            distinctStream.forEach(System.out::println);
        }
    }

#### sorted()：对元素进行排序。 ####

package com.lfsun.java8study.mystream;
    
    import java.util.stream.Stream;
    
    /**
     * 用于对流中的元素进行排序。
     * 它返回一个新的流，其中的元素按照自然顺序或者根据自定义的比较器进行排序。
     *
     * sorted()方法不会修改原始流，而是返回一个新的排序后的流。
     */
    public class MySortedExample {
        
        public static void main(String[] args) {
        
            // 创建一个包含整数的Stream
            Stream<Integer> stream = Stream.of(5, 2, 8, 1, 6);
    
            // 对元素进行排序
            Stream<Integer> sortedStream = stream.sorted();
    
            // 打印排序后的Stream中的元素
            sortedStream.forEach(System.out::println);
        }
    }

**终端操作方法**：

#### forEach(Consumer<? super T> action)：对每个元素执行指定的操作。 ####

package com.lfsun.java8study.mystream;
    
    import java.util.stream.Stream;
    
    /**
     * 用于对流中的每个元素执行指定的操作。它接受一个Consumer函数作为参数，该函数接收一个元素并对其执行操作。
     */
    public class MyForEachExample {
        
        public static void main(String[] args) {
        
            // 创建一个包含字符串的Stream
            Stream<String> stream = Stream.of("apple", "banana", "cherry");
    
            // 对每个元素执行指定的操作
            stream.forEach(System.out::println);
        }
    }

#### collect(Collector<? super T, A, R> collector)：将元素收集到集合或其他数据结构中。 ####

package com.lfsun.java8study.mystream;
    
    import java.util.List;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    
    /**
     * 用于将流中的元素收集到一个集合或其他数据结构中，返回收集结果。
     */
    public class MyCollectExample {
        
        public static void main(String[] args) {
        
            // 创建一个包含字符串的Stream
            Stream<String> stream = Stream.of("apple", "banana", "cherry");
    
            // 将元素收集到一个List中
            List<String> collectedList = stream.collect(Collectors.toList());
    
            // 打印收集结果
            System.out.println(collectedList);
        }
    }

#### reduce(BinaryOperator accumulator)：将流中的元素逐个进行聚合操作。 ####

package com.lfsun.java8study.mystream;
    
    import java.util.stream.Stream;
    
    /**
     * 用于将流中的元素逐个进行聚合操作，返回聚合结果。
     */
    public class MyReduceExample {
        
        public static void main(String[] args) {
        
            // 创建一个包含整数的Stream
            Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
    
            // 将元素逐个求和
            Integer sum = stream.reduce(0, Integer::sum);
    
            // 打印求和结果
            System.out.println("Sum: " + sum);
        }
    }

#### count()：计算流中的元素个数。 ####

package com.lfsun.java8study.mystream;
    
    import java.util.stream.Stream;
    
    /**
     * 用于计算流中的元素个数，并返回计数结果。
     */
    public class MyCountExample {
        
        public static void main(String[] args) {
        
            // 创建一个包含整数的Stream
            Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
    
            // 计算元素个数
            long count = stream.count();
    
            // 打印元素个数
            System.out.println("Count: " + count);
        }
    }

#### anyMatch(Predicate<? super T> predicate)：判断流中是否存在满足指定条件的元素。 ####

package com.lfsun.java8study.mystream;
    
    import java.util.stream.Stream;
    
    /**
     * 用于判断流中是否存在满足指定条件的元素。它接受一个Predicate函数作为参数，该函数用于对流中的元素进行条件判断。
     */
    public class MyAnyMatchExample {
        
        public static void main(String[] args) {
        
            // 创建一个包含字符串的Stream
            Stream<String> stream = Stream.of("apple", "banana", "cherry");
    
            // 判断是否存在以"a"开头的元素
            boolean anyMatch = stream.anyMatch(s -> s.startsWith("a"));
    
            // 打印判断结果
            System.out.println("Any match: " + anyMatch);
        }
    }

需要注意的是，Stream接口并不直接存储数据，它是一个概念上的流，对数据的操作是惰性的。只有在执行终端操作时，才会触发中间操作的执行。