Integer to String recursive method
Such an algorithm is very rarely used, so it is extremely unlikely that its performance matters. So, most chances are you do not need to optimize it at all. But if you insist:
Do not pre-initialize the 'hundred' and 'thousand' StringBuffers. Only initialize them if they are needed. As a matter of fact, it is good practice (though it does not have anything to do with performance) to not even declare them outside of the narrowest possible scope in which they will be used.  By the way, I do not understand why 'hundred' and 'thousand' are StringBuffers instead of Strings.
You do not need HashMaps for this job; just use arrays of String. They will be faster.
It seems like the kind of recursion you are using is tail recursion, so you can trivially convert your function to work iteratively, which will probably yield better performance. I am not saying it will necessarily perform better, so write both versions and benchmark one against the other if you really care about performance. But if you do not, then keep the recursive version, it is way cooler, and even easier to read.
When you append to a StringBuffer, never append multiple strings concatenated with +. Always use a separate call to append() for each string.  Otherwise, the compiler will very likely be creating more temporary StringBuffers behind your back in order to optimize your string append operations.
Considering that any number minus zero is still the same number, you can optimize this:

int temp = num % 1000;
if (temp == 0) {
    numRep.append(representation(num / 1000) + "-" + thousand);
} else {
    numRep.append(representation((num - temp) / 1000) + "-" + thousand
            + "-" + representation(temp));
}


into this:

int temp = num % 1000;
numRep.append( representation( (num - temp) / 1000) );
numRep.append( "-" );
numRep.append( thousand );
if( temp != 0 ) 
{
    numRep.append( "-" );
    numRep.append( representation( temp ) );
}