目录
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实战》,对于开发写代码很有帮助。