Calculate Kth Row of Pascal's Triangle Purpose

Implement a solution that returns the values in the Nth row of Pascal's Triangle where N >= 0.

Math

First three rows of Pascal's Triangle:

    1
  1   1
1   2   1
...
...


These row values can be calculated by the following methodology:


For a given non-negative row index, the first row value will be the binomial coefficient where n is the row index value and k is 0).
The next row value would be the binomial coefficient with the same n-value (the row index value) but incrementing the k-value by 1, until the k-value is equal to the row index value.


Implementation

There are two things the calculator would need in order to operate correctly:


A Binomial Coefficient Calculator, which it would depend on directly
A Factorial Calculator, which the Binomial Coefficient Calculator would depend on directly




public class FactorialCalculator {

  public static int calculateFactorial(int n) {
    if (n &lt; 0) {
      throw new IllegalArgumentException("n value should be non-negative");
    }

    int factorialValue = 1;

    if (n == 0) {
      return factorialValue;
    }

    for (int multiplier = n; multiplier &gt; 0; multiplier--) {
      factorialValue *= multiplier;
    }

    return factorialValue;
  }
}

public class BinomialCoefficientCalculator {

  public static int calculateBinomialCoefficient(int n, int k) {
    if (n &lt; 0) {
      throw new IllegalArgumentException("n value cannot be negative");
    }

    if (k &lt; 0) {
      throw new IllegalArgumentException("k value cannot be negative");
    }

    if (n &lt; k) {
      throw new IllegalArgumentException("n value cannot be less than k value");
    }

    return FactorialCalculator.calculateFactorial(n) / (FactorialCalculator.calculateFactorial(k) * FactorialCalculator.calculateFactorial(n - k));
  }
}

public class PascalsTriangleRowValuesCalculator {

  public static List&lt;Integer&gt; calculateRowValues(int rowIndex) {
    if (rowIndex &lt; 0) {
      throw new IllegalArgumentException("row index must be non-negative");
    }

    List&lt;Integer&gt; rowValues = new ArrayList&lt;&gt;();
    for (int k = 0; k &lt;= rowIndex; k++ ) {
      rowValues.add(BinomialCoefficientCalculator.calculateBinomialCoefficient(rowIndex, k));
    }
    return rowValues;
  }
}
In case n == 0 the loop body of calculateFactorial wouldn't be executed at all, and factorialValue would remain 1. You may safely remove the special case test.
The calculations of the binomial wastes time by recomputing factorials of the same number over and over again. The way the main loop in calculateRowValues is set up exaggerates the problem. Consider precomputing the list of required factorials once.
The code begins to fail at fairly small n: \$14!\$ is already beyond the 32-bit range. I recommend drop the factorial approach whatsoever, and compute the next row directly from the previous, using an \$\binom{n+1}{k} = \binom{n}{k-1} + \binom{n}{k}\$ identity.