java函数式编程之五个基本接口

1、interface Supplier<T>（无输入有输出，T为输出的变量类型）

Supplier<Integer> supplier = () ->44;
System.out.println(supplier.get());

输出结果为：44

初始化一个对象：

Supplier<Person> supplier0 = Person::new;
Person p = supplier0.get();

 Supplier<Person>  supplier = ()->{
     String a = "yang";
     String b = "cai";
     return new Person(a,b);
 };
 System.out.println(supplier.get().getLastName());

2、interface Consumer<T>（有输入无输出，T为输入的变量类型）

int y = 2;
Consumer<Integer> consumer = x->intToString(y);
Consumer<Integer> consumer1 = x->System.out.println(x+2);
consumer.andThen(consumer1).accept(10);
System.out.println(y);

执行结果为：12

                       2

关于consumer再lamda表达式的应用：

List<Person> personList = new ArrayList<>();
personList.add(new Person("yang","cai"));
personList.add(new Person("yang","fen"));
personList.add(new Person("yang","feng"));
personList.stream().forEach(x->{
       System.out.println(x.getFirstName()+x.getLastName());
});

其中forEach中就是一个Consumer对象

x->{System.out.println(x.getFirstName()+x.getLastName());}

可以转变为：

List<Person> personList = new ArrayList<>();
personList.add(new Person("yang","cai"));
personList.add(new Person("yang","fen"));
personList.add(new Person("yang","feng"));
       
Consumer<Person> consumer = x-> System.out.println(x.getFirstName()+x.getLastName());
for(Person p : personList){
    consumer.accept(p);
}

3、interface Function<T, R>（有输入有输出,T输入类型，R输出类型）

Function<Integer,String> function = x-> "a"+x.toString();
System.out.println(function.apply(10));

以上可见：apply方法是接收输入值的，

Function<Integer, Integer> plusSelf = x -> {
    System.out.println("plusSelf");
    return x + x;
};
Function<Integer, String> toString = x -> {
    System.out.println("toString");
    return String.valueOf(x);
};
//输出20，整数10先自加变成20，然后由toString转换成字符串
String string1 = toString.compose(plusSelf).apply(10); //plusSelf返回的值作为toString的输入
System.out.println(string1);

以上可见：compose方法是，先执行plusSelf再执行toString,并且把plusSelf的返回值作为toString的输入，注意类型要一致

Function<Integer, Integer> plusSelf = x -> {
    System.out.println("plusSelf");
    return x + x;
};
Function<Integer, String> toString = x -> {
    System.out.println("toString");
    return String.valueOf(x);
};
//输出20，整数10先自加变成20，然后由toString转换成字符串
String string1 = plusSelf.andThen(toString).apply(10);
System.out.println(string1);

以上可见：andThen方法是，先执行plusSelf再执行toString,并且把plusSelf的返回值作为toString的输入，注意类型要一致

再lamda表达式中的应用：

List<Person> personList = new ArrayList<>();
personList.add(new Person("yang","cai"));
personList.add(new Person("yang","fen"));
personList.add(new Person("yang","feng"));

List<String> list = 
personList.stream().map(x->x.getLastName()).collect(Collectors.toList());

Function<Person,String> function = x->x.getLastName();
List<String> list1 = personList.stream().map(function).collect(Collectors.toList());

4、interface Predicate<T>

Predicate pre = x->x.equals("yangcai");
Predicate pre2 = x->x.equals("cai");
System.out.println(pre.test("yangcai"));  //测试，获取boolean值
System.out.println(pre.and(pre2).test("yangcai"));//and就是两个条件都符合
System.out.println(pre.or(pre2).test("yangcai"));//or就是任意一个符合就行
System.out.println(pre.negate().test("yangcai"));//对pre的测试结果取反
System.out.println(pre.or(pre2).negate().test("yangcai"));

在lamda表达式中的应用：

List<Person> personList = new ArrayList<>();
personList.add(new Person("yang","cai"));
personList.add(new Person("yang","fen"));
personList.add(new Person("yang","feng"));
List<Person> personList2 = 
personList.stream().filter(x->x.firstName.equals("yang")).collect(Collectors.toList());
Predicate<Person> predicate = x->x.firstName.equals("yangcai");
List<Person> personList3 =
personList.stream().filter(predicate).collect(Collectors.toList());

5、interface Comparator<T>

List<Person> personList = new ArrayList<>();
personList.add(new Person("yang","cai"));
personList.add(new Person("yang","fen"));
personList.add(new Person("yang","feng"));
Comparator<Person> comparator = (x, y)->x.getLastName().compareTo(y.getLastName());
List<Person> list1 = personList.stream().sorted(comparator).collect(Collectors.toList());
List<Person> list = personList.stream().sorted(Comparator.comparing(Person::getLastName).reversed()).collect(Collectors.toList());
System.out.println(list1);
System.out.println(list);

如上所述在lamda表达式中的用法