Java 8函数式编程

Posted 2020-10-08

函数式编程

一、Lambda表达式

一）如何辨别Lambda表达式

 1 Runnable noArguments = () -> System.out.println("Hello World"); 
 2 
 3 ActionListener oneArgument = event -> System.out.println("button clicked"); 
 4 Runnable multiStatement = () -> { 
 5 System.out.print("Hello");
 6 System.out.println(" World");
 7 };
 8 
 9 BinaryOperator<Long> add = (x, y) -> x + y; 
10 
11 BinaryOperator<Long> addExplicit = (Long x, Long y) -> x + y; 

1）没有参数用空“（）”表示。

2）只有一个参数，括号可以省略，只写参数名。

3）Lambda 表达式的主体不仅可以是一个表达式， 而且也可以是一段代码块， 使用大括号
（ {}） 将代码块括起来。 该代码块和普通方法遵循的规则别无二致， 可以用返
回或抛出异常来退出。 只有一行代码的 Lambda 表达式也可使用大括号， 用以明确 Lambda
表达式从何处开始、 到哪里结束。

4）Lambda 表达式也可以表示包含多个参数的方法。 这时就有必要思考怎样去阅
读该 Lambda 表达式。 这行代码并不是将两个数字相加， 而是创建了一个函数， 用来计算
两个数字相加的结果。 变量 add 的类型是 BinaryOperator<Long>， 它不是两个数字的和，
而是将两个数字相加的那行代码。 

5）到目前为止， 所有 Lambda 表达式中的参数类型都是由编译器推断得出的。 这当然不错，
但有时最好也可以显式声明参数类型， 此时就需要使用小括号将参数括起来， 多个参数的
情况也是如此。

6）方法引用：Lambda表达式调用参数的一种简便写法。

如：

artist -> artist.getName()
//可以写成
Artist :: getName

构造函数有同样的写法：

（name,nationality）-> new Artist(name,nationlity)
//可以写为
Artist :: new  

目标类型是指 Lambda 表达式所在上下文环境的类型。 比如， 将 Lambda 表
达式赋值给一个局部变量， 或传递给一个方法作为参数， 局部变量或方法参
数的类型就是 Lambda 表达式的目标类型。

二）引用值，而不是变量

匿名内部类需要引用它所在方法里的变量时，需要将变量声明为final。

Java 8中放松了这一限制，可以引用非final变量，但该变量在既成事实上必须是final（只能给该变量赋值一次，

如果试图给该变量多次赋值，然后在Lambda表达式中引用它，编译器就会报错）。

这种行为也解释了为什么lamdba表达式为闭包-------含有自由变量（不是传入参数，且没有在方法块中定义的变量）的代码块。

 

三）函数接口

函数接口是只有一个抽象方法的接口，用作lambda表达式的类型。

四）类型推断

可省略Lambda表达式中所有参数的类型。

无法推断出类型的报错信息：

1 Operator ‘& #x002B;‘ cannot be applied to java.lang.Object, java.lang.Object.

二、流（Stream）

流使得程序员在更高的层次上对集合进行操作。

一）从外部迭代到内部迭代

使用 for 循环计算来自伦敦的艺术家人数 ：

1 int count = 0;
2 for (Artist artist : allArtists) {
3 if (artist.isFrom("London")) {
4 count++;
5 }
6 }

此类代码的问题：

1.每次迭代集合类时， 都需要写很多样板代码

2.for 循环改造成并行方式运行也很麻烦， 需要修改每个 for 循环才能实现。

3.for 循环的样板代码模糊了代码的本意， 程
序员必须阅读整个循环体才能理解。 若是单一的 for 循环， 倒也问题不大， 但面对一个满
是循环（ 尤其是嵌套循环） 的庞大代码库时， 负担就重了。

就其背后的原理来看， for 循环其实是一个封装了迭代的语法糖， 我们在这里多花点时间，
看看它的工作原理。 首先调用 iterator 方法， 产生一个新的 Iterator 对象， 进而控制整
个迭代过程， 这就是外部迭代。 迭代过程通过显式调用 Iterator 对象的 hasNext 和 next
方法完成迭代。 展开后的代码如例 3-2 所示， 图 3-1 展示了迭代过程中的方法调用。

1 int count = 0;
2 Iterator<Artist> iterator = allArtists.iterator();
3 while(iterator.hasNext()) {
4 Artist artist = iterator.next();
5 if (artist.isFrom("London")) {
6 count++;
7 }
8 }

内部迭代：

1 long count = allArtists.stream()
2 .filter(artist -> artist.isFrom("London"))
3 .count();

Stream 是用函数式编程方式在集合类上进行复杂操作的工具。

二）常用的流操作

惰性求值方法：只描述Steam，最终不产生新集合的方法。

及早求值方法：最终会从Steam产生值的方法。

1.collect(toList())

该方法由Steam的值生成一个列表，是一个及早求值的操作。

List<String> collected = Stream.of("a", "b", "c") //Stream.of方法使用一组初始值生成Stream。
.collect(Collectors.toList()); assertEquals(Arrays.asList("a", "b", "c"), collected); 

2.map

map可以将一个流中的值转换成一个新的流。

1 List<String> collected = Stream.of("a", "b", "hello")
2 .map(string -> string.toUpperCase()) //Lambda 表达式必须是 Function 接口的一实例
3 .collect(toList());
4 assertEquals(asList("A", "B", "HELLO"), collected);

 3.filter

遍历数据并检查其中的元素。

1 List<String> beginningWithNumbers
2 = Stream.of("a", "1abc", "abc1")
3 .filter(value -> isDigit(value.charAt(0))) //必须是Predicate
4 .collect(toList());

4.flatmap

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

1 List<Integer> together = Stream.of(asList(1, 2), asList(3, 4))
2 .flatMap(numbers -> numbers.stream()) //必须是Function
3 .collect(toList());
4 assertEquals(asList(1, 2, 3, 4), together);

5.max和min方法

1 List<Track> tracks = asList(new Track("Bakai", 524),
2 new Track("Violets for Your Furs", 378),
3 new Track("Time Was", 451));
4 Track shortestTrack = tracks.stream()
5 .min(Comparator.comparing(track -> track.getLength()))
6 .get();
7 assertEquals(tracks.get(1), shortestTrack);

6.调用List或者Set的stream方法就可以得到Steam对象。

三）元素顺序

1）出现顺序

测试永远通过：

1 List<Integer> numbers = asList(1, 2, 3, 4);
2 List<Integer> sameOrder = numbers.stream()
3 .collect(toList());
4 assertEquals(numbers, sameOrder);

无法保证每次都通过：

1 Set<Integer> numbers = new HashSet<>(asList(4, 3, 2, 1));
2 List<Integer> sameOrder = numbers.stream()
3 .collect(toList());
4 // 该断言有时会失败
5 assertEquals(asList(4, 3, 2, 1), sameOrder);

这会带来一些意想不到的结果， 比如使用并行流时， forEach 方法不能保证元素是
按顺序处理的。 如果需要保证按顺序处理， 应该使用
forEachOrdered 方法

 

四）收集器

一种通用的、 从流生成复杂值的结构。 只要将它传给 collect 方法， 所有
的流就都可以使用它了 。

1）转换为其他集合

如:toList, toSet, toCollection

2)转换成值

利用收集器让流生成一个值 ，如：

1 public Optional<Artist> biggestGroup(Stream<Artist> artists) {
2 Function<Artist,Long> getCount = artist -> artist.getMembers().count();
3 return artists.collect(maxBy(comparing(getCount)));
4 }

3）数据分块

分解成两个集合 ，收集器 partitioningBy， 它接受一个流， 并将其分成两部分 ，它使用 Predicate 对象判断一个元素应该属于哪个部分， 并根据布尔值返回一
个 Map 到列表。

1 public Map<Boolean, List<Artist>> bandsAndSolo(Stream<Artist> artists) {
2 return artists.collect(partitioningBy(artist -> artist.isSolo()));
3 }

4）数据分组

1 public Map<Artist, List<Album>> albumsByArtist(Stream<Album> albums) {
2 return albums.collect(groupingBy(album -> album.getMainMusician()));
3 }

5）字符串

以前的写法：

1 StringBuilder builder = new StringBuilder("[");
2 for (Artist artist : artists) {
3 if (builder.length() > 1)
4 builder.append(", ");
5 String name = artist.getName();
6 builder.append(name);
7 } b
8 uilder.append("]");
9 String result = builder.toString();

现在的写法：

1 String result =
2 artists.stream()
3 .map(Artist::getName)
4 .collect(Collectors.joining(", ", "[", "]"));

 

6）定制收集器

未完待续

三、重载和继承

一）重载

1）Lambda 表达式作为参数时， 其类型由它的目标类型推导得出， 推导过程遵循
如下规则：
1.如果只有一个可能的目标类型， 由相应函数接口里的参数类型推导得出；
2.如果有多个可能的目标类型， 由最具体的类型推导得出；
3.如果有多个可能的目标类型且最具体的类型不明确， 则需人为指定类型。 

2）每个用作函数接口的接口都应该添加@FunctionalInterface注释，该注释会检查被注释接口是否符合函数接口的标准。

 

三）继承

1）默认方法

引入默认方法目的：接口的向后兼容（如果没有默认方法，我们在接口中定义一个新方法时......）。

1.无论函数接口，还是非函数接口都可以使用默认方法。

2.任何时候，默认方法与类中的方法产生冲突，优先选择类中的方法。

3.多重继承，类实现的多个接口中有方法签名相同的默认方法，此时编译器会报错：

1 class Musical Carriage
2 inherits unrelated defaults for rock() from types Carriage and Jukebox。

解决方法：重写：

1 public class MusicalCarriage
2 implements Carriage, Jukebox {
3 @Override
4 public String rock() {
5 return Carriage.super.rock();
6 }
7 }

三）与抽象类的区别

接口和抽象类之间还是存在明显的区别。 接口允许多重继承， 却没有成员变量； 抽象类可
以继承成员变量， 却不能多重继承。

 

四、接口的静态方法

如果一个方法有充分的语义原因和某个概念相关， 那么就应该将该方法和相关的类
或接口放在一起， 而不是放到另一个工具类中。 这有助于更好地组织代码， 阅读代码的人
也更容易找到相关方法。