前言

最近在学习Stream流，写项目时用到了一些map, filter方法，就想着去学习一下，于是就有了下面这篇文章，下面分享了一些常见的方法和介绍…

Lambda表达式

Lambda表达式是Java8之后才有的写法，Lambda表达式基于数学中的 λ演算 得名，直接对应于其中的lambda抽象（lambda abstraction），是一个匿名函数，即没有函数名的函数。 Lambda表达式可以表示 闭包 （注意和数学传统意义上的不同。

格式

lambda表达式可以看成一个匿名的方法，写法更加简洁，可以省略修饰符、返回类型、throws语句。一般看到的形式：(参数) -> 表达式，包含一个参数列表和一个lambda体，二者之间通过一个函数箭头“->''分隔。

(i,j) -> i*j
1

函数式接口

函数式接口有且只有一个抽象方法的接口，确保接口中仅有一个抽象方法

下面来看个简单的例子：

1. 首先定义一个接口

public interface Man {

    void speak();
}
1
2
3
4

2. 定义一个类实现这个接口，并重写这个方法

public class Dy implements Man{

    @Override
    public void speak() {
        System.out.println("我是男的");
    }
}
1
2
3
4
5
6
7

3. 在主类中调用，这样是不是可以正常打印

public static void main(String[] args) {

        test( () -> {
            System.out.println("我是个男生");
        });

    }

    public static void test(Man man) {
        man.speak();
    } 
1
2
3
4
5
6
7
8
9
10
11

Lambda表达式一定是接口，并且是可以通过上下文来推导出Lambda表达式的接口的。

Stream的方法介绍

stream是位于java.util.stream包，包下面后很多的好用的方法，比如我们很常用的Collectors，Stream等等

获取一个Stream的方法有of

public static<T> Stream<T> of(T t) {
        return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
    }
1
2
3

forEach

我们可以自己获取一个Stream，然后再一个forEach来遍历

Stream<String> words = Stream.of("flink", "Spark", "storm", "MapReduce");
words.forEach(item -> System.out.println(item));
1
2

filter

我们可以使用filter来过滤stream中的数据

List<Integer> list = new LinkedList<>();
list.add(1);
list.add(1);
list.add(1);
list.add(1);
list.add(1);
list.add(2);
list.add(3);
Stream<Integer> stream = list.stream().filter(item -> 
            item > 1
);
1
2
3
4
5
6
7
8
9
10
11

collect

在过滤好之后，我们一般在写一些业务逻辑时会将这个流保存起来

List<Integer> collect1 = list.stream().filter(item ->
                item > 1
       ).collect(Collectors.toList());
1
2
3

count

我们用count来统计数量，这里count返回的是一个long

long count = list.stream().filter(item ->
               item > 1
).count();
1
2
3

sum

有了count计数，当然我们也可以使用sum来进行求和了，但是在进行求和前我们需要将数据使用一个mapToInt将我们的数据先映射到我们需要的数据类型上，原生的有mapToInt, mapToDouble, mapToLong, toIntFunction, toLongFunction, ToDoubleFunction

list.stream().mapToInt(Integer::intValue)
  .sum();
1
2

limit 和skip

获取前n条数据，一般我们处理的都是有序流，如果是无序流的话，这两个都可以说是随机取了

// 获取前两个
Stream<User> limitUserStream = userList.stream().sorted(Comparator.comparing(User::getId))
       .limit(2);
//除去前两个
userList.stream().sorted(Comparator.comparing(User::getId))
       .skip(2);
1
2
3
4
5
6

groupingBy

我们可以通过某个类进行分类，这个programLanguageList是一个对象的列表，我们根据编程语言进行了一个分类，然后就可以打印出我们需要的结果

Map<String, Long> programMap = programLanguageList.stream()
                .collect(Collectors.groupingBy(ProgramLanguage::getLanguage,
                        Collectors.counting()));
System.out.println(programMap.toString());
1
2
3
4

当需要对一个Map类型进行收集的时候，我们可以通过Map.Entry来遍历，然后再通过mapping来觉得收集成什么样的数据

Map<String, String> map = new HashMap<>(4);

map.put("java", "基础语法");
map.put("java", "Spring Boot");
map.put("c++", "算法竞赛入门经典");
map.put("c++", "c++ plus");

Map<String, Set<String>> collectMap = map.entrySet().stream()
                .collect(Collectors.groupingBy(Map.Entry::getKey,
                        Collectors.mapping(Map.Entry::getValue, toSet())));
System.out.println(collectMap.toString());
1
2
3
4
5
6
7
8
9
10
11

reduce

我们通过reduce来对数据进行一些聚合操作

Integer reduce = list.stream().reduce(0, (a, b) -> a + b);
        System.out.println("reduce:" + reduce);
1
2

总结

上述是一些常见的Stream的方法，还有一些其他的方法，但是我没有去列出来，相信大家多用用就会了。