从代码的改进，看参数行为化与Lambda

朴灿烈づ我的快乐病毒、 2023-07-14 14:58 18阅读 0赞

举一个简单的例子，看如何优化代码，从而更灵活地适应不断变化的需求。

这是一个优秀的程序需要不断考虑的事情。

**这是水果的类代码**

package constxiong.interview;
    
    /**
     * 水果
     * @author ConstXiong
     */
    class Fruit {
    	private String type;
    	private String color;
    	private double weight;
    	
    	public Fruit(String type, String color, double weight) {
    		this.type = type;
    		this.color = color;
    		this.weight = weight;
    	}
    	
    	public String getColor() {
    		return this.color;
    	}
    	
    	public double getWeight() {
    		return this.weight;
    	}
    	
    	public String getType() {
    		return this.type;
    	}
    
    	@Override
    	public String toString() {
    		return String.format("{type:%s,color:%s,weight:%s}", type, color, weight);
    	}
    }

**需求 1、从水果堆中，筛选出所有的苹果**

打印结果

[{type:苹果,color:红色,weight:1.1}, {type:苹果,color:绿色,weight:1.7}]

**需求 2、这次从水果堆里，筛选出香蕉**

思考：这次你想到，给 filterFruit 方法添加一个水果的种类 type 参数，进行过滤，以适应下次可以满足过滤出其他种类的水果

package constxiong.interview;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    /**
     * 测试优化代码
     * @author ConstXiong
     */
    public class TestImproveCode {
    
    	public static void main(String[] args) {
    		List<Fruit> list = Arrays.asList(new Fruit("苹果", "红色", 1.1),
    				new Fruit("苹果", "绿色", 1.7),
    				new Fruit("香蕉", "黄色", 0.8),
    				new Fruit("橘子", "橙色", 0.7));
    		
    		System.out.println(filterFruit(list, "香蕉"));
    	}
    	
    	/**
    	 * 过滤水果
    	 * @param fruit
    	 * @param type
    	 * @return
    	 */
    	static List<Fruit> filterFruit(List<Fruit> fruit, String type) {
    		List<Fruit> result = new ArrayList<Fruit>();
    		for (Fruit f : fruit) {
    			if (type.equals(f.getType())) {
    				result.add(f);
    			}
    		}
    		return result;
    	}
    }

打印结果

[{type:香蕉,color:黄色,weight:0.8}]

**需求 3、过滤重量大于 1 的水果**

思考：可能你已想到这个需求变动，早就添加了方法 filterFruit(List<Fruit> fruit, double weight)

package constxiong.interview;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    /**
     * 测试优化代码
     * @author ConstXiong
     */
    public class TestImproveCode {
    
    	public static void main(String[] args) {
    		List<Fruit> list = Arrays.asList(new Fruit("苹果", "红色", 1.1),
    				new Fruit("苹果", "绿色", 1.7),
    				new Fruit("香蕉", "黄色", 0.8),
    				new Fruit("橘子", "橙色", 0.7));
    		
    		System.out.println(filterFruit(list, 1));
    	}
    	
    	/**
    	 * 根据类型过滤水果
    	 * @param fruit
    	 * @param type
    	 * @return
    	 */
    	static List<Fruit> filterFruit(List<Fruit> fruit, String type) {
    		List<Fruit> result = new ArrayList<Fruit>();
    		for (Fruit f : fruit) {
    			if (type.equals(f.getType())) {
    				result.add(f);
    			}
    		}
    		return result;
    	}
    	/**
    	 * 根绝重量过滤水果
    	 * @param fruit
    	 * @param type
    	 * @return
    	 */
    	static List<Fruit> filterFruit(List<Fruit> fruit, double weight) {
    		List<Fruit> result = new ArrayList<Fruit>();
    		for (Fruit f : fruit) {
    			if (f.getWeight() > weight) {
    				result.add(f);
    			}
    		}
    		return result;
    	}
    }

但你有没有发现，这个代码中的两个 filterFruit 方法，除了第二个参数和对参数的判断不同，其他地方都是相同，这违反了 Don’t Repeat Yourself 的软件设计原则

于是继续优化代码，把 filterFruit 方法的参数进行合并

package constxiong.interview;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    /**
     * 测试优化代码
     * @author ConstXiong
     */
    public class TestImproveCode {
    
    	public static void main(String[] args) {
    		List<Fruit> list = Arrays.asList(new Fruit("苹果", "红色", 1.1),
    				new Fruit("苹果", "绿色", 1.7),
    				new Fruit("香蕉", "黄色", 0.8),
    				new Fruit("橘子", "橙色", 0.7));
    		
    		System.out.println(filterFruit(list, null, 1.0));
    	}
    	
    	/**
    	 * 过滤水果
    	 * @param fruit
    	 * @param type
    	 * @return
    	 */
    	static List<Fruit> filterFruit(List<Fruit> fruit, String type, Double weight) {
    		List<Fruit> result = new ArrayList<Fruit>();
    		for (Fruit f : fruit) {
    			if (type != null && weight != null) {
    				if (type.equals(f.getType()) && f.getWeight() > weight) {
    					result.add(f);
    				}
    			} else if (type == null && weight != null) {
    				if (f.getWeight() > weight) {
    					result.add(f);
    				}
    			} else if (type != null && weight == null) {
    				if (type.equals(f.getType())) {
    					result.add(f);
    				}
    			}
    		}
    		return result;
    	}
    }

这样的改动，其实很糟糕，代码多了很多 if-else 判断，理解起来更困难了，同时不能更好的满足各种组合的需求。比如再希望通过颜色过滤水果怎么办？

这时候就需要引入行为参数化，让方法接受多种行为作为参数，并在内部使用，来完成不同的行为。

新增一个接口 FruitFilter

package constxiong.interview;
    
    /**
     * 水果过滤接口
     * @author ConstXiong
     */
    public interface FruitFilter {
    
    	/**
    	 * 根据是否满足条件过滤水果
    	 * @param fruit
    	 * @return
    	 */
    	boolean filter(Fruit fruit);
    	
    }

现在就可以新增多个 FruitFilter 实现，满足各种需求的组合

package constxiong.interview;
    
    /**
     * 根据类型过滤水果实现类
     * @author ConstXiong
     */
    public class FruitTypeFilter implements FruitFilter{
    
    	public boolean filter(Fruit fruit) {
    		return "苹果".equals(fruit.getType());
    	}
    	
    }

package constxiong.interview;
    
    /**
     * 根据重量过滤水果实现类
     * @author ConstXiong
     */
    public class FruitWeightFilter implements FruitFilter {
    
    	public boolean filter(Fruit fruit)  {
    		return fruit.getWeight() > 1;
    	}
    	
    }

可以通过这样的方式，把一簇算法规则封装为一系列策略，在运行时选择算法。

再对 filterFruit 方法进行优化

package constxiong.interview;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    /**
     * 测试优化代码
     * @author ConstXiong
     */
    public class TestImproveCode {
    
    	public static void main(String[] args) {
    		List<Fruit> list = Arrays.asList(new Fruit("苹果", "红色", 1.1),
    				new Fruit("苹果", "绿色", 1.7),
    				new Fruit("香蕉", "黄色", 0.8),
    				new Fruit("橘子", "橙色", 0.7));
    		
    		System.out.println(filterFruit(list, new FruitTypeFilter()));
    	}
    	
    	/**
    	 * 过滤水果
    	 * @param fruit
    	 * @param type
    	 * @return
    	 */
    	static List<Fruit> filterFruit(List<Fruit> fruit, FruitFilter filter) {
    		List<Fruit> result = new ArrayList<Fruit>();
    		for (Fruit f : fruit) {
    			if (filter.filter(f)) {
    				result.add(f);
    			}
    		}
    		return result;
    	}
    }

也可以不用提前定义 FruitFilter 的实现类，使用匿名类，在匿名类中实现需求逻辑

package constxiong.interview;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    /**
     * 测试优化代码
     * @author ConstXiong
     */
    public class TestImproveCode {
    
    	public static void main(String[] args) {
    		List<Fruit> list = Arrays.asList(new Fruit("苹果", "红色", 1.1),
    				new Fruit("苹果", "绿色", 1.7),
    				new Fruit("香蕉", "黄色", 0.8),
    				new Fruit("橘子", "橙色", 0.7));
    		
    		System.out.println(filterFruit(list, new FruitFilter() {
    			@Override
    			public boolean filter(Fruit fruit) {
    				return"苹果".equals(fruit.getType());
    			}
    		}));
    	}
    	
    	/**
    	 * 过滤水果
    	 * @param fruit
    	 * @param type
    	 * @return
    	 */
    	static List<Fruit> filterFruit(List<Fruit> fruit, FruitFilter filter) {
    		List<Fruit> result = new ArrayList<Fruit>();
    		for (Fruit f : fruit) {
    			if (filter.filter(f)) {
    				result.add(f);
    			}
    		}
    		return result;
    	}
    }

感觉优化到这里，应该挺让人满意了，但是匿名类的语法容易让人对变量的使用产生歧义，每次都要 new 出对象。

这次就需要使用 Java 8 中 Lambda 表达式代替匿名类，让代码更简洁，一眼就能看出你想要代码表达的意图。

package constxiong.interview;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    /**
     * 测试优化代码
     * @author ConstXiong
     */
    public class TestImproveCode {
    
    	public static void main(String[] args) {
    		List<Fruit> list = Arrays.asList(new Fruit("苹果", "红色", 1.1),
    				new Fruit("苹果", "绿色", 1.7),
    				new Fruit("香蕉", "黄色", 0.8),
    				new Fruit("橘子", "橙色", 0.7));
    		
    		System.out.println(filterFruit(list, (Fruit f) -> "苹果".equals(f.getType())));
    	}
    	
    	/**
    	 * 过滤水果
    	 * @param fruit
    	 * @param type
    	 * @return
    	 */
    	static List<Fruit> filterFruit(List<Fruit> fruit, FruitFilter filter) {
    		List<Fruit> result = new ArrayList<Fruit>();
    		for (Fruit f : fruit) {
    			if (filter.filter(f)) {
    				result.add(f);
    			}
    		}
    		return result;
    	}
    }

通过修改

filterFruit(list, (Fruit f) -> "苹果".equals(f.getType()))

中的 Lambda 表达式即可修改过滤水果的逻辑，比如希望通过重量过滤

filterFruit(list, (Fruit f) -> f.getWeight() > 1)

代码比之前干净很多，更像是它在陈述问题本身。

到此好像可以结束了，但是我们并不满足于此，继续...

把 List 抽象化，修改 FruitFilter 接口和 TestImproveCode 类的 filterFruit 方法

package constxiong.interview;
    
    /**
     * 水果过滤接口
     * @author ConstXiong
     */
    public interface FruitFilter<T> {
    
    	/**
    	 * 根据是否满足条件过滤水果
    	 * @param fruit
    	 * @return
    	 */
    	boolean filter(T t);
    	
    }

/**
    	 * 过滤水果
    	 * @param <T>
    	 * @param fruit
    	 * @param type
    	 * @return
    	 */
    	static <T> List<T> filterFruit(List<T> list, FruitFilter<T> filter) {
    		List<T> result = new ArrayList<T>();
    		for (T e : list) {
    			if (filter.filter(e)) {
    				result.add(e);
    			}
    		}
    		return result;
    	}

这样这个方法就适用于所有的类型了。

这就是 JDK 1.8 中新增 java.util.function.Predicate 接口的用途之一。

看到这里，你是不是理解到了 JDK 的设计师，为了能让你的代码更加简洁的良苦用心了？

--------------------

### 【Java面试题与答案】整理推荐 ###

*  [基础与语法][Link 1]
 *  [集合][Link 2]
 *  [网络编程][Link 3]
 *  [并发编程][Link 4]
 *  [Web][]
 *  [安全][Link 5]
 *  [设计模式][Link 6]
 *  [框架][Link 7]
 *  [算法与数据结构][Link 8]
 *  [异常][Link 9]
 *  [文件解析与生成][Link 10]
 *  [Linux][]
 *  [MySQL][]
 *  [Oracle][]
 *  [Redis][]
 *  [Dubbo][]

[Link 1]: https://www.javanav.com/interview/93b0069472fd479393006c0e73043fc4.html
[Link 2]: https://www.javanav.com/interview/4147d95e693945e7a50345fd33ec817e.html
[Link 3]: https://www.javanav.com/interview/68a57ffc78de4133bb890bdd502ac418.html
[Link 4]: https://www.javanav.com/interview/36a24fa3258e45c89873f474ce914912.html
[Web]: https://www.javanav.com/interview/4e27cb63adb440c6825a159d35cf4010.html
[Link 5]: https://www.javanav.com/interview/03affb2ce3f04fda8853f714e5764906.html
[Link 6]: https://www.javanav.com/interview/07a32a9ff17a4006a53550ce658cafed.html
[Link 7]: https://www.javanav.com/interview/5c466456e9b54ab0a749b5948e51f1d3.html
[Link 8]: https://www.javanav.com/interview/943f917041ee4f05add24539f5b861b2.html
[Link 9]: https://www.javanav.com/interview/d3f058cfc05d4c6dadd821b622e84d36.html
[Link 10]: https://www.javanav.com/interview/67a50996c28f418e83b109ea42fc3eff.html
[Linux]: https://www.javanav.com/interview/00cccb81729540d1923bd0a0ef49533a.html
[MySQL]: https://www.javanav.com/interview/d311e78502a845f1a4bb307bd6aec2b3.html
[Oracle]: https://www.javanav.com/interview/5f29e9677edf4a16be3dce30d257c9ab.html
[Redis]: https://www.javanav.com/interview/066c62b3af4d4827b2243a822c3084a9.html
[Dubbo]: https://www.javanav.com/interview/9a3e7a7740324757abaab953f7ebc455.html