Lambda表达式之常用流操作

collect(toList())

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

public class collect {
   public static void main(String[] args) {
      List<Integer> list = Stream.of(1,2,3,4).collect(Collectors.toList());
      System.out.println(list.equals(Arrays.asList(1,2,3,4)));
   }
}

 

map

如果有一个函数可以将一种类型的值转换成另外一种类型，map操作就可以使用该函数，将一个流中的值转换成一个新的流。传个map函数的Lambda表达式，其传入的参数和返回值不必是同一种类型。但是Lambda表达式必须是Function接口的一个实例（Function接口是只包含一个参数的普通函数接口。

public class Map {
   public static void main(String[] args) {
      List<String> list = Arrays.asList("gzz","welcome","to","chengdu");
      System.out.println(list.stream().map(x->x.toUpperCase()).collect(Collectors.toList()).toString());
   }
}

 

filter

遍历数据并检查其中的元素时，可尝试使用Stream中提供的新方法filter。filter接受一个函数作为参数，该函数用Lambda表达式表示。该Lambda表达式的函数接口是Predicate。

public class Filter {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("ggg","welcome","to","chengdu");
        System.out.println(list.stream().filter(x -> x.startsWith("g")).collect(Collectors.toList()).toString());
    }
}

 

flatMap

flatMap方法可用Stream替换值，然后将多个Stream连接成一个Stream。flatMap方法的相关函数接口和map方法的一样，都是Function接口，只是方法的返回值限定为Stream类型罢了。

public class FlatMap {
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(0,1,2,3,4,5,6);
        List<Integer> list2 = Arrays.asList(3,5,8,9);
        System.out.println(Stream.of(list1,list2).flatMap(Collection::stream).distinct().collect(Collectors.toList()).toString());

        System.out.println(list1.stream().filter( x-> !list2.contains(x)).collect(Collectors.toList()).toString());

        System.out.println(list2.stream().filter( x-> !list1.contains(x)).collect(Collectors.toList()).toString());
    }
}

[0, 1, 2, 3, 4, 5, 6, 8, 9]
[0, 1, 2, 4, 6]
[8, 9]

 

reduce

map()和filter()都是Stream的转换方法，而Stream.reduce()则是Stream的一个聚合方法，它可以把一个Stream的所有元素按照聚合函数聚合成一个结果。reduce()方法传入的对象是BinaryOperator接口，它定义了一个apply()方法，负责把上次计算的结果和本次的元素。

方式一reduce(BinaryOperator accumulator)

Optional<T> reduce(BinaryOperator<T> accumulator);(返回的是Optioanal容器)

public interface BinaryOperator<T> extends BiFunction<T,T,T> {
      public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
    }
    public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
    }
}

 

方式二reduce(T identity, BinaryOperator accumulator)

T reduce(T identity, BinaryOperator<T> accumulator);(返回的是泛型变量)

与第一种变形相同的是都会接受一个BinaryOperator函数接口，不同的是其会接受一个identity参数，identity参数与Stream中数据同类型，相当于一个的初始值，通过累加器accumulator迭代计算Stream中的数据，得到一个跟Stream中数据相同类型的最终结果。

测试样例：

public class Reduce {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,5,6);
        int sum = list.stream().reduce(new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                return integer+integer2;
            }
        }).get();
        System.out.println(sum);

        int sum2 = list.stream().reduce(-1, new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                return integer*integer2;
            }
        });
        System.out.println(sum2);
    }
}

21
-720

 

 

 

 

 

 

 

 

 

 

 

 

 

}

方式一reduce(BinaryOperator accumulator)