We want to write a function that generates accumulators-- a function that takes a number n, and returns a function that takes another number i and returns n incremented by i. See the article Revenge of the Nerds http://www.paulgraham.com/icad.html

Accumulator.groovy

def foo(n) {
    return {n += it}
}

def accumulator = foo(1)
assert accumulator(2) == 3
assert accumulator(3) == 6

Accumulator.java

public class Accumulator {

    public interface Inttoint {
        public int call(int i);
    }

    public static Inttoint foo(final int n) {
        return new Inttoint() {
            int s = n;
            public int call(int i) {
                s = s + i;
                return s;
            }};
    }

    public static void main(String... args) {
        Inttoint accumulator = foo(1);

        System.out.println(accumulator.call(2) == 3);
        System.out.println(accumulator.call(3) == 6);
    }

}

Accumulator8.java

import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Function;

public class Accumulator8 {

    public static Function<Integer,Integer> foo(int n) {
        return new AtomicInteger(n)::addAndGet;
    }

    public static void main(String... args) {

        Function<Integer, Integer> accumulator = foo(1);

        System.out.println(accumulator.apply(2) == 3);
        System.out.println(accumulator.apply(3) == 6);

    }

}