Difference between ? or | in regular expression

Question

From Wiki,

? => Matches the preceding element zero or one time. For example, ab?c matches only "ac" or "abc".
| => The choice (also known as alternation or set union) operator matches either the expression before or the expression after the operator. For example, abc|def matches "abc" or "def".

Here is the code tried;

String yuStr =  "-7.00, 10.00, 0.00, -212.000";

//Using ?
System.out.println(yuStr.replaceAll("-?(\\d+)\\.\\d+", "$1"));

//Using |
System.out.println(yuStr.replaceAll("-|(\\d+)\\.\\d+", "$1"));

However, both of two ways will give the same output

7, 10, 0, 212

Is my assumption right, according to Wiki doc above, in second way with ?, it is choice between expression before operator - and expression after operator (\\d+) ?

My question is, why the second way (with |) is working the same way like first one (with ?) ?

They are not the same, they happen to produce the same output in this example. Change the replacement string to `"<$1>"` and you will see the difference. — nhahtdh, Dec 23 '14 at 10:22

aioobe · Answer 1 · 2014-12-23T10:47:03.827

2

The first expression says

a decimal number, possibly preceded by a -

The second expression says

A - or a decimal number

When using the expressions as argument to replaceAll, you'll (incidentally) get the same result in this case since you set $1 as the replacement value.

edited Dec 23 '14 at 10:47

answered Dec 23 '14 at 10:25

aioobe

413,195
112
811
826

score 2 · Answer 2 · answered Dec 23 '14 at 10:26

The two expressions have different semantics, even though they happen to produce the same results for this particular input.

On some other inputs their result will differ. Consider, for example 1-2. The first would return 1-2 whereas the second would return 12.

TheLostMind · Answer 3 · 2014-12-23T10:48:18.370

? and | are used for different reasons. For example :

public static void main(String[] args) {
    String yuStr = "--7";
    System.out.println("1 : " +yuStr.replaceAll("-?\\d","")); // replaces the second - and 7
    System.out.println("2 : " +yuStr.replaceAll("-|\\d","")); // replaces all - and all numbers
}

prouces the OP :

1 : -  // first - is not replaced.
2 :    // empty string

It is just a co-incidence that in your case, they produce the same output. Note : In regex, it is not surprising to have 10 different ways (expressions) to get the same output :)

score 1 · Accepted Answer · edited May 23 '17 at 12:20

They are not the same, they just happen to produce the same output for your example.

The 4 matches in the first regex:

-7.00, 10.00, 0.00, -212.000
-1---  |   |  |  |  |      |
       11---  |  |  |      |
              1---  |      |
                    -111----

In each match, the capturing group captures the whole part of the decimal number, and all four matches are replaced by the content of the capturing group.

The 6 matches in the second regex:

-7.00, 10.00, 0.00, -212.000
-|  |  |   |  |  |  ||     |
 1---  |   |  |  |  ||     |
       11---  |  |  ||     |
              1---  ||     |
                    -|     |
                     111----

The capturing group only captures some text in 4 matches. In the other 2 matches, the capturing group doesn't capture anything.

In Oracle/OpenJDK, referring to a group that captures nothing in the replacement string will result in empty string. Therefore, the - are simply removed, and for this particular input, the end result is the same.

However, for input such as --7.3, the result will be different.

And in Android and GNU Classpath's implementation, a group that captures nothing is rendered as null when referred to in the replacement string, so your output string in the second case will contain null.

Difference between ? or | in regular expression

4 Answers4