Why regex group doesn't work

Question

I've tried the following regx (java string format):

^(.*(iOS\\s+[\\d\\.]+|Android\\s+[\\d\\.]+)?.*)$

String to match is :

Some Money 2.6.2; iOS 5.1.1

It supposes to return three groups :

group[0] :Some Money 2.6.2; iOS 5.1.1
group[1] :Some Money 2.6.2; iOS 5.1.1
group[2] :iOS 5.1.1

but it actually returns these:

group[0] :Some Money 2.6.2; iOS 5.1.1 
group[1] :Some Money 2.6.2; iOS 5.1.1 
group[2] :null

when i change regex as below

^(.*(iOS\\s+[\\d\\.]+|Android\\s+[\\d\\.]+).*)$

but it can't match string like

whatever iS 5.1.1 whatever

What i want to achieve is the regex returns three groups no matter what string likes.The first and second group always to be the entire string . The third group is the substring that matches '(iOS|Android) [\d.]*' if string does contains that part and is null or empty if it doesn't contain.

It doesn't match the second group, because it is optional and .* has already consumed the whole string. — Sebastian Proske
– Sebastian Proske, Commented Mar 3, 2017 at 7:44
I tried solving a problem with regex. Now I have two problems. — Joshua
– Joshua, Commented Mar 3, 2017 at 7:44
When everything is optional in the regex, something is wrong with the approach. Look, you could use ^((?:(?!(?:iOS|Android)\s+[\d.]).)*((?:iOS|Android)\s+[\d.]+)?.*)$, but do you really want to? I suggest checking for just (?:iOS|Android)\s+[\d.]+ pattern and if not, take the whole string, else grab the string and the match. — Wiktor Stribiżew
– Wiktor Stribiżew, Commented Mar 3, 2017 at 7:45
Then how can i change the regex to avoid these,since string before "iOS " has no fixed pattern. @SebastianProske — sdowooh
– sdowooh, Commented Mar 3, 2017 at 7:48

Alexander · Accepted Answer · 2017-03-03 09:07:35Z

2

Maybe you can use the ; delimiter as indication that your iOS 5.1.1 part starts?

Then a pattern may look like .+;\\s+(.+).

.+; consumes everything up to the semi-colon
\\s+ consumes the spaces between semi-colon and the start of the version string
(.+) consumes everything up to the end

If you really only want to match iOS or Android then you might want to add a non capturing group within the (.+) part. A regexp then would look like this: ".+;\\s+((?:iOS|Android).+)".

And here a executable example what a solution may look like. It shows the behaviour of both pattern variants I explained above.

public static void main(String[] args) {
    String input1 = "Some Money 2.6.2; iS 5.1.1 ";
    String input2 = "Some Money 2.6.2; iOS 5.1.1 ";
    String input3 = "Some Money 2.6.2; Android 5.1.1 ";

    String pattern1 = ".+;\\s+(.+)";
    String pattern2 = ".+;\\s+((?:iOS|Android).+)";

    System.out.println(pattern1);
    matchPattern(input1, pattern1);
    matchPattern(input2, pattern1);
    matchPattern(input3, pattern1);
    System.out.println();
    System.out.println(pattern2);
    matchPattern(input1, pattern2);
    matchPattern(input2, pattern2);
    matchPattern(input3, pattern2);
}

private static void matchPattern(String input, String pattern) {
    Pattern p = Pattern.compile(pattern);
    Matcher m = p.matcher(input);
    if(m.matches()) {
        System.out.println(m.group(0));
        System.out.println(m.group(1));
        if(m.groupCount() > 1) {
            System.out.println(m.group(2));
        }
    }
}

Update: Since the target of the question got clearer due to some edits by the author, I feel the need to update my answer. If it is about always getting three groups, the following might be better than working out all possible notation variants:

public static void main(String[] args) {
    String input1 = "Some Money 2.6.2; iS 5.1.1";
    String input2 = "Some Money 2.6.2; iOS 5.1.1";
    String input3 = "Some Money 2.6.2; Android 5.1.1";
    String input4 = "Some Money 2.6.2 iOS 5.1.1";
    String input5 = "Some Money 2.6.2 iOS";
    String input6 = "Some Money 2.6.2";

    String pattern1 = "(.*?((?:iOS|Android)(?:\\s+[0-9\\.]+)?.*)?)";

    System.out.println(pattern1);
    matchPattern(input1, pattern1);
    matchPattern(input2, pattern1);
    matchPattern(input3, pattern1);
    matchPattern(input4, pattern1);
    matchPattern(input5, pattern1);
    matchPattern(input6, pattern1);
}

private static void matchPattern(String input, String pattern) {
    Pattern p = Pattern.compile(pattern);
    Matcher m = p.matcher(input);
    if(m.matches()) {
        System.out.println(m.group(0));
        System.out.println(m.group(1));
        System.out.println(m.group(2));
        System.out.println();
    }
}

Here the pattern is (.*?(?:((?:iOS|Android)(?:\\s+[0-9\\.]+)?).*)?).

.*? consumes everything before the version string. If no version string is available at all it matches the whole input. The Reluctant quantifier is needed here. It takes the shortest match that still matches and so avoids that the whole input is consumed.
(?:((?:iOS|Android)(?:\\s+[0-9\\.]+)?).*)? consumes the whole version string and everything that is following.
((?:iOS|Android)(?:\\s+[0-9\\.]+)?) is the group(2) output. It just matches the OS string, iOS or Android, with an optional version suffix consisting of numbers and dot.

edited Mar 3, 2017 at 9:07

answered Mar 3, 2017 at 8:07

Alexander

1,42110 silver badges16 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Wiktor Stribiżew Over a year ago

It does not seem to work for string 2.

Alexander Over a year ago

Of cause not, because the regexp is explicitly limited to iOS and Android. I explained the more general approach in my answer while the code uses the more specific one only matching iOS and Android.

Wiktor Stribiżew Over a year ago

Then you just need to add the logic to return the expected results. Moreover, the unanchored regex would be more efficient.

sdowooh Over a year ago

Thanks for you answer. But actually i can't ensure string's format, it may contains no character ';' . What i want to achieve is that the regex return three groups no matter what the string like.

Community · Accepted Answer · 2017-05-23 10:30:02Z

0

please refer this topic about "How a RegEx engine works".

Those based on back-tracking. These often compile the pattern into byte-code, resembling machine instructions. The engine then executes the code, jumping from instruction to instruction. When an instruction fails, it then back-tracks to find another way to match the input.

Your regular expression have many way to match the input. And sadly, it return the other way (not your expected matches).

By removing "?" quantifier from the 2nd group, it becomes "required". Your returned maches will match all required groups.

edited May 23, 2017 at 10:30

CommunityBot

11 silver badge

answered Mar 3, 2017 at 8:16

Hoang Nguyen

793 bronze badges

Comments

sdowooh · Accepted Answer · 2017-03-13 04:36:52Z

0

I finally solved the problem by regex as below.

(.*((?:iOS|Android)\\s+[0-9\\.]+).*|.*)

answered Mar 13, 2017 at 4:36

sdowooh

541 silver badge8 bronze badges

Collectives™ on Stack Overflow

Why regex group doesn't work

3 Answers 3

4 Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

4 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related