泛型（17）：将函数对象用作策略

柔光的暖阳◎ 2023-07-18 14:20 15阅读 0赞

最后一个示例通过使用前面一节描述的适配器方式创建了真正的泛化代码。这个示例开始时是一种尝试，要创建一个元素序列的总和，这些元素可以是任何可以计算总和的类型，但是，后来这个示例使用功能型编程风格，演化成了可以执行通用的操作。

如果只查看尝试添加对象的过程，就会看到这是在多个类中的公共操作，但是这个操作没有在任何我们可以指定的基类中表示——有时甚至可以使用“+”操作符，而其他时间可以使用某种add方法。这是在试图编写泛化代码的时候通常会碰到的情况，因为你想将这些代码应用于多个类上——特别是，像本例一样，作用于多个已经存在且我们不能“修正”的类上。即使你可以将这种情况窄化到Number的子类，这个超类也不包括任何有关“可添加性”的东西。

解决方案是使用策略设计模式，这种设计模式可以产生更优雅的代码，因为它将“变化的事物”完全隔离到了一个函数对象中。函数对象就是在某种程度上行为像函数的对象——一般的，会有一个相关的方法（在支持操作符重载的语言中，可以创建对这个方法的调用，而这个调用看起来就和普通的方法调用一样）。函数对象的价值就在于，与普通方法不同，它们可以传递出去，并且还可以拥有在多个调用之间的持久化的状态。当然，可以用类中的任何方法来实现与此相似的操作，但是（与使用任何设计模式一样）函数对象主要是由其目的来区别的。这里的目的就是要创建某种事物，使它的行为就像是一个可以传递出去的单个方法一样，这样，它就和策略设计模式紧耦合了，有时甚至无法区分。

尽管可以发现我使用了大量的设计模式，但是在这里它们之间的界限是模糊的：我们在创建执行适配操作的函数对象，而它们将被传递到用作策略的方法中。

通过采用这种方式，我添加了最初着手创建的各种类型的泛型方法，以及其他的泛型方法。下面是产生的结果：

import java.math.BigDecimal;
    import java.math.BigInteger;
    import java.math.MathContext;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Iterator;
    import java.util.List;
    import java.util.concurrent.atomic.AtomicLong;
    
    /**
     * 组合
     */
    interface Combiner<T> {
    	T combine(T x, T y);
    }
    
    /**
     * 一元函数
     */
    interface UnaryFunction<R, T> {
    	R function(T x);
    }
    
    interface Collector<T> extends UnaryFunction<T, T> {
    	T result();
    }
    
    /**
     * 一元判断
     */
    interface UnaryPredicate<T> {
    	boolean test(T x);
    }
    
    public class Functional {
    
    	// 分解
    	public static <T> T reduce(Iterable<T> seq, Combiner<T> combiner) {
    		Iterator<T> it = seq.iterator();
    		if (it.hasNext()) {
    			T result = it.next();
    			while (it.hasNext()) {
    				result = combiner.combine(result, it.next());
    			}
    			return result;
    		}
    		return null;
    	}
    
    	// 遍历
    	public static <T> Collector<T> forEach(Iterable<T> seq, Collector<T> func) {
    		for (T t : seq) {
    			func.function(t);
    		}
    		return func;
    	}
    
    	// 转化
    	public static <R, T> List<R> transform(Iterable<T> seq, UnaryFunction<R, T> func) {
    		List<R> result = new ArrayList<>();
    		for (T t : seq) {
    			result.add(func.function(t));
    		}
    		return result;
    	}
    
    	// 过滤
    	public static <T> List<T> filter(Iterable<T> seq, UnaryPredicate<T> pred) {
    		List<T> result = new ArrayList<>();
    		for (T t : seq) {
    			if (pred.test(t)) {
    				result.add(t);
    			}
    		}
    		return result;
    	}
    
    	/**
    	 * 整数加法器
    	 */
    	static class IntegerAdder implements Combiner<Integer> {
    		@Override
    		public Integer combine(Integer x, Integer y) {
    			return x + y;
    		}
    	}
    
    	/**
    	 * 整数减法器
    	 */
    	static class IntegerSubtracter implements Combiner<Integer> {
    		@Override
    		public Integer combine(Integer x, Integer y) {
    			return x - y;
    		}
    	}
    
    	/**
    	 * 精确小数加法器
    	 */
    	static class BigDecimalAdder implements Combiner<BigDecimal> {
    		@Override
    		public BigDecimal combine(BigDecimal x, BigDecimal y) {
    			return x.add(y);
    		}
    	}
    
    	/**
    	 * 大整数加法器
    	 */
    	static class BigIntegerAdder implements Combiner<BigInteger> {
    		@Override
    		public BigInteger combine(BigInteger x, BigInteger y) {
    			return x.add(y);
    		}
    	}
    
    	/**
    	 * 原子类加法器
    	 */
    	static class AtomicLongAdder implements Combiner<AtomicLong> {
    		@Override
    		public AtomicLong combine(AtomicLong x, AtomicLong y) {
    			return new AtomicLong(x.addAndGet(y.get()));
    		}
    	}
    
    	/**
    	 * 返回一个ulp的大小，也就是这个BigDecimal的最后一位
    	 */
    	static class BigDecimalUlp implements UnaryFunction<BigDecimal, BigDecimal> {
    		@Override
    		public BigDecimal function(BigDecimal x) {
    			return x.ulp();
    		}
    	}
    
    	/**
    	 * 大于
    	 */
    	static class GreaterThan<T extends Comparable<T>> implements UnaryPredicate<T> {
    		private T bound;
    
    		public GreaterThan(T bound) {
    			this.bound = bound;
    		}
    
    		@Override
    		public boolean test(T x) {
    			return x.compareTo(bound) > 0;
    		}
    	}
    
    	/**
    	 * 乘以整数收集器
    	 */
    	static class MultiplyingIntegerCollector implements Collector<Integer> {
    
    		private Integer val = 1;
    
    		@Override
    		public Integer function(Integer x) {
    			val *= x;
    			return val;
    		}
    
    		@Override
    		public Integer result() {
    			return val;
    		}
    	}
    
    	// 测试程序
    	public static void main(String[] args) {
    		List<Integer> li = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    		Integer result = reduce(li, new IntegerAdder());
    		System.out.println(result);
    
    		result = reduce(li, new IntegerSubtracter());
    		System.out.println(result);
    
    		System.out.println(filter(li, new GreaterThan<Integer>(4)));
    
    		System.out.println(forEach(li, new MultiplyingIntegerCollector()).result());
    
    		System.out.println(forEach(filter(li, new GreaterThan<Integer>(4)), new MultiplyingIntegerCollector()).result());
    
    		MathContext mc = new MathContext(7);
    		List<BigDecimal> lbd = Arrays.asList(new BigDecimal(1.1, mc), new BigDecimal(2.2, mc), new BigDecimal(3.3, mc),
    				new BigDecimal(4.4, mc));
    		BigDecimal rbd = reduce(lbd, new BigDecimalAdder());
    		System.out.println(rbd);
    
    		System.out.println(filter(lbd, new GreaterThan<BigDecimal>(new BigDecimal(3))));
    
    		List<BigInteger> lbi = new ArrayList<>();
    		BigInteger bi = BigInteger.valueOf(11);
    		for (int i = 0; i < 11; i++) {
    			lbi.add(bi);
    			bi = bi.nextProbablePrime();
    		}
    		System.out.println(lbi);
    
    		BigInteger rbi = reduce(lbi, new BigIntegerAdder());
    		System.out.println(rbi);
    		System.out.println(rbi.isProbablePrime(5));
    
    		List<AtomicLong> lal = Arrays.asList(new AtomicLong(11), new AtomicLong(47), new AtomicLong(74),
    				new AtomicLong(133));
    		AtomicLong ral = reduce(lal, new AtomicLongAdder());
    		System.out.println(ral);
    		
    		System.out.println(transform(lbd, new BigDecimalUlp()));
    	}
    }

我是从为不同类型的函数对象定义接口开始的，这些接口都是按需创建的，因为我为每个接口都开发了不同的方法，并发现每个接口的需求。Combiner类抽象掉了将两个对象添加在一起的具体细节，并且只是声明它们在某种程度上被结合在一起。因此，可以看到，IntegerAdder和IntegerSubstract可以是Combiner类型。

UnaryFunction接受单一的参数，并产生一个结果；这个参数和结果不需要是相同的类型。Collector被用作“收集参数”，并且当你完成时，可以从中抽取结果。UnaryPredicate将产生一个boolean类型的结果。还可以创建其他类型的函数对象，但是这些已经足够说明问题了。

Functional类包含大量的泛型方法，它们可以将函数对象应用于序列。reduce()将Combiner中的函数应用于序列中的每个元素，以产生单一个的结果。

foreach()接受一个Collector，并将其函数应用于每个元素，但同时会忽略每次函数调用的结果。这只能被称为是副作用（这不是“功能型”编程风格，但仍旧是有用的），或者我们可以让Collector维护内部状态，从而变成一个收集参数，就像在本例中看到的那样。

transform()通过在序列中的每个对象上调用UnaryFunction，并捕获调用结果，来产生一个列表。

最后，filter()将UnaryPredicate应用到序列中的每个对象上，并将那些返回true的对象存储到一个List中。

在C++中，潜在类型机制将在你调用函数时负责协调各个操作，但是在java中，我们需要编写函数对象来将泛型方法适配为我们特定的需求。因此，这个类接下来的部分展示了函数对象的各种不同的实现。例如，注意，IntegerAdder和BigDecimalAdder通过为它们特定的类型调用恰当的方法，从而解决了相同的问题，即添加两个对象。因此，这是适配器模式和策略模式的结合。

在main()中，你可以看到，在每个方法调用中，都会传递一个序列和恰当的函数对象。还有大量的、可能会相当复杂的表达式，例如：

forEach(filter(li, new GreaterThan<Integer>(4)), new MultiplyingIntegerCollector()).result()

这将通过选取li中大于4的所有元素而产生一个列表，然后将MultiplyingIntegerCollector()应用于所产生的列表，并抽取result()通过通读它们你就可以了解它们的作用。

**如果本文对您有很大的帮助，还请点赞关注一下。**