Java函数式编程

定义

函数式编程是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);
    }
}