##Types

Given the description, I would assume that the return value is supposed to be `int[]` instead of `List<Integer>`....

... but, you are not using the more general `List<Integer>` value, but instead the `ArrayList<Integer>`. Always use the most general class type for your interfaces.

Also, by keeping the data as Integer values, you are doing a lot of boxing, and unboxing in the loops. Really, you should keep the calculations as Java primitives (`int`), and then box the results if needed.

## Conditions

Your code has a special-case for row 0, where it returns `[1]`. By preference, I recommend not having special cases, although it is a rule I bend often.

Still, after the `rowIndex == 0` special case, you then check to see whether it is `rowIndex >= 1`. This does not make sense because the `rowIndex == 0` case returned from the function, so the other condition is useless. Well, not quite useless, it avoids an error condition for negative values. But, the negative-value condition should have been checked at the method start. Basically, it is a useless check. Consider this restructure:

    if (rowIndex < 0) {
        throw new IllegalArgumentException("Nevative row");
    }
    if(rowIndex==0){
        toAdd.add(1);
        return toAdd;
    }

    toAdd = new ArrayList<Integer>();
    toAdd.add(1);
    toAdd.add(1);
    allList.add(toAdd);
    if(rowIndex==1){
        return toAdd;
    }

## Conclusion

I agree that the complexity is about *O(n<sup>2</sup>)*, but I know it must be psosible to do it faster. The data types are a problem, but the result looks accurate.

## Alternative...

So, I cheated, and looked at wiki, and it has a [relatively easy function for calculating the row values for a function][1]. I adapted it here. This is the way I would have done it, if I was able to google the algorithm. I would have used a similar approach to you, but as arrays-of-int instead, if I could not search the algorithm.

    public static final int[] pascalRow(final int row) {
        // using same names as wikipedia:
        // http://en.wikipedia.org/wiki/Pascal%27s_triangle#Calculating_a_row_or_diagonal_by_itself
        int n = row + 1;
        int[] ret = new int[n];
        int val = 1;
        final int mid = (n)/2;
        for (int k = 0; k <= mid; k++) {
            ret[k] = val;
            ret[n - 1 - k] = val;
            val = (int)(val * ((n - k - 1) / (double)(k + 1)));
        }
        return ret;
    }


  [1]: http://en.wikipedia.org/wiki/Pascal%27s_triangle#Calculating_a_row_or_diagonal_by_itself