1.Lambda管中窥豹
lambda可以理解成一种匿名内部类的简写方式,行为参数化,他的结构是
参数 箭头 主体
如下图:
package com.three;
import java.util.Comparator;
public class LambdaIntroduce {
public static void main(String[] args){
Comparator<Integer> intCompare = new Comparator<Integer>() {
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
};
//by using Lambda
Comparator<Integer> intCompareWithLambda = (Integer a1, Integer a2) -> a1.compareTo(a2);
}
}
这里a1和a2就是参数,a1.compareTo(a2)就是主体
Lambda语法有两种表达方式,我的理解就是隐式的return和显式的return.·
1.(parameters) -> expression
如 (String s1,String s2) -> s1.equals(s2);
()->"Hello"
2.(parameters) ->{statements;}
如 (String s1,String s2) ->{return s1..equals(s2);}
()->{return "Hello";}
2.函数式接口、函数描述符
函数式接口,就是指的有且仅有一个抽象方法的接口
如下:
package com.three;
@FunctionalInterface
public interface FunctionInterface {
int compare(int t1, int t2);
}
通常会用注解@FunctionalInterface来表示这是一个函数式接口
其中定义的抽象方法就叫做函数描述符 :
int compare(int t1, int t2);
Lambda只能应用于函数式接口上
3.函数式接口的使用
3.1 Predicate<T>
函数描述符是boolean test(T t),表示接受一个泛型,返回boolean值,T->boolean
/*
* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
package java.util.function;
import java.util.Objects;
/**
* Represents a predicate (boolean-valued function) of one argument.
*
* <p>This is a <a href="package-summary.html">functional interface</a>
* whose functional method is {@link #test(Object)}.
*
* @param <T> the type of the input to the predicate
*
* @since 1.8
*/
@FunctionalInterface
public interface Predicate<T> {
/**
* Evaluates this predicate on the given argument.
*
* @param t the input argument
* @return {@code true} if the input argument matches the predicate,
* otherwise {@code false}
*/
boolean test(T t);
}
LambdaUseOfPredicate.java:
package com.three;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class LambdaUseOfPredicate {
public static void main(String[] args) {
List<String> list = Arrays.asList("ab", "ac", "bc", "bd", "");
Predicate<String> noneEmptyPredicate = (String s) -> !s.isEmpty();
filter(list, noneEmptyPredicate);
System.out.println("-------------");
Predicate<String> startWithAPredicate = (String s) -> s.startsWith("a");
filter(list, startWithAPredicate);
}
/**
* 过滤并保存满足predicate传递的行为的list中的数据集合
*
* @param list
* @param predicate
* @param <E>
* @return
*/
public static <E> List<E> filter(List<E> list, Predicate<E> predicate) {
List<E> filterList = new ArrayList<>();
for (E e : list) {
if (predicate.test(e)) {
filterList.add(e);
}
}
for (E e : filterList){
System.out.print(e);
System.out.print(" ");
}
return filterList;
}
}
- 在函数式接口Predicate<T>上,通过使用lambda的语法定义了两个noneEmptyPredicate和startWithAPredicate,可以理解成给抽象方法test做了实现,也说明lambda是应用在函数式接口上的
- 行为参数化:noneEmpty和startWithA是两种不同的行为,这里当成了filter函数的第二个参数了,这样的好处就是我把我要做的事情包装成了一个参数进入了filter方法,filter里面怎么过滤的,源代码是不用改的,这就是行为参数化,可以简化很多重复逻辑,不然filter需要多次重写
3.2 Consumer<T>
函数描述符是void accept(T t),接受一个泛型对象,返回为空,即T->void,注意这里也是java.util.function下的函数式接口。个人感觉应用就是“纯消费”,只吃不吐,有入参,返回为空
package java.util.function;
import java.util.Objects;
/**
* Represents an operation that accepts a single input argument and returns no
* result. Unlike most other functional interfaces, {@code Consumer} is expected
* to operate via side-effects.
*
* <p>This is a <a href="package-summary.html">functional interface</a>
* whose functional method is {@link #accept(Object)}.
*
* @param <T> the type of the input to the operation
*
* @since 1.8
*/
@FunctionalInterface
public interface Consumer<T> {
/**
* Performs this operation on the given argument.
*
* @param t the input argument
*/
void accept(T t);
/**
* Returns a composed {@code Consumer} that performs, in sequence, this
* operation followed by the {@code after} operation. If performing either
* operation throws an exception, it is relayed to the caller of the
* composed operation. If performing this operation throws an exception,
* the {@code after} operation will not be performed.
*
* @param after the operation to perform after this operation
* @return a composed {@code Consumer} that performs in sequence this
* operation followed by the {@code after} operation
* @throws NullPointerException if {@code after} is null
*/
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}
LambdaUseOfConsumer.java
package com.three;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
public class LambdaUseOfConsumer {
public static void main(String[] args){
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Consumer<Integer> printElementConsumer = (Integer a) -> System.out.println(a);
forEach(list, printElementConsumer);
Consumer<Integer> elementAddOneConsumer = (Integer a) -> {a++;};
forEach(list, elementAddOneConsumer);
}
public static <E> void forEach(List<E> list, Consumer<E> consumer){
for(E e : list){
consumer.accept(e);
}
}
}
这个例子用来加深理解行为参数化,这里消费者有两个行为,一个是打印每一个元素,一个是每个元素数值加1,这里把行为当成了函数forEach的参数,即行为参数化,这样子复用了方法forEach而不用根据行为不同而重构.
3.3 Function<T, R>
函数式接口是Function<T,R>,函数描述符是T->R,即一个泛型转换为另一个泛型
package java.util.function;
import java.util.Objects;
/**
* Represents a function that accepts one argument and produces a result.
*
* <p>This is a <a href="package-summary.html">functional interface</a>
* whose functional method is {@link #apply(Object)}.
*
* @param <T> the type of the input to the function
* @param <R> the type of the result of the function
*
* @since 1.8
*/
@FunctionalInterface
public interface Function<T, R> {
/**
* Applies this function to the given argument.
*
* @param t the function argument
* @return the function result
*/
R apply(T t);
}