JDK1.8 Consumer Supplier 什么意思

JDK1.8 函数式接口 Consumer & Supplier 以及 JAVA新纪元 λ表达式的到来

背景什么的被吞了,直接进入主题

函数式接口(定义自己百度,一大堆)

因为看了一些关于JDK1.8函数式接口的文章,发现基本上都是糊里糊涂一笔带过.所以就抽空赶紧整理了一下.

还是附上几个学习了解的传送门 :

菜鸟教程
易百教程
汇智网

Consumer 函数式接口

JDK 源码

/*** 接受单个输入参数并且不返回结果的操作。* 与大多数其他功能接口不同， Consumer预期通过副作用进行操作。** @since 1.8*/
@FunctionalInterface
public interface Consumer<T> {/*** 对给定的参数执行此操作。** @param t the input argument*/void accept(T t);/*** 返回一个组合的Consumer ，依次执行此操作，然后执行after操作。 * 如果执行任一操作会抛出异常，它将被转发到组合操作的调用者。 * 如果执行此操作会引发异常，则不会执行after操作。** @param 此操作后执行的操作* @return 一个组成的 Consumer ，依次执行 after操作* @throws NullPointerException - if after is null*/default Consumer<T> andThen(Consumer<? super T> after) {Objects.requireNonNull(after);return (T t) -> { accept(t); after.accept(t); };}

刚拿过来看的时候可能会有一些绕,但是我们换个角度来看一下.

Consumer 直译过来就是消费者的意思,那我们是不是可以理解成消费代码.既然他要消费,那我们就要给他提供代码.

来看一个简单的demo

public void testConsumer1() {Consumer<String> consumer = new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s + "?");}};consumer.accept("李磊");}

输出结果

李磊?

简单解释一下

Consumer是一个接口,所以当我们直接使用的话,要实现其 accept()方法,而这个方法的参数,就是我们定义接口时候给到的泛型,这里给的是一个String类型,方法当中的内容,就是我们所谓的消费代码,当调用accept()方法时执行.

注意 : 也就是上面提到的通过副作用处理,我不清楚这个单词翻译的是否准确,看了很多博主和一些机器翻译都是这个意思,但我个人的理解意思,更趋近于说是通过侧面来解决问题.

再看一下 consumer.accept("李磊")这一句,这里便是真正的执行的地方,也就是调用的我们刚刚自行实现的accept()方法.

让我们继续刚刚的demo往下看

这种写法和上面在JDK1.8环境中是等价的. 主要就是利用到了1.8中的 λ 表达式.

    public void testConsumer1() {Consumer<String> consumer = s -> System.out.println(s + "?");consumer.accept("李磊");}

下面的例子均使用λ表达式完成

泛型为自定义对象时

public void testConsumerToSupplier() {Consumer<Person> consumer = person -> {person.setName("张颖");person.setSize(34);};Person person = new Person();consumer.accept(person);System.out.println("person = " + person);}

输入结果:

person = Person{name='张颖', size=34}

泛型为自定义接口时

public interface People {void come(Person person);
}

public void testConsumerAndInterfaceFunction() {Consumer<People> consumer = people -> {people.come(new Person("李四", 23));people.come(new Person("找钱", 34));people.come(new Person("孙俪", 45));};consumer.accept(this::print);}public void print(Person person) {System.out.println("person = " + person);}

输出结果

person = Person{name='李四', size=23}
person = Person{name='找钱', size=34}
person = Person{name='孙俪', size=45}

如果到了这里还没有明白怎么回事,我建议你亲自动手敲上那么一遍.真的,如果还不懂来杭州,我当面给你讲.

Supplier 函数式接口

还是一样,先看一下JDK源码

/*** 获得对象的一个函数式接口** @since 1.8*/
@FunctionalInterface
public interface Supplier<T> {/*** 得到一个对象** @return 目标对象*/T get();
}

这个是不是看起来很容易理解了,Supplier的意思是供应商,那我们是不是可以把他理解成一个商场,然后你告诉他你想要的东西是什么样子的,它是不是就会给你了.

来看一下这个简单的demo

void testSupplier1() {Supplier<String> supplier = () -> "这是你要的字符串";String str = supplier.get();System.out.println("str = " + str);}

运行结果:

str = 这是你要的字符串

继续自定义对象

void testSupplier2() {Supplier<Person> supplier = () -> {Person person = new Person();person.setName("张三");person.setSize(32);return person;};Person person = supplier.get();System.out.println("person = " + person);}

运行结果

person = Person{name='张三', size=32}

再来刺激的自定义接口

    void testSupplier3() {Supplier<People> supplier = new Supplier<People>() {@Overridepublic People get() {People people = new People() {@Overridepublic void come(Person person) {System.out.println("person = " + person)}};return people;}};People people = supplier.get();people.come(new Person("李四", 24));}

输出结果

person = Person{name='李四', size=24}

看好别眨眼,λ表达式的写法 下面的一行和上面的一堆是等价的

void testSupplier4() {Supplier<People> supplier = () -> person -> System.out.println("person = " + person);People people = supplier.get();people.come(new Person("李四", 24));
}

输出结果

person = Person{name='李四', size=24}

想必看到这你不光明白了 Supplier的用法,更清楚的λ表达式的用处了.

写在最后,写这篇文章的原因是因为在整理工厂模式的时候遇到的一些问题

工厂模式简单的是不能再简单了,但是随着技术的发展,也出现了一些新颖的工厂方法.CTS便是其中之一.

至于Consumer&Supplier应用在工厂模式的代码如下,因为比较特殊,写在了一起,想要亲自体检复制粘贴运行TTT类的main()方法即可

/*** @author lvgo* @version 1.0* @Description: CTS实现工厂模式* @date 18-8-24 下午3:57*/
public interface CTS {static CTS getCts(Consumer<Peoples> consumer) {Map<String, Supplier<Persons>> map = new HashMap<>();consumer.accept(map::put);return person -> map.get(person).get();}Persons getPerson(String name);
}interface Peoples {void come(String name, Supplier<Persons> personSupplier);
}class TTT {public static void main(String[] args) {CTS cts = CTS.getCts(people -> {people.come("张三", () -> new Persons("张三"));people.come("李四", () -> new Persons("李四"));people.come("王五", () -> new Persons("王五"));});Persons person = cts.getPerson("王五");System.out.println("persons = " + person);}
}class Persons {private String name;public Persons() {}public Persons(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Person{" +"name='" + name + "'}'";}
}

CTS工厂模式说明: Consumer To Supplier 自造词,无处可寻,他处偶遇纯属抄袭;

通过Peoples接口的come()方法,可以动态在CTS工厂内添加person,然后使其具于生产该实例的能力.

本文所有源代码点我
更多设计模式学习点我或浏览博客设计模式专栏查看

参考文献

Design Patterns: Elements of Reusable Object-Oriented Software 1st Edition