Como usar o regex no método String.contains () em Java

Quero verificar se uma String contém as palavras “stores”, “store” e “product” nessa ordem. Não importa o que esteja entre eles.

Eu tentei usar someString.contains(stores%store%product); e também .contains("stores%store%product");

Preciso declarar explicitamente um regex e passá-lo no método ou não posso passar um regex?

String.contains

String.contains trabalha com String, ponto final. Não funciona com regex. Ele irá verificar se a String exata especificada aparece na String atual ou não.

Observe que String.contains não verifica o limite de palavras; ele simplesmente verifica a substring.

Solução Regex

O Regex é mais poderoso que o String.contains , já que você pode impor o limite de palavras nas palavras-chave (entre outras coisas). Isso significa que você pode pesquisar as palavras-chave como palavras , em vez de apenas substrings .

Use String.matches com o seguinte regex:

 "(?s).*\\bstores\\b.*\\bstore\\b.*\\bproduct\\b.*" 

O regex RAW (remova o escape feito na string literal – isso é o que você obtém quando imprime a string acima):

 (?s).*\bstores\b.*\bstore\b.*\bproduct\b.* 

O \b verifica o limite de palavras, para que você não obtenha uma correspondência para restores store products . Observe que as stores 3store_product também são rejeitadas, já que digit e _ são consideradas parte de uma palavra, mas duvido que esse caso apareça em texto natural.

Como o limite de palavras é verificado para ambos os lados, o regex acima procurará palavras exatas. Em outras palavras, o stores stores product não corresponderá à regex acima, desde que você esteja procurando pela palavra store sem s .

. normalmente corresponde a qualquer caractere, exceto um número de novos caracteres de linha . (?s) no começo faz . corresponde a qualquer personagem sem exceção (graças a Tim Pietzcker por apontar isto).

matcher.find() faz o que você precisa. Exemplo:

 Pattern.compile("stores.*store.*product").matcher(someString).find(); 

Você pode simplesmente usar o método matches da class String.

 boolean result = someString.matches("stores.*store.*product.*"); 

Se você quiser verificar se uma string contém substring ou não está usando regex, o mais próximo que você pode fazer é usando find () –

  private static final validPattern = "\\bstores\\b.*\\bstore\\b.*\\bproduct\\b" Pattern pattern = Pattern.compile(validPattern); Matcher matcher = pattern.matcher(inputString); System.out.print(matcher.find()); // should print true or false. 

Observe a diferença entre matches () e find (), matches () retornará true se a string inteira corresponder ao padrão fornecido. find () tenta encontrar uma substring que corresponda ao padrão em uma determinada string de input. Também usando find () você não precisa adicionar correspondência extra como – (? S). * No início e. * No final do seu padrão de expressão regular.

 public static void main(String[] args) { String test = "something hear - to - find some to or tows"; System.out.println("1.result: " + contains("- to -( \\w+) som", test, null)); System.out.println("2.result: " + contains("- to -( \\w+) som", test, 5)); } static boolean contains(String pattern, String text, Integer fromIndex){ if(fromIndex != null && fromIndex < text.length()) return Pattern.compile(pattern).matcher(text).find(); return Pattern.compile(pattern).matcher(text).find(); } 

1.resultado: true

2.resultado: true