How should substring() work?

Question

I do not understand why Java's String.substring() method is specified the way it is. I can't tell it to start at a numbered-position and return a specified number of characters; I have to compute the end position myself. And if I specify an end position beyond the end of the String, instead of just returning the rest of the String for me, Java throws an Exception.

I'm used to languages where substring() (or substr()) takes two parameters: a start position, and a length. Is this objectively better than the way Java does it, and if so, can you prove it? What's the best language specification for substring() that you have seen, and when if ever would it be a good idea for a language to do things differently? Is that IndexOutOfBoundsException that Java throws a good design idea, or not? Does all this just come down to personal preference?

Answer 1

If you leave off the 2nd parameter it will go to the end of the string for you without you having to compute it.

Answer 2

second parameter should be optional, first parameter should accept negative values..

Answer 3

I'm used to languages where substring() (or substr()) takes two parameters: a start position, and a length. Is this objectively better than the way Java does it, and if so, can you prove it?

No, it's not objectively better. It all depends on the context in which you want to use it. If you want to extract a substring of a specific length, it's bad, but if you want to extract a substring that ends at, say, the first occurrence of "." in the string, it's better than if you first had to compute a length. The question is: which requirement is more common? I'd say the latter. Of course, the best solution would be to have both versions in the API, but if you need the length-based one all the time, using a static utility method isn't that horrible.

As for the exception, yeah, that's definitely good design. You asked for something specific, and when you can't get that specific thing, the API should not try to guess what you might have wanted instead - that way, bugs become apparent more quickly.

Also, Java DOES have an alternative substring() method that returns the substring from a start index until the end of the string.

Answer 4

There are times when the second parameter being a length is more convenient, and there are times when the second parameter being the "offset to stop before" is more convenient. Likewise there are times when "if I give you something that's too big, just go to the end of the string" is convenient, and there are times when it indicates a bug and should really throw an exception.

The second parameter being a length is useful if you've got a fixed length of field. For instance:

// C#
String guid = fullString.Substring(offset, 36);

The second parameter being an offset is useful if you're going up to another delimited:

// Java
int nextColon = fullString.indexOf(':', start);
if (start == -1)
{
    // Handle error
}
else
{
    String value = fullString.substring(start, nextColon);
}

Typically, the one you want to use is the opposite to the one that's provided on your current platform, in my experience :)

Answer 5

Having gotten some feedback, I see when the second-parameter-as-index scenario is useful, but so far all of those scenarios seem to be working around other language/API limitations. For example, the API doesn't provide a convenient routine to give me the Strings before and after the first colon in the input String, so instead I get that String's index and call substring(). (And this explains why the second position parameter in substr() overshoots the desired index by 1, IMO.)

It seems to me that with a more comprehensive set of string-processing functions in the language's toolkit, the second-parameter-as-index scenario loses out to second-parameter-as-length. But somebody please post me a counterexample. :)

Answer 6

If you store this away, the problem should stop plaguing your dreams and you'll finally achieve a good night's rest:

public String skipsSubstring(String s, int index, int length) {
    return s.subString(index, index+length);
}