For example, class A calls a method in class B. It passes some values (which take a long time to compute). If the values are passed lazily then class B can decide when and if to compute them. It is up to class A to implement the code for how to evaluate the value. So maybe there are 3 lazy values passed and class B decides it doesn't need to use value 1 but it does use values 2 and 3 (perhaps invoking each evaluation in separate threads, to maximise performance). The code to evaluate value 1 is never called, the code to evaluate values 2 and 3 will be called once and only once. Subsequent retrievals of a lazily evaluated value will return a cached copy of the value (unless the lazy evaluator is reset... see the code below).
Here is the class:
public abstract class Lazy<T> { private boolean _evaluated = false; private T _value = null; public final T get() { if (!_evaluated) { _value = evaluate(); _evaluated = true; } return _value; } public void reset() { _evaluated = false; _value = null; } protected abstract T evaluate(); }
... and here is how to use it:
// Setup. final float height = 7.0f; // Create the lazy. Lazy<Float> halfHeight = new Lazy<Float>() { public Float evaluate() { return height / 2; } }; // Get it's value. halfHeight.get();
And that's all you need. This code is completely free to use by anybody. It is held under the Do What You Want To Public License: http://tinyurl.com/DWYWTPL
