私は興味深い問題に遭遇し、これをJavaで実行できるかどうか、またどのように実行できるのか疑問に思いました。任意の関数/メソッドをメモできるメソッドを作成します。メソッドには次の引数があります:メソッド/関数とその引数。
たとえば、私がこのメソッドを持っているとしましょう:
int addOne(int a) { return a + 1;}
そして、同じ引数を使用してメモ化メソッドを2回呼び出します。たとえば、addOneと5の場合、最初の呼び出しは実際にaddOneメソッドを呼び出して結果を返し、その指定された引数の結果を格納する必要があります。 2回目に電話をかけると、これが以前に呼び出されたことを認識し、前の回答を調べる必要があります。
私の考えは、HashMap<Callable,HashMap<List<Objects>,Object>>
のようなものを用意して、前の回答を保存し、後で検索することです。これはラムダ式で何とかできると思いますが、私はそれらにあまり詳しくありません。 mこのメソッドの書き方がよくわからないので、助けていただければ幸いです。
これはこのアプローチで行うことができますか?
Java 8では、次のように実行できます。
Map<Integer, Integer> cache = new ConcurrentHashMap<>();
Integer addOne(Integer x) {
return cache.computeIfAbsent(x -> x + 1);
}
これは良いチュートリアルです。あらゆる方法で作成されています。
チュートリアルから:
メモ化クラス:
public class Memoizer<T, U> {
private final Map<T, U> cache = new ConcurrentHashMap<>();
private Memoizer() {}
private Function<T, U> doMemoize(final Function<T, U> function) {
return input -> cache.computeIfAbsent(input, function::apply);
}
public static <T, U> Function<T, U> memoize(final Function<T, U> function) {
return new Memoizer<T, U>().doMemoize(function);
}
}
クラスの使用方法:
Integer longCalculation(Integer x) {
try {
Thread.sleep(1000);
} catch (InterruptedException ignored) {
}
return x * 2;
}
Function<Integer, Integer> f = this::longCalculation;
Function<Integer, Integer> g = Memoizer.memoize(f);
public void automaticMemoizationExample() {
long startTime = System.currentTimeMillis();
Integer result1 = g.apply(1);
long time1 = System.currentTimeMillis() - startTime;
startTime = System.currentTimeMillis();
Integer result2 = g.apply(1);
long time2 = System.currentTimeMillis() - startTime;
System.out.println(result1);
System.out.println(result2);
System.out.println(time1);
System.out.println(time2);
}
出力:
2
2
1000
0
パラメータの型安全性を放棄したい場合は、Java 8のMethodHandle
sとラムダを使用して任意の関数をメモ化できます。
public interface MemoizedFunction<V> {
V call(Object... args);
}
private static class ArgList {
public Object[] args;
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof ArgList)) {
return false;
}
ArgList argList = (ArgList) o;
// Probably incorrect - comparing Object[] arrays with Arrays.equals
return Arrays.equals(args, argList.args);
}
@Override
public int hashCode() {
return args != null ? Arrays.hashCode(args) : 0;
}
}
public static <V> MemoizedFunction<V> memoizeFunction(Class<? super V> returnType, Method method) throws
IllegalAccessException {
final Map<ArgList, V> memoizedCalls = new HashMap<>();
MethodHandles.Lookup lookup = MethodHandles.lookup();
MethodHandle methodHandle = lookup.unreflect(method)
.asSpreader(Object[].class, method.getParameterCount());
return args -> {
ArgList argList = new ArgList();
argList.args = args;
return memoizedCalls.computeIfAbsent(argList, argList2 -> {
try {
//noinspection unchecked
return (V) methodHandle.invoke(args);
} catch (Throwable throwable) {
throw new RuntimeException(throwable);
}
});
};
}
これにより、関数を囲む可変アリティラムダが作成され、ラムダが構築された後、call(Object...args)
を使用しているため、関数を直接呼び出すのとほぼ同じ速度で実行されます(つまり、MethodHandle.invoke()
内でリフレクションは発生しません)。 Method.invoke()
の代わりに。
ラムダ(匿名クラスに置き換える)とMethodHandles(Method.invokeに置き換える)なしでもこれを行うことができますが、パフォーマンスを重視するコードにとってこれを魅力的にしないパフォーマンスペナルティがあります。