Is there a benefit in using a single temp variable in a method?

Question

Often in code I get to scenarios I need a temporary variable - example:

String tempUserName = input.getUserName();
tempUserName = sanitzie(tempUserName);
validate(tempUserName);
// ... Do something else with tempUserName

String tempUserNickName = input.getUserNickName();
tempUserNickName = sanitzie(tempUserNickName);
validate(tempUserNickName);
// ... Do something else with tempUserNickName

...
...

I know that some people use a single temp variable for these kind of things:

String temp = input.getUserName();
temp = sanitzie(temp);
validate(temp);
// ... Do something else with temp

temp = input.getUserNickName();
temp = sanitzie(temp);
validate(temp);
// ... Do something else with temp

...
...

In my opinion - the way I write it is clearer and less error-prone.

My question is - are there any benefits for using the single temp variable from:

1. Memory consumption perspective
2. Performance perspective
3. Any other perspective

Lets limit the scope of the question to String variables only - but I'll be happy to get a more general feedback.

Answer 1

Memory consumption and performance are irrelevant, but every non-final var makes the code much harder to read. You can never see at a glance exactly where it is being reassigned and if there's a bug that you're looking for, this gives you a hard time. My suggestion, and what I routinely do in my code, is to extract to a method so you don't even need the local var at the calling side. Always tend to write code in terms of function composition.

Answer 2

I also prefer not reusing local variables, and performance aspects shouldn't matter here, because you would gain or lose such a tiny time that it's negligible. And the JIT could generate the same native code for both anyway.

What matters is readability and maintainability. And what I see in your code is that there should be an additional method, so that your original code becomes:

sanitizeAndValidate(input.getUserName());
sanitizeAndValidate(input.getUserNickName());

This makes the code clearer, more testable, avoids repetitions, and makes your initial question irrelevant, since your temp variable is only defined once, in the sanitizeAndValidate() method.

Answer 3

My main answer to this would be if you have a series of those sorts of statements, I'd break the groupings out into a separate function you call. (Which would have just the one temp variable.) E.g.:

private String handleInput(String val) {
    val = sanitzie(val);
    validate(val);
    // ... Do something else with val

    return val;
}

Usage:

String finalPlaceForUserName     = handleInput(input.getUserName());
String finalPlaceForUserNickName = handleInput(input.getUserNickName());

...where handleInput might return null for invalid or dangerous input, etc. You may well have to parameterize handleInput more than above.

Answer the perspectives you raised:

Memory consumption perspective

I suppose technically, if there were only one temp variable, the memory from earlier on would be eligible for garbage collection earlier (e.g., while the method was running rather than afterward). But I doubt it makes any real-world difference.

Performance perspective

I can't imagine so.

Any other perspective

We probably come down to style here, which is mostly a matter of personal preference. Again, I'd split it off into a function, which is kind of an end-run around the question. :-)

Answer 4

The performance difference (memory wise) is to small to be taken in consideration.

What's more important is to make your code readable, and optimize things where it matters.

Answer 5

Those repetitions occur though they are not nice style. I often do:

{
    String s = ...
    something with s;
}
{
    String s = ...
    something with s;
}