web-dev-qa-db-ja.com

Javaメモ化メソッド

私は興味深い問題に遭遇し、これをJavaで実行できるかどうか、またどのように実行できるのか疑問に思いました。任意の関数/メソッドをメモできるメソッドを作成します。メソッドには次の引数があります：メソッド/関数とその引数。

たとえば、私がこのメソッドを持っているとしましょう：

int addOne(int a) { return a + 1;}

そして、同じ引数を使用してメモ化メソッドを2回呼び出します。たとえば、addOneと5の場合、最初の呼び出しは実際にaddOneメソッドを呼び出して結果を返し、その指定された引数の結果を格納する必要があります。 2回目に電話をかけると、これが以前に呼び出されたことを認識し、前の回答を調べる必要があります。

私の考えは、HashMap<Callable,HashMap<List<Objects>,Object>>のようなものを用意して、前の回答を保存し、後で検索することです。これはラムダ式で何とかできると思いますが、私はそれらにあまり詳しくありません。 mこのメソッドの書き方がよくわからないので、助けていただければ幸いです。

これはこのアプローチで行うことができますか？

javalambdamemoization
13
Alex

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
20
code monkey

パラメータの型安全性を放棄したい場合は、Java 8のMethodHandlesとラムダを使用して任意の関数をメモ化できます。

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に置き換える）なしでもこれを行うことができますが、パフォーマンスを重視するコードにとってこれを魅力的にしないパフォーマンスペナルティがあります。

6
Darth Android