定义
函数式编程是Java8新特性之一，可以将函数作为一个变量，参数，返回值和数据类型进行使用，它的使用并不会影响到外部的变量。stream的操作式建立再函数式接口的组合之上，根据JDK1.8对函数式编程的定义，是由注解@FunctionInterface进行标记的接口，实际只要符合以下几个特点，即使不用到注解，也是函数式接口，注解只是让编译器快速定位，当不符合条件则进行报错，作为编译检查的保障：
- 条件
1.有且只有一个唯一的抽象方法；
2.允许有默认方法和静态方法
案例学习
我们以stream方法中所用的函数为切入点进行学习
Function
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
static <T> Function<T, T> identity() {
return t -> t;
}
}
可以看到该函数式接口是由一个抽象方法、两个默认方法、一个静态方法组成，并且由@FunctionInterface进行标记；
- R apply(T t)
该抽象方法是入参和出参都为泛型，表示接收一个类型T的参数，返回一个类型R的返回参数，以stream中的map方法为举例；
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
/**
* StuClass：教室类
* Student ：学生类
*/
public static void main(String[] args) {
Student a = new Student("a", "1", "实验二小");
Student b = new Student("b", "2", "实验二小");
Student c = new Student("c", "2", "实验一小");
Student d = new Student("d", "1", "实验二小");
List<Student> students = Arrays.asList(a, b, c, d);
StuClass A = new StuClass("1", "实验二小");
StuClass B = new StuClass("1", "实验二小");
StuClass C = new StuClass("2", "实验一小");
List<StuClass> stuClasses = Arrays.asList(A, B, C);
System.out.println("+++++++++++++++++++map()：一种中间操作，抽取集合对象中的某些参数,创建一个新的对象集合。++++++++++++++++++++++++++");
List<StuClass> list5 = students.stream().map(student -> {
StuClass stuClass = new StuClass(student.getClassName(), student.getSchool());
return stuClass;
}).collect(Collectors.toList());
}
Predicate
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate<T> negate() {
return (t) -> !test(t);
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}
- boolean test(T t)
输入一个类型T的参数，判断该参数是否符合给定的条件，符合返回true，否则返回false；
System.out.println("+++++++++++++++++++filter():过滤操作++++++++++++++++++++++++++");
List<Student> list1 = students.stream().filter(student -> student.getSchool().equals("实验二小")).collect(Collectors.toList());
而其它的默认方法：and、or中的参数就是一个函数，进行多条件赛选；
public static void main(String[] args) {
List<Student> collect = students.stream().filter(student -> check(student,s1->s1.getClassName().equals("1"),s2->s2.getClassName().equals("2"))).collect(Collectors.toList());
collect.forEach(c1-> System.out.println(c1));
}
public static Boolean check(Student student,Predicate<Student> predicate1,Predicate<Student> predicate2){
return predicate1.or(predicate2).test(student);
}
Comparator
@FunctionalInterface
public interface Comparator<T> {
int compare(T o1, T o2);
...
}
该方法主要用于比较两个入参，并返回一个比较结果，数据排序就可以用到该方法
System.out.println("+++++++++++++++++++sorted()：排序。++++++++++++++++++++++++++");
List<Student> list7 = students.stream().sorted((s1, s2) -> {
return s1.getClassName().compareTo(s2.getClassName());
}).collect(Collectors.toList());
自定义一个简单的函数式接口
@FunctionalInterface
public interface UserDefinedFunction<T,R> {
/*
* @Author pdl
* @Description 将参数类型为R的转换为T
* @Date 14:59
* @Param [r]
* @return
**/
T translate(R r);
}
public class FuntionDemo {
public static void main(String[] args) {
Integer i=100;
String s1 = translateInteger(100, s -> s.toString());
System.out.println(s1);
}
public static String translateInteger(Integer i,UserDefinedFunction<String,Integer> function){
return function.translate(i+1);
}
}
