Dynamic Programming Fibonacci Sequence

I would prefer a Map<Integer, BigInteger> over using a fixed BigInteger[] when performing this memoization. Note that your current approach is not recursive. The Map might be declared and initialized like

static Map<Integer, BigInteger> memo = new HashMap<>();
static {
    memo.put(0, BigInteger.ONE);
    memo.put(1, BigInteger.ONE);
}

Then check if the current n is present in the memo (if it is, return it) - otherwise, computer and store it. Like,

public static BigInteger fibRecurse(int n) {
    if (memo.containsKey(n)) {
        return memo.get(n);
    }
    BigInteger v = fibRecurse(n - 1).add(fibRecurse(n - 2));
    memo.put(n, v);
    return v;
}

A version without memoization would simply omit memo like

public static BigInteger fibRecurseSlow(int n) {
    if (n == 0 || n == 1) return BigInteger.ONE;
    BigInteger v = fibRecurse(n - 1).add(fibRecurse(n - 2));
    return v;
}

I think you can infer from the method names I've chosen which is slower.

import java.math.BigInteger;
import java.util.Arrays;
public class FibonacciNumbersB {
    static BigInteger[] dp = new BigInteger[10000];
    public static void main(String[] args) {
        dp[0] = BigInteger.ONE;
        dp[1] = BigInteger.ONE;
        int N = 9999;
         fibRecurse(N);
        for(int i = 0; i < N; i++)
            System.out.println(dp[i].toString()) ;
    }
    public static void fibRecurse(int N) {
        for(int i = 2; i < N; i++) {
                dp[i] = dp[i - 1].add(dp[i - 2]);
        }
    }
}