总结一下java8中的新特性 内置的四大核心函数式接口
函数式接口在java中是指: 有且仅有一个抽象方法的接口
函数式接口，即适用于函数式编程场景的接口。而java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。
@FunctionalInterface标注在一个接口上，说明这个接口是一个函数式接口。
那么关于函数式接口，有如下特点：
- 有且只有一个抽象方法
- 可以有多个静态方法
- 可以有多个default方法(默认方法)
- 可以有多个Object的public的抽象方法
@FunctionalInterface
public interface Consumer {
void accept(T t);
default Consumer andThen(Consumer after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}
Consumer有参数，无返回值
Consumer有两个方法：accept()抽象方法, andThen()非抽象方法
使用示例：
//Consumer 消费型接口 :
@Test
public void test1(){
happy(10000, (m) -> System.out.println("消费：" + m + "元"));
}
public void happy(double money, Consumer con){
con.accept(money);
}
@FunctionalInterface
public interface Supplier {
// 无输入参数，提供一个创建好的对象，即结果
T get();
}
使用示例
//Supplier 供给型接口 :
@Test
public void test2(){
List numList = getNumList(10, () -> (int)(Math.random() * 100));
for (Integer num : numList) {
System.out.println(num);
}
}
//需求：产生指定个数的整数，并放入集合中
public List getNumList(int num, Supplier sup){
List list = new ArrayList<>();
for (int i = 0; i < num; i++) {
Integer n = sup.get();
list.add(n);
}
return list;
}
@FunctionalInterface
public interface Function {
// 我给你一个参数，你帮我处理一下，给我返回另一个参数。
R apply(T t);
// 返回一个组合函数，首先将入参应用到before函数，再将before函数结果应用到该函数中
default Function compose(Function before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
// 返回一个组合函数，该函数结果应用到after函数中
default Function andThen(Function after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
// 返回输入参数
static Function identity() {
return t -> t;
}
}
使用示例：
//Function 函数型接口：
@Test
public void test3(){
String newStr = strHandler("\t\t\t 这是一个字符串", (str) -> str.trim());
System.out.println(newStr);
String subStr = strHandler("这是一个字符串", (str) -> str.substring(2, 5));
System.out.println(subStr);
}
//需求：用于处理字符串
public String strHandler(String str, Function fun){
return fun.apply(str);
}
源码：
@FunctionalInterface
public interface Predicate {
// 给一个参数T，返回boolean类型的结果
boolean test(T t);
default Predicate and(Predicate other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate negate() {
return (t) -> !test(t);
}
default Predicate or(Predicate other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static Predicate isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}
Predicate默认实现的三个重要方法and，or和negate，这三个方法对应了java的三个连接符号&&、||和!，isEqual这个方法的返回类型也是Predicate，所以我们也可以把它作为函数式接口进行使用。我们可以当做==操作符来使用。
使用示例：
//Predicate 断言型接口：
@Test
public void test4(){
List list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok");
List strList = filterStr(list, (s) -> s.length() > 3);
for (String str : strList) {
System.out.println(str);
}
}
//需求：将满足条件的字符串，放入集合中
public List filterStr(List list, Predicate pre){
List strList = new ArrayList<>();
for (String str : list) {
if(pre.test(str)){
strList.add(str);
}
}
return strList;
}
Original: https://www.cnblogs.com/mrxccc/p/16504729.html
Author: 狮子挽歌丿
Title: Java8新特性-四大核心函数式接口
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/588660/
转载文章受原作者版权保护。转载请注明原作者出处！