文档章节

一起来学Java8(四)——复合Lambda

猿敲月下码
 猿敲月下码
发布于 10/23 12:42
字数 1221
阅读 61
收藏 3

一起来学Java8(二)——Lambda表达式中我们学习了Lambda表达式的基本用法,现在来了解下复合Lambda。

Lambda表达式的的书写离不开函数式接口,复合Lambda的意思是在使用Lambda表达式实现函数式接口抽象方法后,还可以再次调用接口的其它方法,因为从Java8开始,接口中可以包含默认实现的方法。关于接口默认实现方法将会在后面章节详细阐述。

常见的复合Lambda常见的有以下几类:

  • 比较器复合,对应的函数式接口:Comparator
  • 谓词复合,对应的函数式接口:Predicate
  • 函数复合,对应的函数式接口:Function

比较器复合

先来看下Comparator接口的常见用法,针对商品价格从低到高排序

package learn.java8.ch4;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

class Goods {
	private String name;
	private int price;

	public Goods(String name, int price) {
		super();
		this.name = name;
		this.price = price;
	}

    省略get set
}

public class ComparatorTest {

	public static void main(String[] args) {
		List<Goods> list = Arrays.asList(
				new Goods("mete30", 3999),
				new Goods("mete30 pro", 4999),
				new Goods("redmi k20", 2999),
				new Goods("iqoo", 2999),
				new Goods("iphone11", 5000)
				);
		
		Comparator<Goods> comparatorForPrice = (Goods goods1, Goods goods2) -> {
			return Integer.compare(goods1.getPrice(), goods2.getPrice());
		};
		list.sort(comparatorForPrice);
		System.out.println(list);
	}
}

这里是根据价格从低到高排序,我们可以再加一个需求,如果价格一样,再根据商品名称排序。那么代码可以这样写:

public static void main(String[] args) {
		List<Goods> list = Arrays.asList(new Goods("mete30", 3999), new Goods("mete30 pro", 4999),
				new Goods("redmi k20", 2999), new Goods("iqoo", 2999), new Goods("iphone11", 5000));

		Comparator<Goods> comparatorForPrice = (Goods goods1, Goods goods2) -> {
			return Integer.compare(goods1.getPrice(), goods2.getPrice());
		};

		Comparator<Goods> comparatorForName = (Goods goods1, Goods goods2) -> {
			return goods1.getName().compareTo(goods2.getName());
		};
		
		// 把两个函数式接口进行复合,组成一个新的接口
		Comparator<Goods> finalComparator = comparatorForPrice.thenComparing(comparatorForName);
		list.sort(finalComparator);
		System.out.println(list);
	}

上面的例子中 Comparator<Goods> finalComparator = comparatorForPrice.thenComparing(comparatorForName);就是复合Lambda表达式的体现。其中thenComparing()方法是Comparator接口的一个默认实现方法。

谓词复合

谓词复合,即使用谓词函接口来实现,谓词接口定义如下:

@FunctionalInterface
public interface Predicate<T> {
  
    // 抽象接口,判断是否为真
    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);
    }
}

下面来看下具体的例子:

package learn.java8.ch4;

import java.util.function.Predicate;

public class PredicateTest2 {
	static class Goods {
		private String name;
		// 价格
		private int price;
		// 库存
		private int storeCount;

		public Goods(String name, int price, int storeCount) {
			super();
			this.name = name;
			this.price = price;
			this.storeCount = storeCount;
		}
	}

	public static void main(String[] args) {
		Goods mete30pro = new Goods("mete30 pro", 4999, 111);
		Goods iphone11 = new Goods("iphone11", 5000, 444);

		Predicate<Goods> predicate = (goods) -> goods.price > 4000;

		System.out.println("mete30pro价格是否大于4000:" + predicate.test(mete30pro));

		Predicate<Goods> predicatePrice = (goods) -> goods.price > 6000;
		Predicate<Goods> predicateStore = (goods) -> goods.storeCount > 400;
		// 价格大于6000或库存大于400
		Predicate<Goods> predicateOr = predicatePrice.or(predicateStore);
		System.out.println("价格大于6000或库存大于400:" + predicateOr.test(iphone11));
	}

}

函数复合

函数复合使用java.util.function.Function函数式接口中来实现。

Function接口定义如下:

// 两个泛型参数,T表示入参类型,R表示返回类型
@FunctionalInterface
public interface Function<T, R> {

    // 抽象方法
    R apply(T t);

    // 默认实现方法,先执行before,将结果带入当前apply方法中执行
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    // 按顺序执行,先执行当前apply函数,再执行指定的after.apply函数
    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;
    }
}

从代码上看很容易就能看懂,接下来列举几个简单例子,首先来看下andThen方法的使用:

private static void test1() {
    Function<Integer, Integer> funMultiply = (input) -> input * 2;
    Function<Integer, Integer> funMinus = (input) -> input - 1;
    // input * 2 - 1
    Function<Integer, Integer> finalFun = funMultiply.andThen(funMinus);

    Integer result = finalFun.apply(2);
    System.out.println(result); // 3
}

这个例子中定义两个函数,一个对参数做乘法操作然后返回,一个对参数做减法操作然后返回。接着使用andThen方法把两个函数串联起来。用数学公式表示即为:2 * 2 - 1

接下来是compose例子:

private static void test2() {
    Function<Integer, Integer> funMultiply = (input) -> input * 2;
    Function<Integer, Integer> funMinus = (input) -> input - 1;

    // (input - 1) * 2
    Function<Integer, Integer> finalFun = funMultiply.compose(funMinus);

    Integer result = finalFun.apply(2);
    System.out.println(result); // 2
}

这里是先执行减法,得到的结果传入,再执行乘法操作。用数学公式表示即为:(2 - 1) * 2

定期分享技术干货,一起学习,一起进步!

© 著作权归作者所有

猿敲月下码

猿敲月下码

粉丝 49
博文 36
码字总数 34448
作品 4
杭州
高级程序员
私信 提问
【java8】java新特性(一)——全局观

一、前言 年前的时候 ,我一个师姐出去工作,被鄙视了。说写的代码太垃圾。当时我也没有在意,回头想想自己,本以为自己写的代码天衣无缝,无可挑剔。但是自从自己遇到了Java8 后,我的世界观...

kisscatforever
2018/03/15
0
0
【java8】java新特性(二)——lambda表达式

一,前言 在上一篇博客中,小编向大家抛转引玉,简单说明了[ Java8 ](http://blog.csdn.net/kisscatforever/article/details/79572194 ),其实Java 8在2014年3月18日,就发布了。可以说程序...

kisscatforever
2018/03/20
0
0
Java8-初识Lambda

廉颇老矣,尚能饭否 Java,这位已经20多岁的编程语言,称得上是编程语言界的老大哥了。他曾经攻城略地,碾压各路编程语言小弟,风光无限,不可一世。现在,也是家大业大,江湖地位,很难撼动...

Jackie_Zheng
2017/09/17
0
0
Java8实战 — 引入流

流是什么 流是Java API的新成员,它允许你以声明的方式处理数据集合,简单来说,可以把它当作数据集的高级迭代器。此外,流还可以透明地并行处理,你无需写任何多线程代码了。 举个例子来说明...

杰克鹏仔
2016/12/27
50
0
一起来学Java8(二)——Lambda表达式

Lambda简介 什么是Lambda表达式,简单的说是一种匿名函数表达方式。因此Lambda表达式本质是个函数,只不过没有函数名称。 Lambda表达式具有以下特点: 匿名,它没有函数名称 本质是个函数,除...

猿敲月下码
10/21
30
0

没有更多内容

加载失败,请刷新页面

加载更多

BigDecimal 去后面无用的0的方法

BigDecimal a=new BigDecimal("0.1000"); System.out.println(a.stripTrailingZeros().toPlainString());...

xiaodong16
33分钟前
5
0
JAVA--高级基础开发

[集合版双色球] 十二、双色球规则:双色球每注投注号码由6个红色球号码和1个蓝色球号码组成。红色球号码从1—33中选择;蓝色球号码从1—16中选择;请随机生成一注双色球号码。(要求同色号码...

李文杰-yaya
昨天
16
0
聊聊rocketmq broker的CONSUMER_SEND_MSG_BACK

序 本文主要研究一下rocketmq broker的CONSUMER_SEND_MSG_BACK CONSUMER_SEND_MSG_BACK rocketmq/common/src/main/java/org/apache/rocketmq/common/protocol/RequestCode.java public class......

go4it
昨天
3
0
API常见接口(下)

system类 StringBuilder和StringBuffer 包装类 1.System类 (java.lang包中) 提供了大量的静态方法,可以获取与系统相关的信息或系统级操作。 常用方法: public static long currentTimeMi...

Firefly-
昨天
4
0
MySQL系列:一句SQL,MySQL是怎么工作的?

对于MySQL而言,其实分为客户端与服务端。 服务端,就是MySQL应用,当我们使用net start mysql命令启动的服务,其实就是启动了MySQL的服务端。 客户端,负责发送请求到服务端并从服务端获取数...

杨小格子
昨天
5
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部