Java's .split() method corner cases: what are they?

Question

ANSWER GIVEN, SEE BELOW -- morale: never calls .split() alone; if you want sane behaviour, always give it a length argument of -1. But not 0!

The javadoc for Pattern.split() states the following:

The array returned by this method contains each substring of the input sequence that is terminated by another subsequence that matches this pattern or is terminated by the end of the input sequence.

Witness this code:

private static final Pattern UNDERSCORE = Pattern.compile("_");

public static void main(final String... args)
{
    System.out.println(UNDERSCORE.split("_").length);
}

Now, refering to the javadoc, an array should contain substrings of the input which are either (quoting):

"terminated by another subsequence that matches this pattern": well, there is one -- the empty string right before the underscore (which UNDERSCORE obviously matches);
or "is terminated by the end of the input sequence": there is one too: the empty string right after the underscore.

Yet, the above code prints 0. Why? Is this a known bug? (imnsho yes, see below) What are other cases where .split() does not obey its contract? (again, see below)

THE ANSWER (right below this explanative text)

When using a Pattern, the single-argument .split() method is equivalent to calling the two-arguments method with 0 as an argument.

And this is where the bug lies. With an argument of 0, all empty strings from the end of the array "down to" the first non empty element are removed from the result.

If, prior to reading this, you didn't know what a braindead design decision was, now you know. And it is all the more dangerous that this is the default behaviour.

The solution is to always use the full form of the .split() method and give it a negative length argument. Here, -1 is chosen. And in this case, .split() behaves sanely:

private static final Pattern UNDERSCORE = Pattern.compile("_");

public static void main(final String... args)
{
    System.out.println(UNDERSCORE.split("_").length);
    System.out.println(UNDERSCORE.split("__").length);
    System.out.println(UNDERSCORE.split("_x_").length);
    System.out.println(UNDERSCORE.split("_", -1).length);
    System.out.println(UNDERSCORE.split("__", -1).length);
    System.out.println(UNDERSCORE.split("_x_", -1).length);
}

Output:

0 # BUG!
0 # BUG!
2 # BUG!
2 # OK
3 # OK
3 # OK

You referenced the JavaDoc. Read on... – wchargin Jun 04 '13 at 05:02 — wchargin, Jun 04 '13 at 05:02

score 6 · Accepted Answer · edited May 23 '17 at 10:25

6

From the same documentation:

The limit parameter controls the number of times the pattern is applied and therefore affects the length of the resulting array.

If n [the limit] is zero then the pattern will be applied as many times as possible, the array can have any length, and trailing empty strings will be discarded.

The default value for the limit is indeed 0:

public String[] split(CharSequence input)
...

This method works as if by invoking the two-argument split method with the given input sequence and a limit argument of zero.

Thus, the empty string is discarded.

If you want it use UNDERSCORE.split("_", -1), or any other negative integer.

EDIT: To clear up confusion: with a negative limit, the returned array would, according to your reasoning, be this:

[ "" , "" ]

With a non-positive limit, all trailing empty strings are removed. The last element is an empty string, so it is removed. Then, you have:

[ "" ]

The last element is again an empty string, so it is removed as well.

In other words, trailing refers not to trailing in the initial string, but trailing in the final array.

See also:

Java split() method strips empty strings at the end?

edited May 23 '17 at 10:25

Community

1
1

answered Jun 04 '13 at 05:03

wchargin

15,589
12
71
110

OK, I stand corrected for the trailing empty string. But for the empty string at the beginning, there is no reason for it to be discarded given what the javadoc says. – fge Jun 04 '13 at 05:09
OK, that explains it... In short, in order for `.split()` to _really_ obey its contract, you have to use the two argument form with -1 as an argument. A bug indeed... – fge Jun 04 '13 at 05:19
No, not a bug. You're just misinterpreting the contract. You can't reasonably base expectations on the first paragraph of a documentation alone. Although the first sentence could have been more clear, or at least have specified `(see below for details)`, the contract is clear and clearly adhered to. – wchargin Jun 04 '13 at 05:20
Not a bug? Sorry, but I beg to differ. I know what regexes do, I know what text is before and after a match; and `.split(0)` does everything but match reasonable expectations... Now I know I have to `.split(-1)`, but I should not have to. – fge Jun 04 '13 at 05:26

score 0 · Answer 2 · answered Jun 04 '13 at 05:06

0

"terminated by another subsequence that matches this pattern": well, there is one -- the empty string right before the underscore (which UNDERSCORE obviously matches);

No, it doesn't - the empty string before the pattern does not match '_'

answered Jun 04 '13 at 05:06

johnd

516
5
9

1

But the empty string (at the beginning) _is_ terminated by another subsequences which matches `_`... – fge Jun 04 '13 at 05:07

Java's .split() method corner cases: what are they?

2 Answers2