Java8学习笔记整理----stream_02

悠悠 2023-06-04 07:54 22阅读 0赞

**需求1：** 打印热量排在前三的菜肴

List<String> names = menu.stream()
                    .filter(d -> d.getCalories() > 300)
                    .map(Dish::getName)
                    .limit(3)
                    .collect(toList());

**需求2：** 把菜单里面的素菜打印出来  
Java8之前：forEach(外部迭代)

List<Dish> vegetarianDishes = new ArrayList<>();
            for(Dish d: menu){ 
                if(d.isVegetarian()){ 
                    vegetarianDishes.add(d);
                }
            }

Java8：

List<Dish> vegetarianDishes =
                    menu.stream()
                            .filter(Dish::isVegetarian)
                            .collect(toList());

表面看上去差不多是不是？！后面的稍微优雅一些。分析过程如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjA2OTAx_size_16_color_FFFFFF_t_70]

**需求3：** 筛选出列表中所有的偶数，并确保没有重复

List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
            numbers.stream()
                    .filter(i -> i % 2 == 0)
                    .distinct()
                    .forEach(System.out::println);

流还支持一个叫作distinct的方法，它会返回一个元素各异（根据流所生成元素的hashCode和equals方法实现）的流。分析过程如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjA2OTAx_size_16_color_FFFFFF_t_70 1]**需求4：** 跳过超过300卡路里的头两道菜，并返回剩下的

List<Dish> dishes = menu.stream()
                    .filter(d -> d.getCalories() > 300)
                    .skip(2)
                    .collect(toList());

请注意，limit(n)和skip(n)是互补的！

**需求5：** 给定一个单词列表，你想要返回另一个列表，显示每个单词中有几个字母

List<String> words = Arrays.asList("Java 8", "Lambdas", "In", "Action");
            List<Integer> wordLengths = words.stream()
                    .map(String::length)
                    .collect(toList());

回到案例，**需求6：** 提取菜名

List<Integer> dishNameLengths = menu.stream()
                    .map(Dish::getName)
                    .map(String::length)
                    .collect(toList());

**需求7：** 对于一张单词表，如何返回一张列表， 列出里面各不相同的字符呢？ 例如，给定单词列表\[“Hello”,“World”\]，你想要返回列表\[“H”,“e”,“l”, “o”,“W”,“r”,“d”\]。  
**错误示范：**

words.stream()
                    .map(word -> word.split(""))
                    .distinct()
                    .collect(toList());

这个方法的问题在于，传递给map方法的Lambda为每个单词返回了一个String\[\]（String 列表）。因此， map 返回的流实际上是Stream<String\[\]> 类型的。你真正想要的是用  
Stream来表示一个字符流  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjA2OTAx_size_16_color_FFFFFF_t_70 2]2. 使用flatMap

List<String> uniqueCharacters = words.stream()
                    .map(w -> w.split(""))
                    .flatMap(Arrays::stream)
                    .distinct()
                    .collect(Collectors.toList());

使用flatMap方法的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所有使用map(Arrays::stream)时生成的单个流都被合并起来，即扁平化为一个流  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjA2OTAx_size_16_color_FFFFFF_t_70 3]**需求8：** 给定一个数字列表，如何返回一个由每个数的平方构成的列表呢？例如，给定\[1, 2, 3, 4, 5\]，应该返回\[1, 4, 9, 16, 25\]

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
            List<Integer> squares = numbers.stream()
                    .map(n -> n * n)
                    .collect(toList());

**需求9：** 给定两个数字列表，如何返回所有的数对呢？例如，给定列表\[1, 2, 3\]和列表\[3, 4\]，应该返回\[(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)\]。为简单起见，你可以用有两个元素的数组来代表数对。

List<Integer> numbers1 = Arrays.asList(1, 2, 3);
            List<Integer> numbers2 = Arrays.asList(3, 4); List<int[]> pairs =
                    numbers1.stream()
                            .flatMap(i -> numbers2.stream()
                                    .map(j -> new int[]{ i, j})
                            )
                            .collect(toList());

可以使用两个map来迭代这两个列表，并生成数对。但这样会返回一个Stream-  
<Stream<Integer\[\]>>。你需要让生成的流扁平化，以得到一个Stream<Integer\[\]>。这正是flatMap所做的。

**需求10：** 如何扩展前一个例子，只返回总和能被3整除的数对呢？例如(2, 4)和(3, 3)是可以的

List<Integer> numbers1 = Arrays.asList(1, 2, 3);
            List<Integer> numbers2 = Arrays.asList(3, 4); List<int[]> pairs =
                    numbers1.stream()
                            .flatMap(i ->
                                    numbers2.stream()
                                            .filter(j -> (i + j) % 3 == 0)
                                            .map(j -> new int[]{ i, j})
                            )
                            .collect(toList());

**需求11：** 查找菜单中的素菜

if(menu.stream().anyMatch(Dish::isVegetarian)){ 
    System.out.println("The menu is (somewhat) vegetarian friendly!!");
    }

anyMatch方法可以回答“流中是否有一个元素能匹配给定的谓词”

**需求12：** 给定一个数字列表，下面的代码能找出第一个平方能被3整除的数：

List<Integer> someNumbers = Arrays.asList(1, 2, 3, 4, 5); Optional<Integer> firstSquareDivisibleByThree =
                    someNumbers.stream()
                            .map(x -> x * x)
                            .filter(x -> x % 3 == 0)
                            .findFirst(); // 9

**需求13：** 对数字列表中的元素求和：  
先来看看如何使用for-each循环来对数字列表中的元素求和：

int sum = 0;
    for (int x : numbers) { 
    sum += x;
    }

再看看java8的处理方式：

int sum = numbers.stream().reduce(0, (a, b) -> a + b);

**同理**：相乘如下：

int product = numbers.stream().reduce(1, (a, b) -> a * b);

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjA2OTAx_size_16_color_FFFFFF_t_70 4]**需求13：** 利用reduce来计算流中的最大值、最小值

Optional<Integer> max = numbers.stream().reduce(Integer::max);

Optional<Integer> min = numbers.stream().reduce(Integer::min);

**需求14：** 怎样用map和reduce方法数一数流中有多少个菜呢？  
方法一：把流中每个元素都映射成数字1，然后用reduce求和。这相当于按顺序数流中的元素个数。

int count = menu.stream()
                    .map(d -> 1)
                    .reduce(0, (a, b) -> a + b);

方法二：内置count方法可用来计算流中元素的个数：

long count = menu.stream().count();

**需求15：** 使用Stream.of创建了一个字符串流。然后，你可以将字符串转换为大写，再一个个打印出来：

Stream<String> stream = Stream.of("Java 8 ", "Lambdas ", "In ", "Action"); 
    stream.map(String::toUpperCase).forEach(System.out::println);

**需求16：** 使用静态方法Arrays.stream从数组创建一个流。它接受一个数组作为参数。例如， 你可以将一个原始类型int的数组转换成一个IntStream

int[] numbers = { 2, 3, 5, 7, 11, 13};
    int sum = Arrays.stream(numbers).sum();

**需求16：** 看看一个文件中有多少各不相同的词：

long uniqueWords = 0;
            try(Stream<String> lines =
                        Files.lines(Paths.get("data.txt"), Charset.defaultCharset())){ 
                uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(" ")))
                        .distinct()
                        .count();
            }
            catch(IOException e){ 
            //此处做异常处理，省略
            }

**需求17：**  
斐波纳契数列是著名的经典编程练习。下面这个数列就是斐波纳契数列的一部分：0, 1, 1,  
2, 3, 5, 8, 13, 21, 34, 55…数列中开始的两个数字是0和1，后续的每个数字都是前两个数字之和。  
斐波纳契元组序列与此类似，是数列中数字和其后续数字组成的元组构成的序列：(0, 1),  
(1, 1), (1, 2), (2, 3), (3, 5), (5, 8), (8, 13), (13, 21) …  
你的任务是用iterate方法生成斐波纳契元组序列中的前20个元素。

Stream.iterate(new int[]{ 0, 1},
                    t -> new int[]{ t[1], t[0]+t[1]})
                    .limit(20)
                    .forEach(t -> System.out.println("(" + t[0] + "," + t[1] +")"));

**扩展：** 如果只想打印正常的斐波纳契数列，可以使用map提取每个元组中的第一个元素：

Stream.iterate(new int[]{ 0, 1},
                    t -> new int[]{ t[1],t[0] + t[1]})
                    .limit(10)
                    .map(t -> t[0])
                    .forEach(System.out::println);

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjA2OTAx_size_16_color_FFFFFF_t_70]: /images/20230601/b461a1cb86a74833b70405b5f05171a4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjA2OTAx_size_16_color_FFFFFF_t_70 1]: /images/20230601/5c48972381f14256bd5bc4103f67b344.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjA2OTAx_size_16_color_FFFFFF_t_70 2]: /images/20230601/f2b92e75192945b7ad2d3d024307c5a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjA2OTAx_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191007181737368.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjA2OTAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjA2OTAx_size_16_color_FFFFFF_t_70 4]: /images/20230601/8e2561507dcc4423a4193b0205d21e11.png