捕获除特定正则表达式外的所有内容

Question

I'm having some trouble trying to implement some regex. I need to capture everything except one specific operator. So this is the format essentially:

fraction operator fraction

This is the current regex:

([ \t]*-?[0-9]+[ \t]*/[ \t]*-?[0-9]+[ \t]*)

Right now, it's capturing both fractions, but I need it to just get operator. So for example, if I entered:

-12/43 - 3/-5

It would capture -12/43 and 3/-5 . I need it to capture everything but that; I need it to capture the operator in the middle.

I've tried searching for a while, but I get different answers detailing how to do this. Any help would be greatly appreciated!

Answer 1

A fairly simple way to do what you are asking for is to just replace your fractions with "" - then whatever you have left is the operator.

Pattern fraction = Pattern.compile("\\s*-?\\d+\\s*/\\s*-?\\d+\\s*");
Matcher matcher = fraction.match(myExpression);
String operator = matcher.replaceAll("").trim();

The operator variable is now the original expression with all substrings matching the fraction pattern removed.

Note that I've used the predefined character classes for whitespace and digits.

Although this should work I don't recommend this approach. Assuming you will want to do something with the expression (like evaluate it) you are much better off using a proper lexical & semantic analysis technique. There are third party libraries (eg JFlex ) that can do the job with pretty minimal effort and a lot more flexibility.

Answer 2

Try using a capturing group:

/(?:\s*-?\d+\s*\/\s*-?\d+)\s*([*/+-])\s*(?:\s*-?\d+\s*\/\s*-?\d+)/ig

I'll explain what's happening here. We have three capture groups: 2 which are non-capturing groups (?:.*) and one capturing group (.*) . The non-capturing groups are surrounding the fractions that you're ignoring while the capturing group is surrounding the operator that you are looking for [*/+-] . Now you can get the operator with:

Pattern pattern = Pattern.compile("(?:\\s*-?\\d+\\s*\\/\\s*-?\\d+)\\s*([*/+-])\\s*(?:\\s*-?\\d+\\s*\\/\\s*-?\\d+)");
Matcher matcher = pattern.match(whatAreWeMatching);
String operator = matcher.group(1); // returns "-" with the example you gave

Note that I've also included a lot of checks for whitespace \\s* so that you can freely put spaces between any operator. Without checking for whitespace, the regex would look a lot smaller but would not account for things like -21 / 12 + 14 / -5 . If you're confident that your input will only have the structure you have shown us, you could use:

/(?:-?\d+\/-?\d+) ([*/+-]) (?:-?\d+\/-?\d+)/ig

(Just remember to add an extra backslash to all backslashes before putting this in a string.)

Answer 3

If you have always inputs of this structures: values separated by single operators , then I simply appended to your expression an alternation branch to grab that operator:

|(\\S) or |([+-*/]) if you already know what those operators should be.

Which gives:

([ \t]*-?[0-9]+[ \t]*/[ \t]*-?[0-9]+[ \t]*)|(\S)

DEMO

Note: OFC you should escape slaches in your code accordingly !!