1

I was going through this question and one of the answers gave 2 options and said the first one is probably faster.

I would like to know why?

The 2 options mentioned in the answer are

for(int i = 0, n = s.length() ; i < n ; i++) { 
    char c = s.charAt(i); 
}

or

for(char c : s.toCharArray()) {
    // process c
}
Community
  • 1
  • 1
gizgok
  • 7,303
  • 21
  • 79
  • 124

2 Answers2

4

The second answer suggested creates a char array and iterates over that. This mechanism is probably slower because of the additional overhead in creating the array prior to iterating over it; this overhead correlates with the length of the String.

A third method not mentioned in the answer you've referenced involves using a StringCharacterIterator; e.g.

CharacterIterator it = new StringCharacterIterator("Hello, World");
char c;

while ((c = it.next()) != CharacterIterator.DONE) {
  System.err.println("Char: " + c);
}

However, my personal preference would be to use the first index-based solution in the answer you reference.

Adamski
  • 54,009
  • 15
  • 113
  • 152
  • What if I changed the Char Array and store it in a variable and use the variable and also add the string.length() calculation? – gizgok Oct 14 '11 at 11:50
  • @gizgok: that wouldn't matter, since the *creation* of the char array would be the same, and that's (probably) the most relevant part. Also: Don't mind those micro-optimizations: they are **almost never** worth the time you invest in them. – Joachim Sauer Oct 14 '11 at 11:51
  • Yes agree with the micro optimization part, just wanted to know why of the way things work. – gizgok Oct 14 '11 at 12:00
0

This is slow:

for(int i = 0, n = s.length() ; i < n ; i++) { 
    char c = s.charAt(i); 
}

but can be faster like this: int length = s.length();

for(int i = 0, n = length ; i < n ; ++i) { 
    char c = s.charAt(i); 
}

where the differences: - extracted the length to a variable to prevent recalculate this again and again. - ++i is faster the i++ because does not need a temporal variable and garbage collection for it.

This is faster:

for(char c : s.toCharArray()) {
    // process c
}

because it uses an iterator, and can be optimized well by Java compiler. Iterators are always faster than simple loop (except some strange cases, where iterators do complex logic or resource hungry work)

But best to use that character iterator class in the other post here.

regards

Marcell
  • 973
  • 1
  • 6
  • 13
  • The length() implementation is typically O(1), simply returning a pre-computed constant so I don't think it's worth storing the value of length in a variable. I agree with you regarding ++i as best practice (although I would expect the compiler to optimise away the temporary variable in the case of i++). I disagree that the char array approach is better: It involves creating an entirely new array and copying data into that array. What if the String is 100 million characters in length? – Adamski Oct 14 '11 at 11:54
  • What do you mean by "i++" will need garbage collection? – Paul Cager Oct 14 '11 at 12:22