Performance q: decls in loops

Question

Performance question: declarations in loops
I'm wondering if there is any performance difference in the following two scenarios, discounting any special exceptions for special optimizing compilers etc -- just imagine a generic situation with the following two scenarios:
Scenario 1: declaration outside the loop
void someMethod() {
  String s;
  while (x != 0) {
    if (someCondition) {
      s = new String("SomeString");
Scenario 2: declaration inside the loop
void someMethod() {
  while (x != 0) {
    String s;
    if (someCondition) {
      s = new String("SomeString");
}Are there any design-related reasons to choose Scenario 2?

Answer 1

In scenario 2 the VM has to repeatedly re-allocate
memory for the object referece s (never mind what it
points to), and repeatedly garbage collect it.Thanks -- that answers my question and confirms what I had been thinking. I adopted this example code from page 640 of "Thinking In Java 2nd Edition" (Eckel), and was posting to find out whether or not there was some reason that he had written it that way. (If anyone is curious I have pasted the code at the end of this post, the book is freely downloadable at http://www.mindview.net/)
also the line
s = new String("SomeString");
is nearly as wastefull as
s = new String(new String("SomeString"))
It should be simplified to
s = "SomeString";Yeah, I read this in "Effective Java" by Bloch. Thanks for pointing it out though in case I didn't know that.
Are there any design-related reasons to choose
Scenario 2?
Maybe if you're testing performace of the garbage
collector or VM.LOL.
Here's the code, for the curious:
//: c11:WordCount.java
// From 'Thinking in Java, 2nd ed.' by Bruce Eckel
// www.BruceEckel.com. See copyright notice in CopyRight.txt.
// Counts words from a file, outputs
// results in sorted form.
import java.io.*;
import java.util.*;
class Counter {
  private int i = 1;
  int read() { return i; }
  void increment() { i++; }
public class WordCount {
  private FileReader file;
  private StreamTokenizer st;
  // A TreeMap keeps keys in sorted order:
  private TreeMap counts = new TreeMap();
  WordCount(String filename)
    throws FileNotFoundException {
    try {
      file = new FileReader(filename);
      st = new StreamTokenizer(
        new BufferedReader(file));
      st.ordinaryChar('.');
      st.ordinaryChar('-');
    } catch(FileNotFoundException e) {
      System.err.println(
        "Could not open " + filename);
      throw e;
  void cleanup() {
    try {
      file.close();
    } catch(IOException e) {
      System.err.println(
        "file.close() unsuccessful");
  void countWords() {
    try {
      while(st.nextToken() !=
        StreamTokenizer.TT_EOF) {
        String s;
        switch(st.ttype) {
          case StreamTokenizer.TT_EOL:
            s = new String("EOL");
            break;
          case StreamTokenizer.TT_NUMBER:
            s = Double.toString(st.nval);
            break;
          case StreamTokenizer.TT_WORD:
            s = st.sval; // Already a String
            break;
          default: // single character in ttype
            s = String.valueOf((char)st.ttype);
        if(counts.containsKey(s))
          ((Counter)counts.get(s)).increment();
        else
          counts.put(s, new Counter());
    } catch(IOException e) {
      System.err.println(
        "st.nextToken() unsuccessful");
  Collection values() {
    return counts.values();
  Set keySet() { return counts.keySet(); }
  Counter getCounter(String s) {
    return (Counter)counts.get(s);
  public static void main(String[] args)
  throws FileNotFoundException {
    WordCount wc =
      new WordCount(args[0]);
    wc.countWords();
    Iterator keys = wc.keySet().iterator();
    while(keys.hasNext()) {
      String key = (String)keys.next();
      System.out.println(key + ": "
               + wc.getCounter(key).read());
    wc.cleanup();
} ///:~