使用正则表达式搜索字符串中的子字符串

Question

I'm trying to search for a set of words, contained within an ArrayList(terms_1pers) , inside a string and, since the precondition is that before and after the search word there should be no letters, I thought of using expression regular.

I just don't know what I'm doing wrong using the matches operator. In the code reported, if the matching is not verified, it writes to an external file.

String url = csvRecord.get("url");
String text = csvRecord.get("review");
String var = null;
for(String term : terms_1pers)
{
   if(!text.matches("[^a-z]"+term+"[^a-z]"))
   {
      var="true";
   }
}
if(!var.equals("true"))
{
    bw.write(url+";"+text+"\n");
}

Answer 1

In order to find regex matches, you should use the regex classes. Pattern and Matcher.

String term = "term";
ArrayList<String> a  = new ArrayList<String>();
a.add("123term456"); //true
a.add("A123Term5"); //false
a.add("term456"); //true
a.add("123term"); //true
Pattern p = Pattern.compile("^[^A-Za-z]*(" + term + ")[^A-Za-z]*$");
for(String text : a) {
    Matcher m = p.matcher(text);
    if (m.find()) {
         System.out.println("Found: " + m.group(1) );
         //since the term you are adding is the second matchable portion, you're looking for group(1)
    }
    else System.out.println("No match for: " + term);
}

}

In the example there, we create an instance of a https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html to find matches in the text you are matching against.

Note that I adjusted the regex a bit. The choice in this code excludes all letters AZ and the lowercase versions from the initial matching part. It will also allow for situations where there are no characters at all before or after the match term. If you need to have something there, use + instead of * . I also limited the regex to force the match to only contain matches for these three groups by using ^ and $ to verify end the end of the matching text. If this doesn't fit your use case, you may need to adjust.

To demonstrate using this with a variety of different terms:

ArrayList<String> terms = new ArrayList<String>();
terms.add("term");
terms.add("the book is on the table");
terms.add("1981 was the best year ever!");
ArrayList<String> a  = new ArrayList<String>();
a.add("123term456");
a.add("A123Term5");
a.add("the book is on the table456");
a.add("1@#!231981 was the best year ever!9#");
for (String term: terms) {

    Pattern p = Pattern.compile("^[^A-Za-z]*(" + term + ")[^A-Za-z]*$");

    for(String text : a) {

        Matcher m = p.matcher(text);
        if (m.find()) {
             System.out.println("Found: " + m.group(1)  + " in " + text);
             //since the term you are adding is the second matchable portion, you're looking for group(1)
        }
        else System.out.println("No match for: " + term + " in " + text);
    }
}

Output for this is: Found: term in 123term456 No match for: term in A123Term5 No match for: term in the book is on the table456....

In response to the question about having String term being case insensitive, here's a way that we can build a string by taking advantage of java.lang.Character to options for upper and lower case letters.

String term = "This iS the teRm.";
String matchText = "123This is the term.";
StringBuilder str = new StringBuilder();
str.append("^[^A-Za-z]*(");
for (int i = 0; i < term.length(); i++) {
  char c = term.charAt(i);
  if (Character.isLetter(c))
    str.append("(" + Character.toLowerCase(c) + "|" + Character.toUpperCase(c) + ")");
  else str.append(c);
}
str.append(")[^A-Za-z]*$");

System.out.println(str.toString());


Pattern p = Pattern.compile(str.toString());
Matcher m = p.matcher(matchText);
if (m.find()) System.out.println("Found!");
else System.out.println("Not Found!");

This code outputs two lines, the first line is the regex string that's being compiled in the Pattern. "^[^A-Za-z]*((t|T)(h|H)(i|I)(s|S) (i|I)(s|S) (t|T)(h|H)(e|E) (t|T)(e|E)(r|R)(m|M).)[^A-Za-z]*$" This adjusted regex allows for letters in the term to be matched regardless of case. The second output line is "Found!" because the mixed case term is found within matchText.

Answer 2

you did not consider the case where the start and end may contain letters so adding .* at the front and end should solve your problem.

for(String term : terms_1pers)
{
   if( text.matches(".*[^a-zA-Z]+" + term + "[^a-zA-Z]+.*)" )  
   {
      var="true";
      break; //exit the loop
   }
}
if(!var.equals("true"))
{
    bw.write(url+";"+text+"\n");
}

Answer 3

There are several things to note:

• matches requires a full string match, so [^az]term[^az] will only match a string like :term. . You need to use .find() to find partial matches
• If you pass a literal string to a regex, you need to Pattern.quote it, or if it contains special chars, it will not get matched
• To check if a word has some pattern before or after or at the start/end, you should either use alternations with anchors (like (?:^|[^az]) or (?:$|[^az]) ) or lookarounds, (?<![az]) and (?![az]) .
• To match any letter just use \\p{Alpha} or - if you plan to match any Unicode letter - \\p{L} .
• The var variable is more logical to set to Boolean type.

Fixed code:

String url = csvRecord.get("url");
String text = csvRecord.get("review");
Boolean var = false;
for(String term : terms_1pers)
{
   Matcher m = Pattern.compile("(?<!\\p{L})" + Pattern.quote(term) + "(?!\\p{L})").matcher(text);
   // If the search must be case insensitive use
   // Matcher m = Pattern.compile("(?i)(?<!\\p{L})" + Pattern.quote(term) + "(?!\\p{L})").matcher(text); 
   if(!m.find())
   {
       var = true;
   }
}
if (!var) {
   bw.write(url+";"+text+"\n");
}