¿Cuáles son las diferentes técnicas para la memorización en Java?

Question

Sé de este http://onjava.com/pub/a/onjava/2003/08/20/memoization.html pero ¿hay algo más?

Answer 1

memoization es también fácil con una simple typesafe llanura de Java.

Puede hacerlo desde cero con las siguientes clases reutilizables.

Utilizo estos como cachés cuya vida útil es la solicitud en una aplicación web.

Por supuesto, use la Guava MapMaker si necesita una estrategia de desalojo o más funciones como la sincronización.

Si necesita memorizar un método con muchos parámetros, simplemente coloque los parámetros en una lista con ambas técnicas, y pase esa lista como el parámetro único.

abstract public class Memoize0<V> { 
    //the memory 
    private V value; 
    public V get() { 
     if (value == null) { 
      value = calc(); 
     } 
     return value; 
    } 
    /** 
    * will implement the calculation that 
    * is to be remembered thanks to this class 
    */ 
    public abstract V calc(); 
} 

abstract public class Memoize1<P, V> { 
    //The memory, it maps one calculation parameter to one calculation result 
    private Map<P, V> values = new HashMap<P, V>(); 

    public V get(P p) { 
     if (!values.containsKey(p)) { 
      values.put(p, calc(p)); 
     } 
     return values.get(p); 
    } 

    /** 
    * Will implement the calculations that are 
    * to be remembered thanks to this class 
    * (one calculation per distinct parameter) 
    */ 
    public abstract V calc(P p); 
} 

Y esto se utiliza como esto

Memoize0<String> configProvider = new Memoize0<String>() { 
     @Override 
     public String calc() { 
      return fetchConfigFromVerySlowDatabase(); 
     } 
    }; 
    final String config = configProvider.get(); 

    Memoize1<Long, String> usernameProvider = new Memoize1<Long, String>() { 
     @Override 
     public String calc(Long id) { 
      return fetchUsernameFromVerySlowDatabase(id); 
     } 
    }; 
    final String username = usernameProvider.get(123L); 

Answer 2

Sí. Use caches de Guava.

Ejemplo:

import java.math.BigInteger; 

import com.google.common.base.Preconditions; 
import com.google.common.cache.CacheBuilder; 
import com.google.common.cache.CacheLoader; 
import com.google.common.cache.LoadingCache; 

public class Fibonacci { 
    private static final LoadingCache<Integer, BigInteger> CACHE 
      = CacheBuilder.newBuilder().build(CacheLoader.from(Fibonacci::fib)); 

    public static BigInteger fib(int n) { 
     Preconditions.checkArgument(n >= 0); 
     switch (n) { 
     case 0: 
      return BigInteger.ZERO; 
     case 1: 
      return BigInteger.ONE; 
     default: 
      return CACHE.getUnchecked(n - 1).add(CACHE.getUnchecked(n - 2)); 
     } 
    } 
} 

Answer 3

Para memoize funciones sin parámetros, el uso de guayaba Suppliers.memoize(Supplier). Para funciones con parámetros, use CacheBuilder.build(CacheLoader) con objetos de valor de parámetro como claves.