作者:@Ryan-Miao
本文为作者原创,转载请注明出处:http://www.cnblogs.com/woshimrf/p/java8-lambda.html
目录
1.1 Java8中有效的Lambda表达式
1.2 Lambda的基本语法
2.1 函数式接口可以做什么
3.1 第1步: 行为参数化
3.2 第2步:使用函数式接口来传递行为
3.3 第3步: 传递Lambda
4.1 Predicate
4.2 Consuer
4.3 Function
4.4 基本类型函数接口
9.1 原始方案
9.2 使用List内置sort
9.3 Lambda表达式代替匿名内部类
9.4 进一步优化Lambda
猪脚:以下内容参考《Java 8 in Action》
本次学习内容:
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(); }@FunctionalInterfacepublic 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
@Testpublic 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; }@Testpublic 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); } }@Testpublic 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>
定义了一个抽象方法,接收一个参数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; }@Testpublic 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为函数式接口带来了专门的版本。
@Testpublic 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
:
则原始方案转换为:
@Testpublic 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!
http://www.cnblogs.com/woshimrf/p/java8-lambda.html