Java Lambda and Stream

, , Comments

什么是Lambda表达式

  • 利用Lambda可以更简洁的实现匿名内部类与函数声明与调用
  • 基于Lambda提供stream流式处理极大简化对集合的操作

使用Lambda表达式

  • Collections.sort(names, (a, b) -> a.compareTo(b));

Lambda语法格式

  • （参数列表）-> 实现语句
  • 参数列表: 使用逗号分隔参数， 参数类型可省略，单参数的情况下括号可省略
  • 实现语句: 单行直接写，多行用{}包括
  • 约束条件，Lambda表达式只能实现有且只有一个抽象方法的接口，Java称为函数式接口

函数式编程

  • 基于函数式接口并使用Lambda表达式的编程方式
  • 函数式编程的理念是将代码作为可重用数据带入到程序运行中
  • 强调你想做什么，而不是你想怎么做

函数是接口

  • 函数式接口是有且只有一个抽象方法的接口
  • Java中拥有大量函数式接口，如java.lang.Runnable
  • JDK8后提供了一系列新的函数式接口，位于java.util.function

函数式接口Predicate

  • 用于测试传入的数据是否满足判断要求

  • Predicate是新增的函数式接口

  • 需要实现test()方法进行逻辑判断

  • 我们将函数的实现以参数形式传入

  • 当调用predicate.test()时，运行的是我们传入的具体实现

1
2
3
4
5
6
7
public static void filter(List<Integer> list, Predicate<Integer> predicate) {
    for (Integer num : list) {
        if (predicate.test(num)) {
        System.out.println(num);
        }
    }
}
1
filter(list, n->n%2 == 1);

函数式接口Consumer

  • 接受一个参数并对其加工，不返回任何结果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ConsumerSample {
  // output() 函数并不知道consumer.accept()函数的具体实现是什么
  // 它是多变的，具体取决于调用output时传入的参数
  public static void output(String text, Consumer<String> consumer) {
    consumer.accept(text);
  }

  public static void main(String[] args) {
    String text = "some text";
    // print to console
    output(text, s -> System.out.println("print to console: " + s));

    // send to website
    output(text, s -> System.out.println("send to website: " + s));
  }
}

函数式接口Function

  • 接受一个输入参数，并且返回一个结果
  • Function<T, R>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class FunctionSample {
  // generate fixed length random string
  // input parameter: the length of the random string
  // return: random string
  public static void main(String[] args) {
    Function<Integer, String> randomStringFunction = l -> {
      String chars = "abcdefghijklmnopqrstuvwxyz0123456789";
      StringBuffer stringBuffer = new StringBuffer();
      Random random = new Random();
      for (int i = 0; i < l; ++i) {
        int position = random.nextInt(chars.length());
        stringBuffer.append(chars.charAt(position));
      }

      return stringBuffer.toString();
    };

    System.out.println(randomStringFunction.apply(10));
  }
}

函数式编程特点

  • 面向过程
  • 侧重结果，快速实现
  • 更适合人眼阅读
  • 代码量少
  • 不会出现线程安全问题，每一个函数都是独一的
  • 健壮性差
  • 适合小型应用，要求快速实现

Stream流式处理

  • 建立在Lambda基础上的多数据处理技术
  • 对集合数据处理进行高度抽象。极大简化代码量
  • 可对集合进行迭代，筛选，排序，聚合等一系列处理

Stream实例

1
2
3
4
5
6
7
// 获取List集合中最大的偶数
Optional<Integer> op = Arrays.asList(1,2,3,4,5,6).stream()
  .filter(x -> x % 2 == 0) // get even numbers
  .sorted((a, b) -> b - a) // sort descending
  .findFirst(); // get first element

System.out.println(op.get());

Stream常用方法

接口 用途
forEach 循环遍历
map map方法用于映射每个元素到对应的结果
filter filter方法用于通过设置的条件过滤出元素
limit 用于获取指定元素数量
sorted 用于对流进行排序
Collectors Collectors类实现将流转换成集合和聚合元素

创建流的5中方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// Stream流对象创建的5种方式
public class StreamGenerator {
  // 基于数组创建
  @Test
  public void generatorOne() {
    String[] strings = {"one", "two", "three", "four"};
    Stream<String> stream = Stream.of(strings);
    stream.forEach(s -> System.out.println(s));

  }

  // 基于集合创建
  @Test
  public void generatorTwo() {
    List<String> list = new ArrayList<>();
    list.add("one");
    list.add("two");
    list.add("three");
    list.add("four");
    list.stream().forEach(s -> System.out.println(s));
  }

  // 基于generate方法创建无限长度流
  @Test
  public void generatorThree() {
    Stream<Integer> stream = Stream.generate(() -> new Random().nextInt(100000));
    stream.limit(10).forEach(i -> System.out.println(i));
  }

  // 基于迭代器创建流
  // 可以替代for循环，但是使用较少
  @Test
  public void generatorFour() {
    Stream<Integer> stream = Stream.iterate(1, n -> n + 1);
    stream.limit(100).forEach(i -> System.out.println(i));
  }

  // 基于字符序列创建流
  @Test
  public void generatorFive() {
    String str = "some text";
    IntStream stream = str.chars();
    stream.forEach(c -> System.out.println((char) c));
  }
}

Tips about IntStream and Stream

  • IntStream contains the stream of primitive type values
  • Stream<Integer> box the values to Integer
  • if you want to convert strings to primitive type you could use mapToInt() instead of just map(), this will give you primitive values and can be assigned to IntStream

Examples

1
2
3
4
// List of Strings to IntStream
List<String> list =  Arrays.asList("1", "2", "3", "4", "5");
IntStream stream = list.stream()
        .mapToInt(s -> Integer.parseInt(s));
1
2
3
4
// List of Strings to Stream<Integer>
List<String> list =  Arrays.asList("1", "2", "3", "4", "5");
Stream<Integer> stream = list.stream()
        .map(s -> Integer.parseInt(s));

更多案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class StreamMethod {
  // 提取集合中所有偶数并求和
  @Test
  public void methodOne() {
    List<String> list =  Arrays.asList("1", "2", "3", "4", "5");
    int sum = list.stream()
            .mapToInt(s -> Integer.parseInt(s)) // convert element from string to int
            .filter(n -> n % 2 == 0) // get all even numbers
            .sum(); // sum to one int

    System.out.println(sum);
  }

  // 所有名字首字母大写
  @Test
  public void methodTwo() {
    List<String> list = Arrays.asList("lily", "smith", "jackson");
    List<String> newList = list.stream()
            .map(s -> s.substring(0, 1).toUpperCase() + s.substring(1)) // 按指定规则对每一个流数据进行转换
            .collect(Collectors.toList()); // 对流数据进行收集，生成新的List/Set

    System.out.println(newList);
  }

  // 将所有奇数从大到小排序，且不许出现重复
  @Test
  public void methodThree() {
    List<Integer> list = Arrays.asList(1,69,342,4,5,143,2134,5,4324,45,56);
    List<Integer> newList = list.stream().distinct() // 去除重复的数据
            .filter(n -> n % 2 == 1) // 拿到奇数
            .sorted((a, b) -> b - a) // 排序
            .collect(Collectors.toList());
    System.out.println(newList);
  }
}

Yuan ChengSoftware Engineer

Wait and see