Java memoization-Methode

Stieß ich auf ein Interessantes problem und Frage mich, ob und wie könnte man das in Java:
Erstellen Sie eine Methode, die kann memoize jede Funktion/Methode . Die Methode hat die folgenden Argumente : die Methode/Funktion und argument(s) für Sie.

Lass Sie uns zum Beispiel sagen, dass ich diese Methode :

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

und ich rufe meine memoization-Methode zwei mal mit den gleichen Argumenten : addOne und 5 zum Beispiel, der erste Anruf sollte tatsächlich rufen Sie die Methode addOne und das Ergebnis zurückgeben und speichern auch das Ergebnis für das angegebene argument. Das zweite mal, wenn ich es nennen sollte wissen, wurde dies genannt, die vor und schauen Sie einfach die Vorherige Antwort.

Meine Idee wäre, so etwas wie ein HashMap<Callable,HashMap<List<Objects>,Object>> wo Sie speichern die bisherigen Antworten und schauen Sie Sie später auf.Ich denke, das lässt sich irgendwie erledigt mit lambda-Ausdrücke, aber ich bin nicht vertraut mit Ihnen.Ich bin mir nicht ganz sicher, wie Sie Sie schreiben, die diese Methode und würde schätzen etwas Hilfe.

Kann dies gemacht werden mit diesem Ansatz?

möglich, Duplikat der Was sind die verschiedenen Techniken für memoization in Java?
Blick in die Proxyfunktion Mechanismen mit Java. Sie können erstellen Sie einen proxy ein Objekt, das fängt die Methodenaufrufe, die Speicherung der return-Wert. Wenn Sie die Methode aufrufen mit den gleichen Argumenten wie einem früheren Aufruf, Sie würde das gleiche Ergebnis erhalten die zimmerreserviereung, ohne das aufrufen des zugrunde liegenden Methode. Spring caching macht das für Sie.

InformationsquelleAutor Alex | 2014-12-18

In Java 8 kann man das so machen, dass:

Map<Integer, Integer> cache = new ConcurrentHashMap<>();

Integer addOne(Integer x) {
    return cache.computeIfAbsent(x -> x + 1);
}

Dies ist ein gutes tutorial. Es ist für jede Methode.

Aus dem tutorial:

Den Memoizer Klasse:

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);
    }
}

Benutzung der Klasse:

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);
}

Ausgabe:

Das ist zwar ein nettes snippet es gibt keine Antwort auf die OPs-Frage, die war, wie memoize beliebiger - Funktion
Du hast nicht gelesen, der link, richtig? Ich bearbeitet meine post, so dass es klarer ist.
Du hast Recht, wusste ich nicht, vielen Dank für die Klarstellung, ich habe entfernt die -1
computeIfAbsent(key, function::apply) ist funktional einfach mit der Funktion als computeIfAbsent(key, function). Außer letzteren schafft man weniger lambda-Instanz.

InformationsquelleAutor code monkey

Können Sie memoize jede Funktion, die mit Java 8 ist MethodHandles und Lambda-Ausdrücke, wenn Sie bereit sind zu geben, geben Sicherheit auf die Parameter:

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);
            }
        });
    };
}

Beispiel

Dies erstellt eine variable stelligkeit lambda, welches die Funktion und die ist fast so schnell wie der Aufruf der Funktion direkt (d.h., keine Reflexion passiert, innerhalb von call(Object...args)) nach der lambda-Ausdruck konstruiert, da wir mit MethodHandle.invoke() statt Method.invoke().

Können Sie noch tun, ohne lambdas (ersetzen mit anonymen Klassen) und MethodHandles (ersetzen mit der Methode.aufrufen), aber es wird performance-Strafen, machen diese weniger attraktiv für performance-bewusste code.

Nice one! Gab es eine Planung der Verwendung des returnType argument, das aktuell nicht verwendet wird?
Ich denke, dass es gemeint war, verwendet werden, um die Validierung der Rückgabetyp der Method, und wurde einfach vergessen.
sollte nicht zurück geben, gebunden als ? extends V statt? Wenn Methode, eigentlich gibt etwas, das ist ? super V, dann ist es nicht wirklich eine args -> V lambda, und Gießen zurückgegebene Wert ist nicht sicher.

InformationsquelleAutor Darth Android

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.