Function to generate all valid parentheses of n*2
isCombinationValid


          for(int i=0 ; i &lt; comb.length() ; i++)
          {
              char current = comb.charAt(i);



Since you never use i for anything other than generating current, you could just 

          for (char current : comb.toCharArray())
          {


This way you wouldn't have to manage i at all.  


        if(st.isEmpty())
        {
            return true;
        }
        else
        {
            return false;
        }



This is more complicated than need be.  

        return st.isEmpty();


This has the same result in seven fewer lines.  


            if(current == '(')
            {
                st.push('(');
            }
            else
            {
                if(!st.isEmpty() &amp;&amp; st.peek() == '(')
                {
                    st.pop();
                }
                else
                {
                    st.push(')');
                }
            }



Instead, you can say 

            if (current == '(')
            {
                st.push('(');
            }
            else if (st.isEmpty())
            {
                return false;
            }
            else
            {
                st.pop();
            }


You know that anything in the stack must be a '(', so you don't need to peek to check.  And if you ever find an extra ')', you can quit immediately.  You already know that it's not well-formed.  So if the first character is a ')', you don't even have to go through the rest of the string.  

I prefer not to use an else with an if !.  I just find the logic easier to follow this way.  And I switched to the more common else if rather than 

getAllPossibleCombinations


        if (presentCombinations.isEmpty())
        {
            temp.add("(");
            temp.add(")");
        }
        else //From second call, add ( and ) for current values in stack
        {



You are doing this with each recursive call, but that's not necessary.  Rather than do this in getAllPossibleCombinations, replace 


        ArrayList&lt;String&gt; allCombinations = getAllPossibleCombinations(2*a,new ArrayList&lt;String&gt;());
        ArrayList&lt;String&gt; prunedCombinations = new ArrayList&lt;String&gt;(); 



        for(String comb : allCombinations)


with

        List&lt;String&gt; initialCombinations = new ArrayList&lt;&gt;();
        initialCombinations.add("(");

        List&lt;String&gt; prunedCombinations = new ArrayList&lt;&gt;(); 
        for (String comb : getAllPossibleCombinations(2*a, initialCombinations)))


You don't need the ")" one at all, because no valid version can start with a closing parenthesis.  

I also changed your use of ArrayList&lt;String&gt; as the variable type to just use List&lt;String&gt;.  Unless you use some functionality specific to ArrayList, it is generally better to use the interface (List) rather than the implementation (ArrayList) as the type.  This makes it easier to change the implementation in the future.  

I also changed the right hand side to use the newer &lt;&gt; notation.  It's possible that your Java doesn't support that.  If so, just leave it as &lt;String&gt;.  

One might argue that this makes getAllPossibleCombinations less reusable, as you have to pass a specific opening parameter.  This is true, but it was also true of your original.  To get around this, you can specify a version that does not require a List to be passed:  

    public List&lt;String&gt; getAllPossibleCombinations(int maximumPairCount) {
        List&lt;String&gt; initialCombinations = new ArrayList&lt;&gt;();
        initialCombinations.add("(");

        return getAllPossibleCombinations(maximumPairCount - 1, initialCombinations);
    }


Now you could declare the two parameter version private, as all consumers should call this version instead.  And you can get rid of your isEmpty check, as it will never be called that way.  This won't shorten your code, but it will make it run faster, as you save checking isEmpty for nearly every call.  

Optimization

The code that you link checks for validity as it builds the string.  If you do that, you don't have to save invalid combinations like "))))".  Since there are \$2^{2*n}\$ combinations but only a smaller number of these are valid, this should make your program take longer to run out of memory.  

Note that if you do this, you don't return false if the stack has extra '(' in it.  It's valid for a partial expression to have unmatched '('.  What's invalid is unmatched ')'.