How the split() of Strings work?

[Varuna Seneviratna]

The documentation at https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#split(java.lang.String) illustrate six examples. From the six examples, how could the sixth example be explained. Why does a space " " come as part of the result. If two equal characters are placed adjecently, then a space comes as a part of the result(array). How to explain this splitting?

The string "boo:and:foo", for example, yields the following results with these parameters:

Regex Limit Result
: 2 { "boo", "and:foo" }
: 5 { "boo", "and", "foo" }
: -2 { "boo", "and", "foo" }
o 5 { "b", "", ":and:f", "", "" }
o -2 { "b", "", ":and:f", "", "" }
o 0 { "b", "", ":and:f" }

[Carey Brown]

It's not a "space" that is in the resulting array, it is an EMPTY String.

[Carey Brown]

The string "boo:and:foo", for example, yields the following results with these parameters:

Regex Limit Result

o ==> "b" <o> "" <o> ":and:f" <o> "" <o> ""

If two 'o's appear back to back then there is an EMPTY String in between them.

[Varuna Seneviratna]

Actually what happens when splitting  If you split using

"boo:and:foo.split("o", 2)

 then the result is

 String[2] { "b", "o:and:foo" }

.

When

"boo:and:foo"

is split using

 "boo:and:foo".split("o", 3)

the result is

 String[3] { "b", "", ":and:foo" }

. In first occurrence of "o" the string is split between "b" and "o:and:foo" then when "o" is encountered for the second time "b" and "o:and:foo" is built into {b", "", ":and:foo} .

Why does an empty string gets constructed?

[Carey Brown]

"boo:and:foo.split("o", 2)

result is

 String[2] { "b", <o> "o:and:foo" }

Once you hit the first 'o' and split the string you've reached the limit of '2' and the next 'o' is not processed and the second array position contains "everything else".

Trying this with a limit of 3:

"boo:and:foo".split("o", 3)

result is

 String[3] { "b", <o> "", <o> ":and:foo" }

This time, after splitting on the first 'o' we haven't reached our limit so we split on the second 'o'. And because the second was back to back with the first that meant that there was no data in between them, so the EMPTY data is represented by an  EMPTY String. Now the limit has be reached and the third array position contains everything else.

[Carey Brown]

Here's a test program for experimentation:

public class StringSplitTest
{
	private static String DOC_POSITIVE =
			"    If the limit is positive then the pattern will be applied at most\n" +
			"    limit - 1 times, the array's length will be no greater than limit,\n" +
			"    and the array's last entry will contain all input beyond the last\n" +
			"    matched delimiter.";

	private static String DOC_ZERO =
			"    If the limit is zero then the pattern will be applied as many times\n" +
			"    as possible, the array can have any length, and trailing empty strings\n" +
			"    will be discarded.";

	private static String DOC_NEGATIVE =
			"    If the limit is negative then the pattern will be applied as many\n" +
			"    times as possible and the array can have any length.";

	private static SplitSpec[] ssary =
	{
		new SplitSpec( ":",  2 ),
		new SplitSpec( ":",  5 ),
		new SplitSpec( ":", -2 ),
		new SplitSpec( "o",  5 ),
		new SplitSpec( "o", -2 ),
		new SplitSpec( "o",  0 )
	};
	
	public static void main( String[] args )
	{
		for( SplitSpec ss : ssary )
			test( "boo:and:foo", ss );
	}

	private static void test( String str, SplitSpec ss )
	{
		if( ss.limit < 0 )			System.out.println( DOC_NEGATIVE );
		else if( ss.limit == 0 )	System.out.println( DOC_ZERO );
		else						System.out.println( DOC_POSITIVE );
		
		System.out.printf( "INPUT  = \"%s\"   %-22s%n", str, ss );
		String[] ary = str.split( ss.regex, ss.limit );
		
		System.out.print( "OUTPUT = " );
		for( int i=0 ; i < ary.length ; i++ )
		{
			if( i > 0 )
				System.out.print( " <" + ss.regex + "> " );
			
			System.out.print( "\"" + ary[i] + "\"" );
			if( ary[i].isEmpty() )
				System.out.print( "(empty)" );
		}
		System.out.println(  );
		System.out.println(  );
	}
}

class SplitSpec
{
	String		regex;
	int			limit;
	
	public SplitSpec( String regex, int limit )
	{
		this.regex = regex;
		this.limit = limit;
	}
	
	public String toString()
	{
		return String.format( "regex=\"%s\", limit=%2d", regex, limit );
	}
}

The output of this was:

    If the limit is positive then the pattern will be applied at most
    limit - 1 times, the array's length will be no greater than limit,
    and the array's last entry will contain all input beyond the last
    matched delimiter.
INPUT  = "boo:and:foo"   regex=":", limit= 2   
OUTPUT = "boo" <:> "and:foo"

    If the limit is positive then the pattern will be applied at most
    limit - 1 times, the array's length will be no greater than limit,
    and the array's last entry will contain all input beyond the last
    matched delimiter.
INPUT  = "boo:and:foo"   regex=":", limit= 5   
OUTPUT = "boo" <:> "and" <:> "foo"

    If the limit is negative then the pattern will be applied as many
    times as possible and the array can have any length.
INPUT  = "boo:and:foo"   regex=":", limit=-2   
OUTPUT = "boo" <:> "and" <:> "foo"

    If the limit is positive then the pattern will be applied at most
    limit - 1 times, the array's length will be no greater than limit,
    and the array's last entry will contain all input beyond the last
    matched delimiter.
INPUT  = "boo:and:foo"   regex="o", limit= 5   
OUTPUT = "b" <o> ""(empty) <o> ":and:f" <o> ""(empty) <o> ""(empty)

    If the limit is negative then the pattern will be applied as many
    times as possible and the array can have any length.
INPUT  = "boo:and:foo"   regex="o", limit=-2   
OUTPUT = "b" <o> ""(empty) <o> ":and:f" <o> ""(empty) <o> ""(empty)

    If 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.
INPUT  = "boo:and:foo"   regex="o", limit= 0   
OUTPUT = "b" <o> ""(empty) <o> ":and:f"