java实现泛型加法
引言：
朴素的数字加法
之前实践中实现数据的加法，很繁琐，比如下面，每一种类型都要写一遍，能不能用泛型方法实现呢？
public Long getSum(Long... args) { long init = 0L; for (Long arg : args) { if (arg == null) { arg = 0L; } init += arg; } return init; } public Integer getSum(Integer... args) { int init = 0; for (Integer arg : args) { if (arg == null) { arg = 0; } init += arg; } return init; }
一、泛型实现-数据类型抽象
借鉴了网上大牛的代码，其实是可以实现的，用了所有数字类的基类Number，把所有类型都当做double类型处理，最后在转成相关类型
虽然牺牲了效率，但更优雅了
public <T extends Number> T getSum(T... args) { Double t = 0.0d; for (T arg : args) { t = t + arg.doubleValue(); } return (T) t; } public <T extends Number> T add(T t1, T t2) { Double all = 0.0d; all = t1.doubleValue() + t2.doubleValue(); return (T) (all); }
二、四则运算-运算符抽象
既然加法可以泛型实现，那么减法、乘除肯定也可以
我们继续抽象一下，把四则运算都实现了
public <T extends Number> T add(T t1, T t2) { Double all = 0.0d; all = t1.doubleValue() + t2.doubleValue(); return (T) (all); } public <T extends Number> T dif(T a, T b) { Double a1 = a == null ? 0.0d : a.doubleValue(); Double b1 = b == null ? 0.0d : b.doubleValue(); Double c1 = a1 - b1; return (T) c1; } public <T extends Number> T mul(T a, T b) { Double a1 = a == null ? 0.0d : a.doubleValue(); Double b1 = b == null ? 0.0d : b.doubleValue(); Double c1 = a1 * b1; return (T) c1; } public <T extends Number> T div(T molecular, T denominator) { Double result; if (denominator == null || denominator.equals(0L)) { result = 0d; } else { result = 100 * molecular.doubleValue() / denominator.doubleValue(); } return (T) result; }
数据类型抽象了，不管有多少不同的number类，我们都可以用一个方法实现。
但是对应加减乘除四则运算，我们还是需要写四个方法，那么运算符能不能抽象？
其实是可以的，我们可以基于java的函数式接口，把运算符也抽象了
public class Test { /** * 针对数字类型的二元操作 * @param t1 * @param t2 * @return * @param <T> */ public static <T extends Number> T binaryOp(T t1, T t2, BiFunction<T,T,T> operator) { T apply = operator.apply(t1, t2); return (T) (apply); } public static void main(String[] args) { Number sum = Test.binaryOp(5, 6, new AddOp()); System.out.println(sum); Number dif = Test.binaryOp(5.0d, 6.0d, new SubOp()); System.out.println(dif); Number product = Test.binaryOp(5l, 6l, new MulOp()); System.out.println(product); Number quo = Test.binaryOp(0x6, 0x3, new DivOp()); System.out.println(quo); } }
现在我们的方法就剩下一个，binaryOp，支持传入两个数字类型，和一个二元操作Function，
当然Function是可以自己定义的，也不仅限于加减乘除。
//加 public class AddOp implements BiFunction<Number, Number, Number> { @Override public Number apply(Number number1, Number number2) { return number1.doubleValue() + number2.doubleValue(); } } //除 public class DivOp implements BiFunction<Number, Number, Number> { @Override public Number apply(Number number1, Number number2) { return number1.doubleValue() / number2.doubleValue(); } } //乘 public class MulOp implements BiFunction<Number, Number, Number> { @Override public Number apply(Number number1, Number number2) { return number1.doubleValue() * number2.doubleValue(); } } //减 public class SubOp implements BiFunction<Number, Number, Number> { @Override public Number apply(Number number1, Number number2) { return number1.doubleValue() - number2.doubleValue(); } }
因为加减乘除是纯函数式编程，我们可以直接定义成单例模式
public class AddOp implements BiFunction<Number, Number, Number> { public static AddOp op = new AddOp(); public static AddOp get() { return op; } private AddOp() { } @Override public Number apply(Number number1, Number number2) { return number1.doubleValue() + number2.doubleValue(); } }
三、参数个数的抽象
我们目前的方法只能支持二元操作，假如我们的数据是可变参数、一个数组或一个集合类型，目前的函数就不够用了。
我们继续抽象一下，把二元操作，抽象为多元操作
首先支持可变参数列表，这样也就支持了数组
/** * 多元操作可支持多个操作对象,需要提供初始值 * 支持可变参数列表和数组 * @param operator * @param initialValue * @param args * @return * @param <T> */ public static <T extends Number> T multivariateOp(BiFunction<T, T, T> operator, T initialValue, T... args) { for (T arg : args) { initialValue = operator.apply(initialValue, arg); } return initialValue; }
但是如果我们的数据来源不是数组，而是来自一个集合或列表，上面的方法就不能用了
我们需要实现一个容器版本的方法，如下
现在所有的容器类，比如Set,List,Queue等实现Iterable的集合都能用了
public static <T extends Number> T multivariateOp(BiFunction<T, T, T> operator, T initialValue, Iterable<? extends T> args) { for (T arg : args) { initialValue = operator.apply(initialValue, arg); } return initialValue; }
四、迭代器版本
可以基于Iterator实现一个版本，这样不管你是可变参数列表，数组，还是集合类型，只要你能转成iterator,就可以使用这个方法。
这也是C++里面的算法常用的形式
public static <T extends Number> T multivariateOp(BiFunction<T, T, T> operator, T initialValue, Iterator<? extends T> args) { while (args.hasNext()) { T arg = args.next(); initialValue = operator.apply(initialValue, arg); } return initialValue; }
五、更一般版本
更多思考...
目前我们的函数已经适用于所有的Number子类，但如果我们要自定义一个复数类Complex，或者一个矩阵类Matrix,显而易见，上述方法是不能用的
因为我们限定了T的范围是Number的子类，那么如何破开这层限制，可以更一般的支持自定义类型呢？
首先我们分析下这个真正的桎梏到底在哪里呢？
我们已经支持了容器类，所以存放元素的容器不是问题了，已经基于函数式接口支持了自定义操作符，所以操作也不是问题
关键还在泛型类型T本身，如果我们让T不再限定为Number的子类，那会怎么样？
我们取消了T的限制，如下
public static <T> T multivariateOp(BiFunction<T, T, T> operator, T initialValue, T... args) { for (T arg : args) { initialValue = operator.apply(initialValue, arg); } return initialValue; }
然后我们自定义一个复数类Complex
public class Complex { int real;//实数 int imag;//虚数 public Complex(int real, int imag) { this.real = real; this.imag = imag; } @Override public String toString() { return "Complex{"+ real + "," + imag + '}'; } }
那么之前的AddOp已经不适用与复数版本，我们需要给复数专门定义操作符了
//复数加法 public class ComplexAddOp implements BiFunction<Complex,Complex,Complex> { //加法原点是(0,0) @Override public Complex apply(Complex complex1, Complex complex2) { return new Complex(complex1.real+complex2.real, complex1.imag+complex2.imag); } } //复数乘法 public class ComplexMulOp implements BiFunction<Complex,Complex,Complex> { //乘法原点是(1,0) @Override public Complex apply(Complex complex1, Complex complex2) { int a = complex1.real;//a=1,b=0 int b = complex1.imag; int c = complex2.real; int d = complex2.imag; return new Complex(a*c-b*d,b*c+a*d); } }
测试一下
public static void main(String[] args) { Complex complex00 = new Complex(1, 0); Complex complex0 = new Complex(0, 0); Complex complex1 = new Complex(1, 2); Complex complex2 = new Complex(3, 4); System.out.println(complex1); System.out.println(complex2); Complex complex = Test.multivariateOp(new ComplexAddOp(), complex0, complex1, complex2); System.out.println(complex); Complex complex3 = Test.multivariateOp(new ComplexMulOp(), complex00, complex1, complex2); System.out.println(complex3); }
输出：
Complex{1,2}
Complex{3,4}
Complex{4,6}
Complex{-5,10}
减法和除法与之相似，就不提供了。
如果定义一个矩阵，只需要定义相关的操作就可以了，或者自定义关系运算用于支持数据库操作，
这样我们的函数算是真正的泛型函数了，支持所有的类型。
todo：通过C++实现矩阵运算、关系运算
