Java函数式编程

• java  lambda表达式
• java 8系列之Stream的基本语法详解   
• java函数式编程
• function函数详解
• java8中的Function函数式编程详解
• java8之Option

一、什么是函数是编程

相信大家都使用过面向对象的编程语言，面向对象编程是对数据进

行抽象，而函数式编程是对行为进行抽象。函数式编程让程序员能够写出更加容易阅读的代码。那什么时候函数式编程呢？

函数式编程是一种编程的方法论，主要是将行为编写成一个个的函数。

什么是函数？函数就是对输入的值进行处理，返回另外的值。

二、lambda表达式

1. 将list转为map

public Map<String, AClass> getLarkMap(List<AClass> aList) {
   return aList.stream().collect(Collectors.toMap(AClass::getUrl, a -> a, (k1, k2) -> k2));
}

　　

2. 将list中感兴趣的内容过滤出来

public List<AClass> getLarkList(String url, List<AClass> aList) {
   return aList.stream().filter(AClass -> AClass.getUrl().equals(url)).collect(Collectors.toList());
}

 

3. Predicate & Consumer & Function

public class FunctionProgramming {
    private Logger logger = LoggerFactory.getLogger(FunctionProgramming.class);

//    Predicate函数式接口的主要作用就是提供一个test方法，接受一个参数返回一个布尔类型。
//    Predicate在stream api中进行一些判断的时候非常常用。
    @Test
    public void testPredicate() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        List<Integer> res = filter(list, num -> num > 5);
        res.stream().forEach(System.out::print);
        System.out.println();

        res = filterAnd(list, num -> num > 3, num -> num < 7);
        res.stream().forEach(System.out::print);
    }

//    描述：Consumer<T>接口接受一个T类型参数，没有返回值。
    @Test
    public void testConsumer() {
        Student student = Student.builder().build();
        Consumer<Student> consumer = stu -> stu.setName("stu");
        consumer.accept(student);
        consumer = stu -> stu.setAge(18);
        consumer.accept(student);
        logger.info(student.toString());
    }

    @Test
    public void testConsumer2() {
        Student student = Student.builder().name("stu").age(18).build();
        String stuStr = JSON.toJSONString(student);

        Student newStudent = changeInfo(stuStr, Student.class, stu -> {
            stu.setAge(19);
        });
        logger.info(newStudent.introduce());
    }

    @Test
    public void testPredicateConsumer() {
        Student student = Student.builder().build();
        Predicate<Student> predicate = stu -> stu.getName() == null;
        Consumer<Student> consumer = stu -> stu.setName("stu");
        predicateConsumer(student, predicate, consumer);
        logger.info(student.toString());
    }

//    Function<T,R>  接收一个参数并返回结果的函数
//    接口方法 R apply(T t) 将此参数应用到函数中
    @Test
    public void testFunction() {
        Function<String, String> function = str -> str += "!";
        logger.info(function.apply("Hello world"));

        String name = "jack";
        Student jack = Student.builder().name(name).age(18).build();
        Map<String, Student> map = new HashMap<>();
        map.put(name, jack);

//        举个简单的例子用来说明function的使用方法
        logger.info("{} age: {}", name, getAge(name, map, student -> student.getAge()));
    }
private List<Integer> filter(List<Integer> list, Predicate<Integer> predicate) {
        return list.stream().filter(predicate).collect(Collectors.toList());
    }

    private List<Integer> filterAnd(List<Integer> list, Predicate<Integer> pre1, Predicate<Integer> pre2) {
        return list.stream().filter(pre1.and(pre2)).collect(Collectors.toList());
    }

    private void predicateConsumer(Student student, Predicate<Student> predicate, Consumer<Student> consumer) {
        if (predicate.test(student)) {
            consumer.accept(student);
        }
    }

    private <T extends Person> T changeInfo(String msg, Class<T> tClass, Consumer<T> consumer) {
        T t = JSONObject.parseObject(msg, tClass);
        Assert.assertNotNull(t);
        consumer.accept(t);
        return t;
    }

    private int getAge(String name, Map<String, Student> map, Function<Student, Integer> function) {
        Student student = map.get(name);
        return function.apply(student);
    }
}

Student.java

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Student implements Person {
    private String name;
    private int age;

    @Override
    public String introduce() {
        return this.toString();
    }
}