Java开发笔记（七十）Java8新增的几种泛型接口
2019-03-12 08:23:26来源：博客园 阅读 ()
由于泛型存在某种不确定的类型，因此很少直接运用于拿来即用的泛型类，它更经常以泛型接口的面目出现。例如几种基本的容器类型Set、Map、List都被定义为接口interface，像HashSet、TreeMap、LinkedList等等只是实现了对应容器接口的具体类罢了。泛型的用途各式各样，近的不说，远的如数组工具Arrays的sort方法，它在排序时用到的比较器Comparator就是个泛型接口。别看Comparator.java的源码洋洋洒洒数百行，其实它的精华部分仅仅下列寥寥数行：
//数组排序需要的比较器主要代码，可见它是个泛型接口
public interface Comparator<T> {
int compare(T o1, T o2);
}
当然系统提供的泛型接口不止是Comparator一个，从Java8开始，又新增了好几个系统自带的泛型接口，它们的适用范围各有千秋，接下来便分别加以介绍。
1、断言接口Predicate
之前介绍方法引用的时候，要求从一个字符串数组中挑选出符合条件的元素生成新数组，为此定义一个过滤器接口StringFilter，该接口声明了字符串匹配方法isMatch，然后再利用该过滤器编写字符串数组的筛选方法，进而由外部通过Lambda表达式或者方法引用来进行过滤。可是StringFilter这个过滤器只能用于筛选字符串，不能用来筛选其它数据类型。若想让它支持所有类型的数据筛选，势必要把数据类型空泛化，Java8推出的断言接口Predicate正是这种用于匹配校验的泛型接口。
在详细说明Predicate之前，先定义一个苹果类Apple，本文的几个泛型接口都准备拿苹果类练手，它的类定义代码如下所示：
//定义一个苹果类
public class Apple {
private String name; // 名称
private String color; // 颜色
private Double weight; // 重量
private Double price; // 价格
public Apple(String name, String color, Double weight, Double price) {
this.name = name;
this.color = color;
this.weight = weight;
this.price = price;
}
// 为节省篇幅，此处省略每个成员属性的get/set方法
// 获取该苹果的详细描述文字
public String toString() {
return String.format("\n(name=%s,color=%s,weight=%f,price=%f)", name,
color, weight, price);
}
// 判断是否红苹果
public boolean isRedApple() {
return this.color.toLowerCase().equals("red");
}
}
接着构建一个填入若干苹果信息的初始清单，几种泛型接口准备对苹果清单磨刀霍霍，清单数据的构建代码示例如下：
// 获取默认的苹果清单
private static List<Apple> getAppleList() {
// 数组工具Arrays的asList方法可以把一系列元素直接赋值给清单对象
List<Apple> appleList = Arrays.asList(
new Apple("红苹果", "RED", 150d, 10d),
new Apple("大苹果", "green", 250d, 10d),
new Apple("红苹果", "red", 300d, 10d),
new Apple("大苹果", "yellow", 200d, 10d),
new Apple("红苹果", "green", 100d, 10d),
new Apple("大苹果", "Red", 250d, 10d));
return appleList;
}
然后当前的主角——断言接口终于登场了，别看“断言”二字似乎很吓人，其实它的关键代码也只有以下几行，真正有用的就是校验方法test：
public interface Predicate<T> {
boolean test(T t);
}
再定义一个清单过滤的泛型方法，输入原始清单和断言实例，输出筛选后符合条件的新清单。过滤方法的处理逻辑很简单，仅仅要求遍历清单的所有元素，一旦通过断言实例的test方法检验，就把该元素添加到新的清单。具体的过滤代码如下所示：
// 利用系统自带的断言接口Predicate，对某个清单里的元素进行过滤
private static <T> List<T> filterByPredicate(List<T> list, Predicate<T> p) {
List<T> result = new ArrayList<T>();
for (T t : list) {
if (p.test(t)) { // 如果满足断言的测试条件，则把该元素添加到新的清单
result.add(t);
}
}
return result;
}
终于轮到外部调用刚才的过滤方法了，现在要求从原始的苹果清单中挑出所有的红苹果，为了更直观地理解泛型接口的运用，先通过匿名内部类方式来表达Predicate实例。此时的调用代码是下面这样的：
// 测试系统自带的断言接口Predicate
private static void testPredicate() {
List<Apple> appleList = getAppleList();
// 第一种调用方式：匿名内部类实现Predicate。挑出所有的红苹果
List<Apple> redAppleList = filterByPredicate(appleList, new Predicate<Apple>() {
@Override
public boolean test(Apple t) {
return t.isRedApple();
}
});
System.out.println("红苹果清单：" + redAppleList.toString());
}
运行上述的测试代码，从输出的日志信息可知，通过断言接口正确筛选到了红苹果清单：
红苹果清单：[ (name=红苹果,color=RED,weight=150.000000,price=10.000000), (name=红苹果,color=red,weight=300.000000,price=10.000000), (name=大苹果,color=Red,weight=250.000000,price=10.000000)]
显然匿名内部类的实现代码过于冗长，改写为Lambda表达式的话仅有以下一行代码：
// 第二种调用方式：Lambda表达式实现Predicate List<Apple> redAppleList = filterByPredicate(appleList, t -> t.isRedApple());
或者采取方法引用的形式，也只需下列的一行代码：
// 第三种调用方式：通过方法引用实现Predicate List<Apple> redAppleList = filterByPredicate(appleList, Apple::isRedApple);
除了挑选红苹果，还可以挑选大个的苹果，比如要挑出所有重量大于半斤的苹果，则采取Lambda表达式的的调用代码见下：
// Lambda表达式实现Predicate。挑出所有重量大于半斤的苹果
List<Apple> heavyAppleList = filterByPredicate(appleList, t -> t.getWeight() >= 250);
System.out.println("重苹果清单：" + heavyAppleList.toString());
以上的代码演示结果，充分说明了断言接口完全适用于过滤判断及筛选操作。
2、消费接口Consumer
断言接口只进行逻辑判断，不涉及到数据修改，若要修改清单里的元素，就用到了另一个消费接口Consumer。譬如下馆子消费，把肚子撑大了；又如去超市消费，手上多了装满商品的购物袋；因此消费行为理应伴随着某些属性的变更，变大或变小，变多或变少。Consumer同样属于泛型接口，它的核心代码也只有以下区区几行：
public interface Consumer<T> {
void accept(T t);
}
接着将消费接口作用于清单对象，意图修改清单元素的某些属性，那么得定义泛型方法modifyByConsumer，根据输入的清单数据和消费实例，从而对清单执行指定的消费行为。详细的修改方法示例如下：
// 利用系统自带的消费接口Consumer，对某个清单里的元素进行修改
private static <T> void modifyByConsumer(List<T> list, Consumer<T> c) {
for (T t : list) {
// 根据输入的消费指令接受变更，所谓消费，通俗地说，就是女人花钱打扮自己。
// 下面的t既是输入参数，又允许修改。
c.accept(t); // 如果t是String类型，那么accept方法不能真正修改字符串
}
}
消费行为仍然拿苹果清单小试牛刀，外部调用modifyByConsumer方法之时，传入的消费实例要给苹果名称加上“好吃”二字。下面便是具体的调用代码例子，其中一块列出了匿名内部类与Lambda表达式这两种写法：
// 测试系统自带的消费接口Consumer
private static void testConsumer() {
List<Apple> appleList = getAppleList();
// 第一种调用方式：匿名内部类实现Consumer。在苹果名称后面加上“好吃”二字
modifyByConsumer(appleList, new Consumer<Apple>() {
@Override
public void accept(Apple t) {
t.setName(t.getName() + "好吃");
}
});
// 第二种调用方式：Lambda表达式实现Consumer
modifyByConsumer(appleList, t -> t.setName(t.getName() + "好吃"));
System.out.println("好吃的苹果清单" + appleList.toString());
}
运行上面的调用代码，可见输入的日志记录果然给苹果名称补充了两遍“好吃”：
好吃的苹果清单[ (name=红苹果好吃好吃,color=RED,weight=150.000000,price=10.000000), (name=大苹果好吃好吃,color=green,weight=250.000000,price=10.000000), (name=红苹果好吃好吃,color=red,weight=300.000000,price=10.000000), (name=大苹果好吃好吃,color=yellow,weight=200.000000,price=10.000000), (name=红苹果好吃好吃,color=green,weight=100.000000,price=10.000000), (name=大苹果好吃好吃,color=Red,weight=250.000000,price=10.000000)]
不过单独使用消费接口的话，只能把清单里的每个元素全部修改过去，不加甄别的做法显然太粗暴了。更好的办法是挑出符合条件的元素再做变更，如此一来就得联合运用断言接口与消费接口，先通过断言接口Predicate筛选目标元素，再通过消费接口Consumer处理目标元素。于是结合两种泛型接口的泛型方法就变成了以下这般代码：
// 联合运用Predicate和Consumer，可筛选出某些元素并给它们整容
private static <T> void selectAndModify(List<T> list, Predicate<T> p, Consumer<T> c) {
for (T t : list) {
if (p.test(t)) { // 如果满足断言的条件要求，
c.accept(t); // 就把该元素送去美容院整容。
}
}
}
针对特定的记录再作调整，正是实际业务场景中的常见做法。比如现有一堆苹果，因为每个苹果的质量参差不齐，所以要对苹果分类定价。一般的苹果每公斤卖10块钱，如果是红彤彤的苹果，则单价提高50%；如果苹果个头很大（重量大于半斤），则单价也提高50%；又红又大的苹果想都不要想肯定特别吃香，算下来它的单价足足是一般苹果的1.5*1.5=2.25倍了。那么调整苹果定价的代码逻辑就得先后调用两次selectAndModify方法，第一次用来调整红苹果的价格，第二次用来调整大苹果的价格，完整的价格调整代码如下所示：
// 联合测试断言接口Predicate和消费接口Consumer
private static void testPredicateAndConsumer() {
List<Apple> appleList = getAppleList();
// 如果是红苹果，就涨价五成
selectAndModify(appleList, t -> t.isRedApple(), t -> t.setPrice(t.getPrice() * 1.5));
// 如果重量大于半斤，再涨价五成
selectAndModify(appleList, t -> t.getWeight() >= 250, t -> t.setPrice(t.getPrice() * 1.5));
System.out.println("涨价后的苹果清单：" + appleList.toString());
}
运行以上的价格调整代码，从以下输出的日志结果可知，每个苹果的单价都经过计算重新改过了：
涨价后的苹果清单：[ (name=红苹果,color=RED,weight=150.000000,price=15.000000), (name=大苹果,color=green,weight=250.000000,price=15.000000), (name=红苹果,color=red,weight=300.000000,price=22.500000), (name=大苹果,color=yellow,weight=200.000000,price=10.000000), (name=红苹果,color=green,weight=100.000000,price=10.000000), (name=大苹果,color=Red,weight=250.000000,price=22.500000)]
3、函数接口Function
刚才联合断言接口和消费接口，顺利实现了修改部分元素的功能，然而这种做法存在问题，就是直接在原清单上面进行修改，一方面破坏了原始数据，另一方面仍未抽取到新清单。于是Java又设计了泛型的函数接口Function，且看它的泛型接口定义代码：
public interface Function<T, R> {
R apply(T t);
}
从Function的定义代码可知，该接口不但支持输入某个泛型变量，也支持返回另一个泛型变量。这样的话，把输入参数同输出参数区分开，就避免了二者的数据处理操作发生干扰。据此可编写新的泛型方法recycleByFunction，该方法输入原始清单和函数实例，输出处理后的新清单，从而满足了数据抽取的功能需求。详细的方法代码示例如下：
// 利用系统自带的函数接口Function，把所有元素进行处理后加到新的清单里面
private static <T, R> List<R> recycleByFunction(List<T> list, Function<T, R> f) {
List<R> result = new ArrayList<R>();
for (T t : list) {
R r = f.apply(t); // 把原始材料t加工一番后输出成品r
result.add(r); // 把成品r添加到新的清单
}
return result;
}
接下来由外部去调用新定义的recycleByFunction方法，照旧采取匿名内部类与Lambda表达式同时进行编码，轮番对红苹果和大苹果涨价，修改后的调用代码例子见下：
// 测试系统自带的函数接口Function
private static void testFunction() {
List<Apple> appleList = getAppleList();
List<Apple> appleRecentList;
// 第一种调用方式：匿名内部类实现Function。把涨价后的苹果放到新的清单之中
appleRecentList = recycleByFunction(appleList,
new Function<Apple, Apple>() {
@Override
public Apple apply(Apple t) {
Apple apple = new Apple(t.getName(), t.getColor(), t.getWeight(), t.getPrice());
if (apple.isRedApple()) { // 如果是红苹果，就涨价五成
apple.setPrice(apple.getPrice() * 1.5);
}
if (apple.getWeight() >= 250) { // 如果重量大于半斤，再涨价五成
apple.setPrice(apple.getPrice() * 1.5);
}
return apple;
}
});
// 第二种调用方式：Lambda表达式实现Function
appleRecentList = recycleByFunction(appleList, t -> {
Apple apple = new Apple(t.getName(), t.getColor(), t.getWeight(), t.getPrice());
if (apple.isRedApple()) { // 如果是红苹果，就涨价五成
apple.setPrice(apple.getPrice() * 1.5);
}
if (apple.getWeight() >= 250) { // 如果重量大于半斤，再涨价五成
apple.setPrice(apple.getPrice() * 1.5);
}
return apple;
});
System.out.println("涨价后的新苹果清单：" + appleRecentList.toString());
}
注意到上面的例子代码中，函数接口的入参类型为Apple，而出参类型也为Apple。假设出参类型不是Apple，而是别的类型如String，那该当若何？其实很简单，只要函数接口的返回参数改成其它类型就好了。譬如现在无需返回苹果的完整清单，只需返回苹果的名称清单，则调用代码可调整为下面这样：
// 返回的清单类型可能与原清单类型不同，比如只返回苹果名称
List<String> colorList = recycleByFunction(appleList,
t -> t.getName() + "(" + t.getColor() + ")");
System.out.println("带颜色的苹果名称清单：" + colorList.toString());
运行以上的调整代码，果然打印了如下的苹果名称清单日志：
带颜色的苹果名称清单：[红苹果(RED), 大苹果(green), 红苹果(red), 大苹果(yellow), 红苹果(green), 大苹果(Red)]
更多Java技术文章参见《Java开发笔记（序）章节目录》
原文链接:https://www.cnblogs.com/pinlantu/p/10513444.html
如有疑问请与原作者联系
标签：
版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有
上一篇：ssm实现查看流程图
- 国外程序员整理的Java资源大全（全部是干货） 2020-06-12
- 2020年深圳中国平安各部门Java中级面试真题合集（附答案） 2020-06-11
- 2020年java就业前景 2020-06-11
- 04.Java基础语法 2020-06-11
- Java--反射(框架设计的灵魂)案例 2020-06-11
IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设
网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源
网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它
服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护
软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷
网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash
