collect(toList())

collect(toList()) 方法由 Stream 里的值生成一个列表， 是一个及早求值操作。

 @Test
    public void lambdaCollect(){
        List<String> collected = Stream.of("a" , "b" , "c").collect(Collectors.toList());
        Assert.assertEquals(Arrays.asList("a" , "b" , "c") , collected);
    }

map

如果有一个函数可以将一种类型的值转换成另外一种类型， map 操作就可以
使用该函数， 将一个流中的值转换成一个新的流。

使用 for 循环将字符串转换为大写

List<String> collected = new ArrayList<>();
        for (String string : Arrays.asList("a", "b", "hello")) {
            String uppercaseString = string.toUpperCase();
            collected.add(uppercaseString);
        }
        assertEquals(Arrays.asList("A", "B", "HELLO"), collected);

使用 map 操作将字符串转换为大写形式

  @Test
    public void lambdaMap(){
        List<String> collected = Stream.of("a" , "b" , "hello")
                .map(s -> s.toUpperCase())
                .collect(Collectors.toList());
        assertEquals(Arrays.asList("A" , "B" , "HELLO") , collected);
    }

filter

遍历数据并检查其中的元素时， 可尝试使用 Stream 中提供的方法 filter

使用循环遍历列表， 使用条件语句做判断

List<String> beginningWithNumbers = new ArrayList<>();
        for(String value : asList("a", "1abc", "abc1")) {
            if (isDigit(value.charAt(0))) {
                beginningWithNumbers.add(value);
            }
        }
        assertEquals(asList("1abc"), beginningWithNumbers);

函数式风格

 @Test
    public void lambdaFilter(){
        List<String> beginningWithNumbers = Stream.of("a" , "1abc" , "abc1")
                .filter(value -> isDigit(value.charAt(0))).collect(Collectors.toList());
        assertEquals(asList("1abc") , beginningWithNumbers);
    }

flatMap

flatMap 方法可用 Stream 替换值， 然后将多个 Stream 连接成一个 Stream

假设有一个包含多个列表的流， 现在希望得到所有数字的序列

@Test
    public void lambdaFlatMap(){
        List<Integer> together = Stream.of(asList(1, 2) , asList(3 , 4))
                .flatMap(numbers -> numbers.stream())
                .collect(Collectors.toList());
        assertEquals(asList(1 , 2 , 3 , 4) , together);
    }

max和min

使用 Stream 查找最小值和最大值

    List<Track> tracks = asList(new Track("zzl" , 524)
                , new Track("andy" , 378)
                ,new Track("andy" , 451));

        Track shortestTrack = tracks.stream()
                .min(Comparator.comparing( track -> track.getLength()))
                .get();

        assertEquals(tracks.get(1) , shortestTrack);

        Track longtestTrack = tracks.stream()
                .max(Comparator.comparing( track -> track.getLength()))
                .get();
        assertEquals(tracks.get(0) , longtestTrack);

为了让 Stream 对象按照长度进行排序， 需要传给它一个 Comparator 对象。 Java 8 提供了一个新的静态方法 comparing， 使用它可以方便地实现一个比较器。

reduce

reduce 操作可以实现从一组值中生成一个值。 在上述例子中用到的 count、 min 和 max 方法， 因为常用而被纳入标准库中。 事实上， 这些方法都是 reduce 操作。

下面代码，Lambda 表达式就是 reducer， 它执行求和操作， 有两个参数： 传入 Stream 中的当前元素和 acc。 将两个参数相加， acc 是累加器， 保存着当前的累加结果。

  @Test
    public void lambdaReduce(){
      int count = Stream.of(1 ,2 , 3).reduce(0 , (acc , element) -> acc + element);
      assertEquals(6 , count);
    }