Which loop has better performance? Why?

by

Limited Scope is Best

Use your second option:

for ( ... ) {
  String s = ...;
}

Scope Doesn’t Affect Performance

If you disassemble code the compiled from each (with the JDK’s javap tool), you will see that the loop compiles to the exact same JVM instructions in both cases. Note also that Brian R. Bondy’s “Option #3” is identical to Option #1. Nothing extra is added or removed from the stack when using the tighter scope, and same data are used on the stack in both cases.

Avoid Premature Initialization

The only difference between the two cases is that, in the first example, the variable s is unnecessarily initialized. This is a separate issue from the location of the variable declaration. This adds two wasted instructions (to load a string constant and store it in a stack frame slot). A good static analysis tool will warn you that you are never reading the value you assign to s, and a good JIT compiler will probably elide it at runtime.

You could fix this simply by using an empty declaration (i.e., String s;), but this is considered bad practice and has another side-effect discussed below.

Often a bogus value like null is assigned to a variable simply to hush a compiler error that a variable is read without being initialized. This error can be taken as a hint that the variable scope is too large, and that it is being declared before it is needed to receive a valid value. Empty declarations force you to consider every code path; don’t ignore this valuable warning by assigning a bogus value.

Conserve Stack Slots

As mentioned, while the JVM instructions are the same in both cases, there is a subtle side-effect that makes it best, at a JVM level, to use the most limited scope possible. This is visible in the “local variable table” for the method. Consider what happens if you have multiple loops, with the variables declared in unnecessarily large scope:

void x(String[] strings, Integer[] integers) {
  String s;
  for (int i = 0; i < strings.length; ++i) {
    s = strings[0];
    ...
  }
  Integer n;
  for (int i = 0; i < integers.length; ++i) {
    n = integers[i];
    ...
  }
}

The variables s and n could be declared inside their respective loops, but since they are not, the compiler uses two “slots” in the stack frame. If they were declared inside the loop, the compiler can reuse the same slot, making the stack frame smaller.

What Really Matters

However, most of these issues are immaterial. A good JIT compiler will see that it is not possible to read the initial value you are wastefully assigning, and optimize the assignment away. Saving a slot here or there isn’t going to make or break your application.

The important thing is to make your code readable and easy to maintain, and in that respect, using a limited scope is clearly better. The smaller scope a variable has, the easier it is to comprehend how it is used and what impact any changes to the code will have.

More Related Contents:

  1. Garbage collection behaviour for String.intern()
  2. StringBuilder vs String concatenation in toString() in Java
  3. How can I read a large text file line by line using Java?
  4. When to use StringBuilder in Java [duplicate]
  5. Garbage collection of String literals
  6. When will a string be garbage collected in java
  7. Does setting Java objects to null do anything anymore?
  8. Fastest way to iterate over all the chars in a String
  9. Should I use Java’s String.format() if performance is important?
  10. How can I avoid garbage collection delays in Java games? (Best Practices) [closed]
  11. Performance penalty of String.intern()
  12. Why does appending “” to a String save memory?
  13. Know of any Java garbage collection log analysis tools? [closed]
  14. Garbage collection on intern’d strings, String Pool, and perm-space
  15. Java Collections and Garbage Collector
  16. Fastest way to strip all non-printable characters from a Java String
  17. Java split String performances
  18. What is the Metadata GC Threshold and how do I tune it?
  19. Is there a memory-efficient replacement of java.lang.String?
  20. Java very large heap sizes [closed]
  21. What GC parameters is a JVM running with?
  22. Measuring time spent on GC
  23. String replace method is not replacing characters
  24. How to split a String by space
  25. Splitting on comma outside quotes
  26. Java Strings: “String s = new String(“silly”);”
  27. How to Split a mathematical expression on operators as delimiters, while keeping them in the result?
  28. Convert a String of Hex into ASCII in Java
  29. Java: How to convert a string (HH:MM:SS) to a duration?
  30. Remove all occurrences of \ from string

Leave a Comment