用正则表达式\ w \ w *拆分字符串？ \ w +？

Question

I'm learning regexp and thought I was starting to get a grip. but then...

I tried to split a string and I need help to understand such a simple thing as:

String input = "abcde";
System.out.println("[a-z] " + Arrays.toString(input.split("[a-z]")));
System.out.println("\\w " + Arrays.toString(input.split("\\w")));
System.out.println("\\w*? " + Arrays.toString(input.split("\\w*?")));
System.out.println("\\w+? " + Arrays.toString(input.split("\\w+?")));

The output is
[a-z] - []
\w    - []
\w*?  - [, a, b, c, d, e]
\w+?  - []

Why doesn't any of the two first lines split the String on any character? The third expression \\w*?, (question mark prevents greediness) works as I expected, splitting the String on every character. The star, zero or more matches, returns an empty array.

I've tried the expression within NotePad++ and in a program and it shows 5 matches as in:

Scanner ls = new Scanner(input);
while(ls.hasNext())
    System.out.format("%s ", ls.findInLine("\\w");

Output is: a b c d e

This really puzzles me

Answer 1

If you split a string with a regex, you essentially tell where the string should be cut. This necessarily cuts away what you match with the regex. Which means if you split at \\w , then every character is a split point and the substrings between them (all empty) are returned. Java automatically removes trailing empty strings, as described in the documentation .

This also explains why the lazy match \\w*? will give you every character, because it will match every position between (and before and after) any character (zero-width). What's left are the characters of the string themselves.

Let's break it down:

1. [az] , \\w , \\w+?

   Your string is

    abcde 

   And the matches are as follows:

     abcde └─┘└─┘└─┘└─┘└─┘ 

   which leaves you with the substrings between the matches, all of which are empty.

   The above three regexes behave the same in this regard as they all will only match a single character. \\w+? will do so because it lacks any other constraints that might make the +? try matching more than just the bare minimum (it's lazy, after all).

2. \\w*?

     abcde └┘ └┘ └┘ └┘ └┘ └┘ 

   In this case the matches are between the characters, leaving you with the following substrings:

    "", "a", "b", "c", "d", "e", "" 

   Java throws the trailing empty one away, though.

Answer 2

Let's break down each of those calls to String#split(String) . It's key to notice from the Java docs that the "method works as if by invoking the two-argument split method with the given expression and a limit argument of zero. Trailing empty strings are therefore not included in the resulting array."

"abcde".split("[a-z]"); // => []

This one matches every character (a, b, c, d, e) and results in only the empty strings between them, which are omitted.

"abcde".split("\\w")); // => []

Again, every character in the string is a word character ( \\w ), so the result is empty strings, which are omitted.

"abcde".split("\\w*?")); // => ["", "a", "b", "c", "d", "e"]

In this case, the * means "zero or more of the preceding item" ( \\w ) which matches the empty expression seven times (once at the beginning of the string then once between each character). So we get the first empty string then each character.

"abcde".split("\\w+?")); // => []

Here the + means "one or more of the preceding item" ( \\w ) which matches the entire input string, resulting in only the empty string, which is omitted.

Try these examples again with input.split(regex, -1) and you should see all of the empty strings.

Answer 3

String.split cuts the string at each match of the pattern:

The array returned by this method contains each substring of this string that is terminated by another substring that matches the given expression or is terminated by the end of the string.

So whenever the pattern like [az] is matched, the string is cut at that match. As every character in your string is matched by the pattern, the resulting array is empty (trailing empty strings are removed).

The same applies for \\w and \\w+? (one or more \\w but as little repetitions as possible). That \\w*? results in something that you expected is due to the *? quantifier as that will match zero repetitions if possible, so an empty string. And an empty string is found at each position in the given string.