您的位置：首页 > 编程语言 > Java开发

Java8学习(3)- Lambda 表达式

2017-07-21 18:17 337 查看

Lambda 基本模式
环绕执行模式
函数式接口，类型推断
方法引用
Lambda 复合

上一篇Java8学习(2)- 通过行为参数化传递代码--lambda代替策略模式

1. 结构

初始化一个比较器：

Comparator<Apple> byWeight = new Comparator<Apple>() {
public int copare(Apple a1, Apple a2){
return a1.getWeight().compareTo(a2.getWeight() );
}
}

使用Lambda表达式：

Comparator<Apple> byWeight = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight() );

参数列表--compare方法的的两个参数
箭头 --- 把参数列表与lambda主体分割开
Lambda主体 --- 表达式的值就是Lambda的返回值

1.1 Java8中有效的Lambda表达式

接收一个字符串，并返回字符串长度int

(String a) -> s.length()

接收一个Apple类参数，返回一个boolean值

(Apple a) -> a.getWeight() > 150

接收两个参数，没有返回值(void)，多行语句需要用大括号包围

(int x, int y) -> {
System.out.println("Result:");
System.out.println(x + y);
}

不接收参数，返回一个值

()-> 42

接收两个参数，返回一个值

(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight() );

1.2 Lambda的基本语法

(parameters) -> expression
或
(parameters) -> {statements}

2. 函数式接口

在上次的学习中的通过行为参数化传递代码,

Predicate(T)

就是一个函数式接口：

public interface Predicate<T> {
boolean test(T t);
}

函数式接口就是只定义一个抽象方法的接口。

Java API中很多符合这个条件。比如：

public interface Comparable<T> {
public int compareTo(T o);
}

public interface Runnable {
public abstract void run();
}

@FunctionalInterface
public interface Callable<V> {
V call() throws Exception;
}

2.1 函数式接口可以做什么

Lambda表达式允许你直接以内联的形式为函数式接口的抽象方法提供实现，并把表达式作为函数式接口的实例（函数式接口一个具体实现的实例）。就像内部类一样，但看起来比内部类简洁。

Runnable r1 = () -> System.out.println("1");

Runnable r2 = new Runnable(){
public void run(){
System.out.println("2");
}
};

public static void process(Runnable r) {
r.run();
}

process(r1);
process(r2);
process(() -> System.out.println(3));

@FunctionalInterface

是一个标注，用来告诉编译器这是一个函数式接口，如果不满足函数式接口的条件，编译器就会报错。当然，这不是必须的。好处是编译器帮助检查问题。

3. 一步步修改为Lambda表达式

Lambda式提供了传递方法的能力。这种能力首先可以用来处理样板代码。比如JDBC连接，比如file读写。这些操作会有try-catcha-finally，但我们更关心的是中间的部分。那么，是不是可以将中间的部分提取出来，当做参数传递进来？

3.1 第1步：行为参数化

下面是读一行：

public String read(){
try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
return br.readLine();
} catch (IOException e) {
e.printStackTrace();
}

return null;
}

行为参数化就是把一个过程行为转换成参数。在这里就是将

br.readLine()

提取成参数。

3.2 第2步：使用函数式接口来传递行为

定义一个接口来执行上述的行为：

public interface BufferedReaderProcessor{
String process(BufferedReader b) throws IOException;
}

然后把这个接口当作参数：

public String read(BufferedReaderProcessor p) throws IOException{
try(BufferedReader br = new BufferedReader(new FileReader("data.txt"))){
return p.process(br);
}
}

3.3 第3步：传递Lambda

@Test
public void readFile() throws IOException {
String oneLine = read(BufferedReader::readLine);
String twoLine = read((BufferedReader b) -> b.readLine() + b.readLine());
}

如此，我们就把中间的逻辑抽出来了。把行为抽象成一个接口调用，然后通过Lambda来实现接口的行为。传递参数。完毕。

4. Java API中内置的一些函数式接口

Java API中内置了一些很有用的Function接口。

4.1 Predicate

java.util.function.Predicate<T>
定义了一个抽象方法，返回一个
boolean
。

使用demo如下：

private <T>  List<T> filter(List<T> list, Predicate<T> p){
List<T> results = new ArrayList<>();
for (T t : list) {
if (p.test(t)){
results.add(t);
}
}
return results;
}
@Test
public void testPredicate(){
List<String> list = Arrays.asList("aa","bbb","ccc");
List<String> noEmpty = filter(list, (String s) -> !s.isEmpty());
}

4.2 Consuer

java.util.function.Consumer<T>
定义了一个抽象方法，接收一个参数。

private <T> void forEach(List<T> list, Consumer<T> c){
for (T t : list) {
c.accept(t);
}
}
@Test
public void testConsumer() {
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
forEach(integers, System.out::println);
}

4.3 Function

java.util.function.Function<T,R>
定义了一个抽象方法，接收一个参数

，返回一个对象

private <T,R> List<R> map(List<T> list, Function<T,R> f){
List<R> result = new ArrayList<>();
for (T t : list) {
result.add(f.apply(t));
}
return result;
}

@Test
public void testFunction(){
List<String> strings = Arrays.asList("a", "bb", "ccc");
List<Integer> lengths = map(strings, String::length);
}

4.4 基本类型函数接口

前面三个泛型函数式接口

Predicate<T>

、

Consumer<T>

、

Function<T,R>

，这些接口是专门为引用类型设计的。那么基本类型怎么办？我们知道可以自动装箱嘛。但装箱是有损耗的。装箱(boxing)的本质是把原始类型包裹起来，并保存在堆里。因此装箱后的值需要更多的内存，并需要额外的内存搜索来获取包裹的原始值。

Java8为函数式接口带来了专门的版本。

@Test
public void testIntPredicate() {
//无装箱
IntPredicate intPredicate = (int t) -> t%2 == 0;
boolean isEven = intPredicate.test(100);
Assert.assertTrue(isEven);
//装箱
Predicate<Integer> integerPredicate = (Integer i) -> i%2 == 0;
boolean isEven2 = integerPredicate.test(100);
Assert.assertTrue(isEven2);
}

类似的还有:

Java 8中的常用函数式接口

5. Lambda原理

编译器可以推断出方法的参数类型，由此可以省略一些样板代码。
void和其他返回值做了兼容性处理

6. Lambda的局部变量

在Lambda中可以使用局部变量，但要求必须是final的。因为Lambda可能在另一个线程中运行，而局部变量是在栈上的，Lambda作为额外的线程会拷贝一份变量副本。这样可能会出现同步问题，因为主线程的局部变量或许已经被回收了。基于此，必须要求final的。

而实例变量则没问题，因为实例变量存储于堆中，堆是共享的。

7. 方法引用

Lambda表达式可以用方法引用来表示。比如

(String s) -> s.length()
==
String::length

这是因为可以通过Lambda表达式的参数以及方法来确定一个方法。在这里，每个方法都叫做

方法签名

。方法签名由方法名+参数列表唯一确定。其实就是重载的判断方式。

当Lambda的主体只是一个简单的方法调用的时候，我们可以直接使用一个方法引用来代替。方法引用可以知道要接受的参数类型，以及方法体的逻辑。

方法引用结构：

类名::方法名

什么可以使用方法引用？

静态方法。

指向任意类型实例方法的方法引用。

指向现有对象的实例方法。

8. 构造函数引用

构造函数可以通过

类名::new

的方式引用。

9. Lambda实战

目标：用不同的排序策略给apple排序。

过程：把一个原始粗暴的解决方案变得更加简单。

资料：

行为参数化

匿名类

，

Lambda

方法引用

.

最终：

inventory.sort(comparing(Apple::getWeight) );

9.1 原始方案

/**
* Created by ryan on 7/20/17.
*/
public class AppleSort {
private List<Apple> inventory;

@Before
public void setUp() {
inventory = new ArrayList<>();
inventory.add(new Apple("red", 1));
inventory.add(new Apple("red", 3));
inventory.add(new Apple("red", 2));
inventory.add(new Apple("red", 21));
}

@Test
public void sort_old() {
Collections.sort(inventory, new Comparator<Apple>() {
@Override
public int compare(Apple o1, Apple o2) {
return o1.getWeight() - o2.getWeight();
}
});

printApples();
}

private void printApples() {
inventory.forEach(System.out::println);
}
}

排序首先要注意的一点就是排序的标准。那么要搞清楚为什么这样写？

Comparator定义的其实就是一个方法，此处就是将排序的原则抽取出来。特别符合Lambda的思想！这里先不说Lambda，先说这个方法的作用：定义什么时候发生交换。

跟踪源码可以发现这样一段代码:

//java.util.Arrays#mergeSort(java.lang.Object[], java.lang.Object[], int, int, int, java.util.Comparator)
if (length < INSERTIONSORT_THRESHOLD) {
for (int i=low; i<high; i++)
for (int j=i; j>low && c.compare(dest[j-1], dest[j])>0; j--)
swap(dest, j, j-1);
return;
}

假设比较的两个数为

o1

和

o2

，并且

o1

在

o2

前一位(left>right)。如下：

....o1,o2...

compare(o1,o2)

的结果大于0则，

o1

和

o2

交换。那么，显然，如果

compare(o1,o2) = o1-o2

则说明，前一个值比后一个值大的时候，发生交换。也即大的往后冒泡。就是升序了。

所以：

o1-o2

升序

o2-o1

降序

9.2 使用List内置sort

好消息是Java8提供了sort方法给list：

java.util.List#sort

:

则原始方案转换为：

@Test
public void sort1(){
inventory.sort(new Comparator<Apple>() {
@Override
public int compare(Apple o1, Apple o2) {
return o1.getWeight() - o2.getWeight();
}
});

printApples();
}

9.3 Lambda表达式代替匿名内部类

从之前的学习可以得到，几乎所有的匿名内部类都可以用Lambda表达式替代！

inventory.sort((o1, o2) -> o1.getWeight() - o2.getWeight());

9.4 进一步优化Lambda

Comparator

提供了一个生成Comparator的方法:

public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
Function<? super T, ? extends U> keyExtractor)
{
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
}

其中，

Function<T,R>

已经在前面学习过了，就是一个接受一个参数并返回另一个参数的函数式接口。在本例中，

apple.getWeight()

符合接受一个参数

apple

返回一个

int

。那么，就可以使用这个方法：

inventory.sort(Comparator.comparing((Apple a)->a.getWeight()));

进一步，将Lambda改为方法引用：

inventory.sort(Comparator.comparing(Apple::getWeight));

这里有个问题，记得之前讲的基本类型的自动装箱吗。

Apple::getWeight

的返回值是

int

。而

comparing

的返回值是一个对象。那么，必然要经过自动装箱的过程。所以，应该使用基本类型的函数式接口：

inventory.sort(Comparator.comparingInt(Apple::getWeight));

至此，基本已经改造完毕了。最多就是静态引入

comparingInt

方法：

inventory.sort(comparingInt(Apple::getWeight));

目标达到。相比原始方法，不要太简洁！

话说，这种是不是只能默认升序？因此没有任何一个单词可以看出排序规则。

是的，想要降序？

inventory.sort(comparingInt(Apple::getWeight).reversed());

So do it,and change it,no regret!

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航