题
是这样的可能在Java中吗?
for (Object o : objects) {
for (Function f : functions) {
f(o);
}
}
我只是调用的函数了一把,但我需要撰写他们,就像这样:
for (Object o : objects) {
for (Function f : functions) {
for (Function g : functions) {
f(g(o));
}
}
}
和我想避免写出几百个函数调用行。
我试过研究函数指针和函子,但没有发现任何相关的。
解决方案
您不能使用f(g(o))
语法,但可以使用(与合适的接口)f.call(g.call(o))
。
public interface UnaryFunction<Arg, Ret> {
Ret call(Arg arg);
}
用法示例(这是接近你可以在Java中,函数子至少要等到倒闭使其进入语言):
public class Exp implements UnaryFunction<Double, Double> {
public Double call(Double arg) {
return Math.exp(arg);
}
}
如果你不希望创建一个数不胜数类,基于反射的方法可能更好地工作(例如对于double
- > double
功能java.lang.Math
,但很容易适应其他场景):
public class MathUnary implements UnaryFunction<Double, Double> {
private final Method method;
public MathUnary(String funName) {
try {
method = Math.class.getMethod(funName, double.class);
} catch (NoSuchMethodException exc) {
throw new IllegalArgumentException(exc);
}
if (method.getReturnType() != double.class)
throw new IllegalArgumentException();
}
public Double call(Double arg) {
try {
return (Double) method.invoke(null, arg);
} catch (IllegalAccessException exc) {
throw new AssertionError(exc);
} catch (InvocationTargetException exc) {
throw new AssertionError(exc);
}
}
}
(异常消息已省去为了简洁,很明显,我把他们在生产代码。)
示例用法:
MathUnary[] ops = {
new MathUnary("sin"), new MathUnary("cos"), new MathUnary("tan")
};
for (UnaryFunction<Double, Double> op1 : ops) {
for (UnaryFunction<Double, Double> op2 : ops) {
op1.call(op2.call(arg));
}
}
其他提示
Java并没有真正做仿函数完全是,但你可以得到相当接近与接口。我reccommend也许想这样的事情。
public interface Function {
Object doWork(Object o);
}
public class Function1 implements Function {
public Object doWork(Object o) {
...
}
}
...
然后在你的代码,你会创建一个包含功能1,函数2 ...对象的数组或列表和运行的东西,看起来很像你的代码。
for (Object o : objects) {
for (Function f : functionList) {
f.doWork(o);
}
}
或者,对于两个嵌套层次:
for (Object o : objects) {
for (Function f : functionList1) {
for (Function g : functionList2) {
f.doWork(g.doWork(o));
}
}
}
@Seth - 这里是您的泛型例子。由于在运行时不存在仿制药,我不明白为什么你害怕的“灵活性”的损失。如果您使用泛型,那么你只是使用对象。
如果您想根据G的回归F型的行为改变,那么你就只需要声明的F到做一些事情,如F,易peasy。
//=== Function.java
public interface Function<ReturnType, Type> {
ReturnType doWork(Type arg);
}
//=== SomethingWeird.java
import java.util.*;
// yo dawg, i heard you liked functions. so i put a function in yo'
// function, so you can derive while you derive.
public class SomethingWeird {
public static <FReturnType, FType, GType> List<FReturnType> collateOrSomething(
Iterable<GType> objects,
Iterable<Function<FReturnType, FType>> fList,
Iterable<Function<FType, GType>> gList
) {
List<FReturnType> results = new ArrayList<FReturnType>();
for (GType garg : objects) {
for (Function<FReturnType, FType> f : fList) {
for (Function<FType, GType> g : gList) {
results.add(f.doWork(g.doWork(garg)));
}
}
}
return results;
}
}
//=== SomethingWeirdTest.java
import java.util.*;
import org.junit.*;
import static org.junit.Assert.*;
public class SomethingWeirdTest {
// this is kinda silly, and...
public static class F1 implements Function<Integer, Double> {
@Override
public Integer doWork(Double arg) {
return arg.intValue();
}
}
// ...this has all kinds of autoboxing madness, but...
public static class F2 implements Function<Integer, Double> {
@Override
public Integer doWork(Double arg) {
double ceil = Math.ceil(arg);
return (int) ceil;
}
}
// ...why you'd want to do something like this is quite beyond me...
public static class G1 implements Function<Double, String> {
@Override
public Double doWork(String arg) {
return Math.PI * arg.length();
}
}
// ...ditto this...
public static class G2 implements Function<Double, String> {
@Override
public Double doWork(String arg) {
return Math.E * arg.length();
}
}
// oh, yeah, it was so we could test this weird thing
@Test
public void testCollateOrSomething() {
List<String> data = Arrays.asList("x", "xx", "xxx");
List<Function<Integer, Double>> fList = Arrays.asList(new F1(), new F2());
List<Function<Double, String>> gList = Arrays.asList(new G1(), new G2());
List<Integer> results = SomethingWeird.collateOrSomething(data, fList, gList);
assertEquals(12, results.size());
// x
assertEquals(3, (int) results.get(0));
assertEquals(2, (int) results.get(1));
assertEquals(4, (int) results.get(2));
assertEquals(3, (int) results.get(3));
// xx
assertEquals(6, (int) results.get(4));
assertEquals(5, (int) results.get(5));
assertEquals(7, (int) results.get(6));
assertEquals(6, (int) results.get(7));
// xxx
assertEquals(9, (int) results.get(8));
assertEquals(8, (int) results.get(9));
assertEquals(10, (int) results.get(10));
assertEquals(9, (int) results.get(11));
}
}
也许你可以尝试流畅的介面,将让你们这帮这些结合在一起。这可能是一个不错的设计,但我无法从你的例子告诉我们。
不隶属于 StackOverflow