我们这里演示函数式接口和Lambda表达式的应用。简单来说函数式接口就是只有一个抽象方法的接口，Java提供了几种常用的函数式接口
有参数 返回值是boolean类型
public interface Predicate<T> {
boolean test(T t);
}
以下都没有使用泛型，采用了具体的String类型
//将长度大于10的字符串筛选出来
private List<String> filter(List<String> items) {
List<String> result = new ArrayList<>();
for (String item : items) {
if (item.length()>10) {
result.add(item);
}
}
return result;
}
发现这个里面关键的判断方法可以用上面接口的方法,于是改成这样
private List<String> filter(List<String> items, Predicate<String> predicate) {
List<String> result = new ArrayList<>();
for (String item : items) {
if (predicate.test(item)) {
result.add(item);
}
}
return result;
}
//实现函数式接口，使用接口的好处是数据和业务逻辑分离了，筛选结果取决于外部的判断方法
Predicate<String> predicate=new Predicate<String>() {
@Override
public boolean test(String s) {
return s.length()>10;
}
};
有了Lambda表达式，上面的实现就显得啰嗦，引用Java 8实战的一个定义：
Lambda表达式允许你用内联的方式为函数式接口提供实现，并把整个表达式作为实例，
函数式接口的抽象方法的签名基本上就是Lambda表达式的签名。重点就是方法签名要兼容
//右边表达式要满足接受一个参数并返回boolean类型值
Predicate<String> predicate= s -> s.length()>10;
于是，下面就体现了Lambda表达式实现函数式接口的简洁、方便，复用性强
List<String> names = Arrays.asList("one", "two", "three", "four");
List<String> strings = filter(names, s -> s.length() > 10);
List<String> strings = filter(names, s -> s.length()!=3);
再看看Consumer消费者
接受一个参数，没有返回值，这个名字起的很形象
public interface Consumer<T> {
void accept(T t);
}
private List<String> consume(List<String> items, Consumer<String> consumer) {
List<String> result = new ArrayList<>();
for (String item : items) {
//由接口决定如何处理
consumer.accept(item)
}
return result;
}
//接口实现，转成大写再打印
Consumer<String> consumer=new Consumer<String>() {
@Override
public void accept(String s) {
//具体怎么消费就看这个方法的实现
System.out.println(s.toUpperCase());
}
};
//使用Lambda表达式
Consumer<String> consumer= s -> System.out.println(s.toUpperCase());
试试Function。
与Predicate类似，不过返回类型是指定的，它是一种类型到另一种类型的转化
public interface Function<I, O> {
O apply(I input);
}
private List<Integer> map(List<String> names, Function<String, Integer> function) {
List<Integer> result = new ArrayList<>();
for (String name : names) {
Integer t = function.apply(name);
result.add(t);
}
return result;
}
//我们这里有装箱操作，有专门针对基础类型的ToIntFunction
Function<String,Integer> function=new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return s.length();
}
};
//使用Lambda表达式
Function<String,Integer> function= s -> s.length();
//使用方法引用，方法引用可以被看作仅仅调用特定方法的Lambda的一种快捷写法
Function<String,Integer> function= String::length;
List<String> names = Arrays.asList("one", "two", "three", "four");
List<Integer> result = map(names, String::length);
String::length是一种指向 任意类型实例方法 的方法引用，特点是你在引用一个对象的方法，而这个对象本身是Lambda的一个参数，见下图的三种方法引用的第二种，图片来自Java 8 实战。
method_referece.png
//它与Consumer相反，是个生产者
public interface Supplier<T> {
T get();
}
Supplier<List<String>> supplier=new Supplier<List<String>>() {
@Override
public List<String> get() {
return new ArrayList<>();
}
};
//使用Lambda表达式
Supplier<List<String>> supplier= () -> new ArrayList<>();
//构造函数是静态方法，这里的方法引用对应前表显示的第一种
Supplier<List<String>> supplier= ArrayList::new;
//如果要调用的是一个参数的构造函数
Function<Integer, List> function = ArrayList::new;
//展开是这样
Function<Integer, List> function = new Function<Integer, List>() {
@Override
public List apply(Integer size) {
return new ArrayList(size);
}
};
我们再看看BiConsumer
//正如名字一样 要消费两个参数
public interface BiConsumer<T, U> {
void accept(T t, U u);
}
//一种实现方式
BiConsumer<List<String>, String> biConsumer=new BiConsumer<List<String>, String>() {
@Override
public void accept(List<String> strings, String s) {
//这里是对两个参数的处理
strings.add(s);
}
};
改成Lambda表达式
BiConsumer<List<String>, String> biConsumer= (strings, s) -> strings.add(s);
方法引用，对应上述表中的第二种方法引用
BiConsumer<List<String>, String> biConsumer= List::add;
List::add的真正函数式接口是这样，如果忽略返回值就是void，方法签名是兼容的
BiFunction<List<String>, String, Boolean> biFunction = List::add;
类似的
BiConsumer<StringBuilder, Integer> biConsumer = StringBuilder::deleteCharAt;
BiConsumer<HashSet<String>, String> biConsumer = HashSet::remove;
使用上面的函数式接口作为参数，看一个方法
private void collect(Supplier<List<String>> supplier, BiConsumer<List<String>, String> biConsumer) {
List<String> collector = supplier.get();
biConsumer.accept(collector, "one");
biConsumer.accept(collector, "two");
System.out.println(collector);
}
简洁 优美 灵活 的调用
collect(ArrayList::new,List::add);
你还可以使用Function对collector集合变换后作为返回值，这是一种归约操作的雏形。
还有很多类似的接口，针对基础类型的，不在赘述。用Lambda表达式实例化函数式接口的重点是方法签名要兼容。关于Lambda深入而又权威的解释可以参考这篇文章。
