Java函数式编程

矫情吗；* 2022-07-10 10:58 192阅读 0赞

**摘要：** 在Java重构的过程中，巧妙的运用函数式思想能够便捷地去掉重复。

函数式编程是声明式的。也就是说，她应该指定“什么要做”而非“怎么做”。这种方式使得我们可以工作更高的抽象层次。而传统的过程式以及面向对象的语言，则是命令式的，因而更关注于“怎么做”这个层面。站在面向对象思想的角度来看，函数式编程将函数看成一等公民的思想，使得我们处理的粒度从类变小为函数，从而可以更好地满足系统对重用性和扩展性的支持。也就是说，我们可以从函数的粒度，而非对象的粒度去思考领域问题。

例如，有这样一个场景：我的业务模型是个Person，已经有业务接口能返回给我所有Person的list集合，我需要把根据一些条件返回符合对应关系的Person。

Person.java

public class Person { 
        private String name;
        private String gender;
        private int age;
    
        public int getAge() { 
            return age;
        }
    
        public void setAge(int age) { 
            this.age = age;
        }
    
        public String getGender() { 
            return gender;
        }
    
        public void setGender(String gender) { 
            this.gender = gender;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    }

首先，根据业务需求，写出第一个方法 `通过姓名找出符合的Person`

PersonService.java

接下来，第二个方法`根据性别找出符合的Person`

import java.util.ArrayList;
    import java.util.List;
    
    public class PersonService { 
        //假设这个list是通过已有接口返回的所有Person集合
        private static List<Person> list = new ArrayList<Person>();
    
        public static List<Person> findByName(String name){ 
            List<Person> people = new ArrayList<Person>();
            for (Person p : list){ 
                if(name.equals(p.getName())){ 
                    people.add(p);
                }
            }
            return people;
        }
    
        public static List<Person> findByGender(String gender){ 
            List<Person> people = new ArrayList<Person>();
            for (Person p : list){ 
                if(gender.equals(p.getGender())){ 
                    people.add(p);
                }
            }
            return people;
        }
    }

功能是实现了，但是要是这样交差，估计得挨骂了，这么多重复代码。仔细观察刚添加的两个方法。发现，除了下面两行以外全都相同：

*  if(name.equals(p.getName()))\{
 *  if(gender.equals(p.getGender()))\{

这里的`name`和`gender`是两个字符串参数，可以给它们用同样的名字，比如str，这样的话：

*  if(str.equals(p.getName()))\{
 *  if(str.equals(p.getGender()))\{

这下，不同点就是`getName()`和`getGender()`，是两个方法，而Java是不能把函数当参数的，这样重构起来就麻烦很多。

想到Java中还有一种迂回的方式传递函数，那就是接口。  
新建一个接口`Criteria`，在这个接口里隐藏`if`条件语句里面的实现细节。这样就可以把`findByName()`和`findByGender`高度抽象为一个方法`find()`。

import java.util.ArrayList;
    import java.util.List;
    
    public class PersonService { 
        //假设这个list是通过已有接口返回的所有Person集合
        private static List<Person> list = new ArrayList<Person>();
    
        public List<Person> findByName(String name) { 
    		return null;
        }
    
        public List<Person> findByGender(String gender) { 
            return null;
        }
    
        public List<Person> find(Criteria criteria){ 
            List<Person> people = new ArrayList<Person>();
            for (Person p : list){ 
                if(criteria.matches(p)){ 
                    people.add(p);
                }
            }
            return people;
        }
    }
    
    interface Criteria{ 
        boolean matches(Person person);
    
    }

对于具体的`findByName()`方法，只需要实现匹配的细节即可：

public List<Person> findByName(String name) { 
            return find(new Criteria() { 
                @Override
                public boolean matches(Person person) { 
                    return person.getName().equals(name);
                }
            });
        }

经过改装后的PersonService.java大致像下面这样：

import java.util.ArrayList;
    import java.util.List;
    
    public class PersonService { 
        //假设这个list是通过已有接口返回的所有Person集合
        private List<Person> list = new ArrayList<>();
    
        public List<Person> findByName(String name) { 
            return find(new Criteria() { 
                @Override
                public boolean matches(Person person) { 
                    return name.equals(person.getName());
                }
            });
        }
    
        public List<Person> findByGender(String gender) { 
           return find(new Criteria() { 
               @Override
               public boolean matches(Person person) { 
                   return gender.equals(person.getGender());
               }
           });
        }
    
        public List<Person> find(Criteria criteria){ 
            List<Person> people = new ArrayList<>();
            for (Person p : list){ 
                if(criteria.matches(p)){ 
                    people.add(p);
                }
            }
            return people;
        }
    
    }
    
    interface Criteria{ 
        boolean matches(Person person);
    }

看到这，估计有人要发飙了，说好的重构去重复，结果为了一行代码，增加了无数行无关代码，还无故多了一个类（接口Criteria）。原始代码才25行左右，现在将近40行代码。这个`findByName()`和`findByGender`方法除了`return`后面的不同，剩下的完全一样，虽然那些代码都是IDE自动生成的，但是看起来，这次重构没有起到简化代码的目的。甚至，如果你没有用Java8，那上面的代码需要改动才能编译通过。  
这种重构的思想其实属于一种设计模式——策略设计模式，它的意图就是定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。

当然，如果使用过java8，那么应该也听说过Lambda表达式。如果使用的IDE是Intellij的话，那应该庆幸一下，因为它已经识别到了需要改进的地方。  
![这里写图片描述][aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwMjI3MjIwNjA0ODU0]  
这样，看起来，代码会整洁许多：

import java.util.ArrayList;
    import java.util.List;
    
    public class PersonService { 
        //假设这个list是通过已有接口返回的所有Person集合
        private List<Person> list = new ArrayList<>();
    
        public List<Person> findByName(String name) { 
            return find(p-> name.equals(p.getName()));
        }
    
        public List<Person> findByGender(String gender) { 
           return find(p-> gender.equals(p.getGender()));
        }
    
        public List<Person> find(Criteria criteria){ 
            List<Person> people = new ArrayList<>();
            for (Person p : list){ 
                if(criteria.matches(p)){ 
                    people.add(p);
                }
            }
            return people;
        }
    
    }
    
    interface Criteria{ 
        boolean matches(Person person);
    }

我定义了一个看起来多余，但是又必须存在的接口`Criteria`。如果项目中有很多需要这样重构的代码，不是得写很多类似的接口？当然，JDK的设计者已经想到了这一点，于是就有了一个公用的接口`Predicate`。这样，再整理一下代码：

import java.util.ArrayList;
    import java.util.List;
    import java.util.function.Predicate;
    
    public class PersonService { 
        //假设这个list是通过已有接口返回的所有Person集合
        private List<Person> list = new ArrayList<>();
    
        public List<Person> findByName(String name) { 
            return find(p-> name.equals(p.getName()));
        }
    
        public List<Person> findByGender(String gender) { 
           return find(p-> gender.equals(p.getGender()));
        }
    
        public List<Person> find(Predicate<Person> predicate){ 
            List<Person> people = new ArrayList<>();
            for (Person p : list){ 
                if(predicate.test(p)){ 
                    people.add(p);
                }
            }
            return people;
        }
    }

如果觉得这里的`find`写的臃肿，也可以改进：  
![这里写图片描述][aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwMjI3MjIyMzI3MTgw]

整理后的代码：

import java.util.ArrayList;
    import java.util.List;
    import java.util.function.Predicate;
    import java.util.stream.Collectors;
    
    public class PersonService { 
        //假设这个list是通过已有接口返回的所有Person集合
        private List<Person> list = new ArrayList<>();
    
        public List<Person> findByName(String name) { 
            return find(p -> name.equals(p.getName()));
        }
    
        public List<Person> findByGender(String gender) { 
           return find(p -> gender.equals(p.getGender()));
        }
    
        public List<Person> find(Predicate<Person> predicate){ 
            return list.stream().filter(p -> predicate.test(p)).collect(Collectors.toList());
        }
    }

这样看起来就比刚开始复制/粘贴的代码清爽许多。如果第三个业务需求是`根据年龄找出符合条件的Person`，你可以这样写：

public List<Person> findByAge(int age){ 
            List<Person> people = new ArrayList<>();
            for (Person person : list) { 
                if(age == person.getAge()){ 
                    people.add(person);
                }
            }
         return people;
    }

中规中矩，没有问题，但是如果写成下面这样，是不是更容易抓住方法的要点：

public List<Person> findByAge(int age){
         return find(p -> age == p.getAge());
    }

刚开始重构花了很多时间，但是现在要新添加业务方法，我只需要一行代码：

import java.util.ArrayList;
    import java.util.List;
    import java.util.function.Predicate;
    import java.util.stream.Collectors;
    
    public class PersonService { 
        //假设这个list是通过已有接口返回的所有Person集合
        private List<Person> list = new ArrayList<>();
    
        public List<Person> findByName(String name) { 
            return find(p -> name.equals(p.getName()));
        }
    
        public List<Person> findByGender(String gender) { 
           return find(p -> gender.equals(p.getGender()));
        }
    	//根据年龄找出符合条件的Person
        public List<Person> findByAge(int age){ 
            return find(p -> age == p.getAge());
        }
    
        public List<Person> find(Predicate<Person> predicate){ 
            return list.stream().filter(p -> predicate.test(p)).collect(Collectors.toList());
        }
    }

之后又有一个新的业务需求`找出在给定年龄段的Person`，依然只需要一行代码：

import java.util.ArrayList;
    import java.util.List;
    import java.util.function.Predicate;
    import java.util.stream.Collectors;
    
    public class PersonService { 
        //假设这个list是通过已有接口返回的所有Person集合
        private List<Person> list = new ArrayList<>();
    
        public List<Person> findByName(String name) { 
            return find(p -> name.equals(p.getName()));
        }
    
        public List<Person> findByGender(String gender) { 
           return find(p -> gender.equals(p.getGender()));
        }
    
        public List<Person> findByAge(int age){ 
            return find(p -> age == p.getAge());
        }
    	//找出在给定年龄段的Person
        public List<Person> findByAgeRange(int startAge,int endAge){ 
            return find(p -> startAge <= p.getAge() && endAge >= p.getAge());
        }
    
        public List<Person> find(Predicate<Person> predicate){ 
            return list.stream().filter(p -> predicate.test(p)).collect(Collectors.toList());
        }
    }

Java8中引入的函数式接口，Lambda表达式，以及Stream API给Java增加了更多的可能，在面向对象的语言中增加面向函数的设计思想，使得某些场景下代码的编写异常简洁清晰。

[aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwMjI3MjIwNjA0ODU0]: /images/20220709/45a6d7e6fc8742f5a49134965a7661c9.png
[aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwMjI3MjIyMzI3MTgw]: /images/20220709/87b9bf70c592449d948079747695c400.png