目录
1.Lambda的简单介绍
2.java 8 的函数式接口
2.1 Predicate的使用
2.2 Consumer的使用
2.3 Function的使用
2.4 Supplier的使用
2.5 Comparator的使用
2.6 BinaryOperator的使用
3.总结
1.Lambda的简单介绍
Lambda表达式可以简单的理解为一种简洁的可传递匿名函数：它没有名字，但它有参数列表、函数主体、返回类型，可能还能抛出异常列表。
Lambda表达式的基本语法：(parameters) -> expression 或者 (parameters) ->{statements;}
注意：本文着重写Lambda表达式在函数式接口的使用，至于Lambda的详细内容请读者查阅相关书籍阅读。
2.java 8 的函数式接口
Java 8 中常用函数式接口
函数式接口 | 函数描述符 | 基本类型特化 |
Predicate<T> | T -> boolean | IntPredicate LongPredicate DoublePredicate |
Consumer<T> | T -> void | IntConsumer LongConsumer DoubleConsumer |
Function<T,R> | T -> R | IntFunction<R> IntToDoubleFunction IntToLongFunction LongFunction<R> LongToDoubleFunction LongToIntFunction DoubleFunction<R> DoubleToIntFunction DoubleToLongFunction ToIntFunction<T> ToDoubleFunction<T> ToLongFunction<T> |
Supplier<T> | () -> T | BooleanSupplier IntSupplier LongSupplier DoubleSupplier |
UnaryOperator<T> | T -> T | IntUnaryOperator LongUnaryOperator DoubleUnaryOperator |
BinaryOperator<T> | (T,T) -> T | IntBinaryOperator LongBinaryOperator DoubleBinaryOperator |
BiPredicate<T,U> | (T,U) ->boolean | |
BiConsumer | (T,U) -> void | ObjIntConsumer<T> ObjLongConsumer<T> ObjDoubleConsumer<T> |
BiFunction<T,U,R> | (T,U) -> R | ToIntBiFunction<T,U> ToLongBiFunction<T,U> ToDoubleBiFunction<T,U> |
Comparator<T> | (T,T) -> int |
注意：函数描述符是指的函数式接口的抽象方法的签名。举个栗子：Runnable接口有一个抽象方法run，这个方法不接受任何参数，也不返回任何值，就可以表示为() -> void
2.1 Predicate的使用
Predicate有五个重要的方法，下面来介绍它们的使用
boolean test(T t);
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate<T> negate() {
return (t) -> !test(t);
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
1.test方法的使用
假设你想有一筐苹果，你想扔掉绿苹果，只要红苹果，那么你一定要想到test方法。话不多说，请看此例
public static List<Apple> filterApples(List<Apple> inventory, Predicate<Apple> p) {
List<Apple> result = new ArrayList<>();
for (Apple apple : inventory) {
if (p.test(apple)) {
result.add(apple);
}
}
return result;
}
List<Apple> greenApples2 = filterApples(inventory, (Apple a) -> "green".equals(a.getColor()));
test方法，它接受泛型T对象，并返回一个boolean。当你想过滤一个列表中某些元素，可以使用它。可能小伙伴会提问，我直接将if语句里的条件改成 "green".equals(apple.getColor())，此时filterApples方法只需要一个参数List<Apple> inventory不就行了嘛，那么我此时抽风，不让你过滤绿苹果，让你过滤苹果重量大于150或者过滤坏苹果呢，你不会想到再写几个方法吧，而你用我上面的例子，你只需改变Lambda表达式即可，多么强大，赶紧用起来。
2.negate、and、or和isEqual的使用
假设你不仅想过滤绿苹果，又想过滤到苹果重量大于150呢？此时这四个方法就能派上用场
public static List<Apple> filterGreenAndHeavyApples(List<Apple> inventory, Predicate<Apple> p1, Predicate<Apple> p2){
List<Apple> result = new ArrayList<>();
for (Apple apple : inventory) {
if (p1.and(p2).test(apple)) {
result.add(apple);
}
}
return result;
}
List<Apple> redAndLightApples = filterGreenAndHeavyApples(inventory, apple -> "red".equals(apple.getColor()), (Apple a) -> a.getWeight() > 150);
这四个方法可以配合test方法构造多种条件，其中negate等价于取非，and等价于&& ，or等价于 ||，and和or方法按照表达式链中位置，从左向右确定优先级的。例如，a.or(b).and(c) 看做(a || b ) && c,a.and(b).or(c) 看做(a && b) || c。有了这四个方法，你就可以放弃if - else语句了，写出优雅的代码了。
注意：IntPredicate、LongPredicate和DoublePredicate这三个接口见名知意，参数是对应的基本数据类型，不再介绍，后面接口介绍也是如此。
2.2 Consumer的使用
Consumer有两个重要方法，下面依次介绍
void accept(T t);
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
1.accep方法的使用
accept方法接收一个泛型T的对象，假如你需要访问类型T的对象，并对其执行某些操作，就可以使用它。举个栗子，假设给你List类型的集合，你如何遍历它呢？你可能最能想到的是增强for循环，我再给你一个优雅的方法
ArrayList<Integer> list = new ArrayList<>();
list.forEach(num -> System.out.println("num = " + num));
为何能这样使用呢？我们看一下forEach方法，就一目了然了，它的方法参数是Consumer类型的，遍历的时候调用它accept方法，而你传的Lambda表达式相当于重新它的accept方法
public void forEach(Consumer<? super E> action) {
Objects.requireNonNull(action);
final int expectedModCount = modCount;
@SuppressWarnings("unchecked")
final E[] elementData = (E[]) this.elementData;
final int size = this.size;
for (int i=0; modCount == expectedModCount && i < size; i++) {
action.accept(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
2.andThen的使用
假设你不仅想遍历一个整数列表，又想让它以偶数的方式输出，请看下面的栗子
private static void forEachAndEven(List<Integer> list,Consumer<Integer> c1,Consumer<Integer> c2) {
for (Integer num : list) {
c1.andThen(c2).accept(num);
}
}
forEachAndEven(list,num -> {num = num * 2;},num -> System.out.println("num = " + num));
可能你会提问，我直接在遍历的时候修改其值，不就好了嘛，其实我只是举了个简单的栗子，各位小伙伴在业务开发要多想，学会举一反三，达到灵活应用
2.3 Function的使用
Function方法如下
R apply(T t);
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
static <T> Function<T, T> identity() {
return t -> t;
}
1.apply方法的使用
apply方法接收一个泛型T对象，并返回一个泛型R的对象。比如你想提取苹果的重量，或者把字符串映射为它的长度，就可以使用它
public static <T,R> List<R> map(List<T> list, Function<T,R> f){
ArrayList<R> result = new ArrayList<>();
for (T t : list) {
result.add(f.apply(t));
}
return result;
}
List<Integer> res = map(Arrays.asList("asds","sds","sd"),s -> s.length());
2.andThen、compose和identity的使用
andThen和compose都是把Lambda表达式复合起来，并返回Function的一个实例，但它们也有区别，先让我给大家举个栗子，从栗子中发现二者的区别吧。假设有一个函数f给数字1，另一个函数给数字乘2，现在让你把它们组合成一个函数h,先给数字加1，再给结果乘2。
使用andThen实现
Function<Integer,Integer> f = x -> x + 1;
Function<Integer,Integer> g = x -> x * 2;
Function<Integer,Integer> h = f.andThen(g);
int result = h.apply(1);
使用compose实现
Function<Integer,Integer> f = x -> x + 1;
Function<Integer,Integer> g = x -> x * 2;
Function<Integer,Integer> h = g.compose(f);
int result = h.apply(1);
伙伴们，发现区别嘛？不细心的读者肯定不会发现的。andThen和compose都能实现函数的复合，使用起来却截然相反，不过g.compose(f) 类似于数学上的g(f(x))
注意：Function.identity()返回一个输出跟输入一样的Lambda表达式对象，等价于形如t->t 形式的Lambda表达式，由于比较简单，故不再介绍。
2.4 Supplier的使用
Supplier的方法如下
T get();
get方法的使用
用来获取一个泛型参数指定类型的对象数据，请看如下例子
Supplier<Apple> c = Apple::new;
Apple apple = c.get();
2.5 Comparator的使用
Comparator非常重要，方法如下
int compare(T o1, T o2);
boolean equals(Object obj);
default Comparator<T> reversed() {
return Collections.reverseOrder(this);
}
default Comparator<T> thenComparing(Comparator<? super T> other) {
Objects.requireNonNull(other);
return (Comparator<T> & Serializable) (c1, c2) -> {
int res = compare(c1, c2);
return (res != 0) ? res : other.compare(c1, c2);
};
}
default <U> Comparator<T> thenComparing(
Function<? super T, ? extends U> keyExtractor,
Comparator<? super U> keyComparator)
{
return thenComparing(comparing(keyExtractor, keyComparator));
}
default <U extends Comparable<? super U>> Comparator<T> thenComparing(
Function<? super T, ? extends U> keyExtractor)
{
return thenComparing(comparing(keyExtractor));
}
default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {
return thenComparing(comparingInt(keyExtractor));
}
default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {
return thenComparing(comparingLong(keyExtractor));
}
default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {
return thenComparing(comparingDouble(keyExtractor));
}
public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
return Collections.reverseOrder();
}
public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
}
public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
return new Comparators.NullComparator<>(true, comparator);
}
public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
return new Comparators.NullComparator<>(false, comparator);
}
public static <T, U> Comparator<T> comparing(
Function<? super T, ? extends U> keyExtractor,
Comparator<? super U> keyComparator)
{
Objects.requireNonNull(keyExtractor);
Objects.requireNonNull(keyComparator);
return (Comparator<T> & Serializable)
(c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
keyExtractor.apply(c2));
}
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));
}
public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
}
public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));
}
public static<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));
}
给你一筐苹果，让你按照苹果的重量由小到大的顺序排序，你能想到几种方式呢？请看如下栗子
//方式一
Comparator<Apple> c1 = (Apple a1, Apple a2) -> a1.getWeight() - a2.getWeight();
//方式二
Comparator<Apple> c2 = Comparator.comparingInt(Apple::getWeight);
//方式三
Comparator<Apple> c3 = Comparator.comparing(Apple::getWeight);
//方式四
Comparator c4 = Comparator.naturalOrder();
apples.sort(c1);
这四种方式你喜欢用那种呢？你可能会说，用方式四，因为简单。可以抱歉，方式四需要比较对象实现Comparable接口，重写compareTo方法，因此这种方式适合那些已经实现Comparable接口的类，比如Integer等，当比较基本数据类型时，推荐使用第二种，因为这种方式避免装箱操作。
想一想如何按照苹果的重量由大到小排序呢？请看如下栗子
//方式一
Comparator<Apple> c1 = (Apple a1, Apple a2) -> a2.getWeight() - a1.getWeight();
//方式二
Comparator<Apple> c2 = Comparator.comparingInt(Apple::getWeight).reversed();
//方式三
Comparator<Apple> c3 = Comparator.comparing(Apple::getWeight).reversed();
//方式四
Comparator c4 = Comparator.reverseOrder();
伙伴们可能提问，如果苹果一样重该咋办呢?你可能会说再提供一个比较器就好啦，其实完全没必然，因为Comparator接口还提供了一个方法thenComparing，它可以轻而易举地解决你的问题
inventory.sort(Comparator.comparing(Apple::getWeight).reversed().thenComparing(Apple::getCountry));
一行代码搞定既能按照苹果重量排序，又能按照国家排序，多么优雅，这才是人上人的玩法
2.6 BinaryOperator的使用
BinaryOperator接口的方法如下，没有列出继承BiFunction接口的方法
public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
Objects.requireNonNull(comparator);
return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
}
public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
Objects.requireNonNull(comparator);
return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
}
minBy和maxBy可以获得集合中的最大值或者最小值
BinaryOperator<Integer> bi = BinaryOperator.minBy(Comparator.naturalOrder());
System.out.println(bi.apply(2, 3));
这个例子来源于网上，不过这两个方法在介绍流会使用的
3.总结
看到这里，读者可能会问，还有几个接口没讲，其实我虽然讲了一部分，但是各位小伙伴必须学会举一反三，其他几个接口都类似，故不再赘述。本文的内容是借鉴《Java 8实战》这本书的，这本书除了讲了Lambda表达式的使用，还讲解了流的使用，这个才是重中之重，后面有时间我会更新流的内容，强烈推荐有兴趣的小伙伴读一下《Java 8实战》，对于开发写代码很有帮助。
