No, the length of a java string is O(1) because java's string class stores the length as a field.

The advice you've received is true of C, amongst other languages, but not java. C's strlen walks the char array looking for the end-of-string character. Joel's talked about it on the podcast, but in the context of C.

It is O(1) as the length is already known to String instance.

From JDK 1.6 it is visible.

public int length() {
    return count;
}

Update

It is important to understand why they can cache the value of count and keep using same value for count. The reason lies in a great decision they took when designing String, its Immutability.

Let n be the number of characters in your string. Your loop obviously iterates n times (since text.length() == n), with each iteration doing constant work (addition).

Your loop should be O(n)

EDIT: The other answers are wrong. You are not returning a string, nor appending to a StringBuilder. You are adding the int value of each ASCII character, and returning the total.

As told by OP, the problem and its the solution come from Elements of Programming Interviews in Java by Adnan Aziz, Tsung-Hsien Lee, and Amit Prakash.

Here is the excerpt of the book that analyzes the time-complexity of the solution.

The number of vertices is the number d of words in the dictionary. The number of edges is, in the worst-case, $O(d^2)$. The time complexity is that of BFS, namely $O(d + d^2) = O(d^2)$. If the string length $n$ is less than $d$ then the maximum number of edges out of a vertex is $O(n)$, implying an $O(nd)$ bound.

The above analysis in the book is correct. Please note "word" and "string" are used interchangeably here.

Here is OP's analysis, with the only modification that I use $d$ to denote the number of words so as to be consistent with the book.

The second loop is a constant (right?), it doesn't change with the size of $d$, so I don't think that is a part of the calculation for the run time.

OP's analysis is not wrong, either, if we assume that the length of the strings in the dictionary is bounded by a constant. This assumption is not unreasonable since it conforms to our ordinary experience about words in a normal dictionary. In fact, OP's analysis has been included in the book as well! It is the very last statement of the excerpt above.

Is there a logical inconsistency between the bounds $O(d^2)$ and $O(nd)$? No, since they apply to different situations with different assumptions. For example, in the worst case where every string differ in exactly one character with every other string, if we let $d$ go to infinity, then the maximal string length $n$ will goes to infinity as well. That is, "The second loop" does "change with the size of $d$"! Those strings are very unlikely to be words in our ordinary dictionary because of their huge lengths, of course.

In fact, in all cases, $d \leq 26n$. So $O(d^2)$ implies $O(nd)$.

New answer

As of update 6 within Java 7's lifetime, the behaviour of substring changed to create a copy - so every String refers to a char[] which is not shared with any other object, as far as I'm aware. So at that point, substring() became an O(n) operation where n is the numbers in the substring.

Old answer: pre-Java 7

Undocumented - but in practice O(1) if you assume no garbage collection is required, etc.

It simply builds a new String object referring to the same underlying char[] but with different offset and count values. So the cost is the time taken to perform validation and construct a single new (reasonably small) object. That's O(1) as far as it's sensible to talk about the complexity of operations which can vary in time based on garbage collection, CPU caches etc. In particular, it doesn't directly depend on the length of the original string or the substring.

For every call to String.concat(), a new string instance is created. To create that instance, the contents of the previous string needs to be copied to the new one plus the contents of the concatenated string. This is done for every string in the collection. So if you look at in in terms of how many strings are concatenated (and not the characters copied), you're copying the contents of the n strings by the time you reach the nth iteration and all that matters is the worst case (the last iteration). Therefore it has \$O(n^2)\$ performance.

Looking at OpenJKD, StringBuilder.toString() (1) ends up calling new String(char[], offset, count) (2), which calls Arrays.copyOfRange (3), which calls System.arrayCopy. At a certain level, this is going to end up moving n bytes in memory; however, the system is often able to utilize CPU-level block copy commands, which executes more quickly than copying n bytes one-at-a-time.

I think this algorithm is still n^2, since you're copying 1, then 2, then 3, ..., then n bytes. I don't think you can accomplish your goal any more quickly, since you have to copy this many bytes in order to fill out the array.

The string builder implementation is definitely more performant, since at each step, it writes a single byte into an array (that is already sized correctly!), and then copies that array to a different memory location.

Since you have both objects already, the time complexity is the same: it's O(1), because both java.lang.String and Java arrays store their length for direct retrieval.

However, you can improve upon the timing of your method by using getChars method of the string to avoid copying the characters past the end of the substring that you need:

int maxLength = 100;
int effectiveLength = Math.min(maxLength, str.length());
char[] strArray = new char[effectiveLength];
str.getChars(0, effectiveLength, strArray, 0);

If it happens that your algorithm can stop processing before reaching the end of the string, this approach would let you avoid allocating the extra memory and copying the characters into it.