How to use Regex in Java to pattern match?

Question

I have read the documentation and various tutorials online but I'm still confused on how regex works in Java. What I am trying to do is create a function which takes in argument of type string. I then want to check if the passed string contains any characters other than MDCLXVIivxlcdm. So for example, string "XMLVID" should return false and "ABXMLVA" should return true.

public boolean checkString(String arg)
{
     Pattern p = Pattern.complile("[a-zA-z]&&[^MDCLXVIivxlcdm]");
     Matcher m = p.matcher(arg);
     if(m.matches())
          return true;
     else
          return false;
 }

When I pass, "XMLIVD", "ABXMLVA", and "XMLABCIX", all return false. What am I doing wrong? Any help will be greatly appreciated.

Answer 1

You will need to use Java's character class intersection operator inside a character class, otherwise it literally matches && . Btw, your first character class from A to (lowercase) z also includes [\\]^_ , which you certainly do not want; and you misspelled "Patter.complile".

Also, matches()

Attempts to match the entire region against the pattern.

So you either need to use find() instead or pad the expression with .* .

public boolean checkString(String arg) {
    return Pattern.compile("[[a-zA-Z]&&[^MDCLXVIivxlcdm]]").matcher(arg).find();
}

Answer 2

you can use a function like this, with two arguments, viz.,

• origingalString the original string to check
• searchString the string to be searched

the code exactly,

public boolean checkCompletelyExist(String origingalString,String searchString){ 
  boolean found = false; 
  String regex = ""; 
  try{ 
    for(int i = 0; i < searchString.length();i++){ 
      String temp = String.valueOf(searchString.charAt(i)); 
      regex = "[\\x20-\\x7E]*"+"["+temp.toLowerCase()+"|"+temp.toUpperCase()+"]+[\\x20-\\x7E]*"; 
      if(!origingalString.matches(regex)){ 
        found = true; 
        break; 
      } 
    } 
    System.out.println("other character present : "+found); 
  } catch (Exception e) { 
    e.printStackTrace(); 
  } 
  return found; 
}

eg:

checkCompletelyExist("MDCLXVIivxlcdm","XMLVID") output will be other character present : false

and

checkCompletelyExist("MDCLXVIivxlcdm","ABXMLVA") output will be other character present : true

Answer 3

Regular Expressions (RegEx / RegExp) Basically, a regular expression is a pattern describing a certain amount of text.

^abc$   start / end of the string
\b \B   word, not-word boundary
\w \d \s    word, digit, whitespace
\W \D \S    not word, digit, whitespace
\z  - End of entire string
(…) - Grouping (capture groups)
[abc]   any of a, b, or c
[^abc]  not a, b, or c
[a-g]   character between a & g
{ m,n } - quantifiers for “from m to n repetitions”
+ - quantifiers for 1 or more repetitions (i.e, {1,})
? - quantifiers for 0 or 1 repetitions (i.e, {0,1})

POSIX Bracket Expressions POSIX bracket expressions are a special kind of character classes. POSIX bracket expressions match one character out of a set of characters, just like regular character classes. The POSIX character class names must be written all lowercase. The POSIX standard defines 12 character classes. The table below lists all 12, plus the [:ascii:] and [:word:] classes that some regex flavors also support.

Pattern Matching with Regular Expressions:

final Pattern mix_alphaNumaric_pattern = Pattern.compile("^[A-Za-z0-9]+$");
final Pattern alphabets_pattern = Pattern.compile("^[A-Za-z,\\- ]+$");
final Pattern alphabetsNull_pattern = Pattern.compile("|^[A-Za-z,\\- ]+$");
final Pattern numaric_pattern = Pattern.compile("^[0-9]+$");    // ^begning +followed By $end
final Pattern date_time_pattern = Pattern.compile("\\d{1,2}/\\d{1,2}/\\d{4}\\s\\d{1,2}\\:\\d{1,2}");
final Pattern weather_pattern = Pattern.compile("[\\-]*\\d{1,3}\\.\\d{1,6}");
final Pattern email_pattern = Pattern.compile("^[\\w-_\\.+]*[\\w-_\\.]\\@([\\w]+\\.)+[\\w]+[\\w]$");
final Pattern mobile_pattern = Pattern.compile("(\\+)?(\\d{1,2})?\\d{10}");

public static void main(String[] args) {
    String[] str = {"MCDL", "XMLIVD", "ABXMLVA", "XMLABCIX"}; 
    Pattern p = Pattern.compile("^(M|D|C|L|X|V|I|i|v|x|l|c|d|m)+$");
    // Returns: true if, and only if, the entire region sequence matches this matcher's pattern
    for (String sequence : str ) {
        boolean match = false, find = false;
        if ( !p.matcher(sequence).matches() ) match = true;
        if (p.matcher(sequence).find())       find = true;

        System.out.format("%s \t Match[%s] Find[%s]\n", sequence, match, find);
    }
}

OutPut:

MCDL     Match[false] Find[true]
XMLIVD   Match[false] Find[true]
ABXMLVA      Match[true] Find[false]
XMLABCIX     Match[true] Find[false]

@see this links to:

• https://regexr.com/