What would be preferred aesthetically and performance wise?
I agree mostly with @Vogel612's answer, the second version is more concise and there is no need to litter variables all over the place as is done in the first version.

Another point is that code should be self-documenting, which @Vogel612 also suggests, but else you can still add a comment behind the code lines.

My review

I wanted to talk about a more interesting point, as this question seems to be a subproblem of a bigger question of yours, which involves creating a high throughput program that does something with tweets.
Perhaps this is a premature optimization given that I do not know how well your program performs, but your program may very well hit a threshold limit because of the way you handle regexes.

You should consider what a String.replaceAll does:

public String replaceAll(String regex, String replacement) {
    return Pattern.compile(regex).matcher(this).replaceAll(replacement);
}


For every provided regex it creates a pattern and matches and replaces the occurences with the replacement.
It is also important to look into Pattern.replaceAll now:

public String replaceAll(String replacement) {
    reset();
    boolean result = find();
    if (result) {
        StringBuffer sb = new StringBuffer();
        do {
            appendReplacement(sb, replacement);
            result = find();
        } while (result);
        appendTail(sb);
        return sb.toString();
    }
    return text.toString();
}


Here you can see, that because of four regex replaces, you create four times a StringBuffer, which is synchronized, and a String object, which can count up if you are processing tons of tweets.

There are two things you can do:


Create a single regex that captures what you want to do, thus needing only one replaceAll call.
Go really into micro-optimizing and get rid of the regexes in a whole, operate on a char[] and only store the resulting character array.