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

Quero verificar se uma String contém as palavras "armazena", "armazena" e "produto" nessa ordem, não importa o que esteja entre elas.

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

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

String.contains

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

Observe que String.containsnão verifica o limite da palavra; ele simplesmente verifica a substring.

Solução Regex

Regex é mais poderoso do que String.contains, uma vez que você pode impor limites 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.matchescom o seguinte regex:

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

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

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

A \bverificação de limite de palavra, para que você não obtenha uma correspondência para restores store products. Observe que stores 3store_producttambém é rejeitado, uma vez que dígito e_ são considerados parte de uma palavra, mas eu duvido que esse caso apareça em texto natural.

Como o limite da palavra é verificado para ambos os lados, o regex acima irá pesquisar por palavras exatas. Em outras palavras, stores stores productnão corresponderá ao regex acima, pois você está procurando pela palavra storesem s.

.normalmente corresponde a qualquer caractere, exceto um número de caracteres de nova linha . (?s)no início faz .combinações com qualquer caractere sem exceção (obrigado a Tim Pietzcker por apontar isso).

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

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

Você pode simplesmente usar o matchesmétodo da classe String.

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

Se você quiser verificar se uma string contém substring ou não usando regex, o mais próximo que você pode fazer é usar 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 match () e find (), match () retorna verdadeiro se toda a string corresponder ao padrão fornecido. find () tenta encontrar uma substring que corresponda ao padrão em uma dada string de entrada. Além disso, usando find (), você não precisa adicionar correspondências extras como - (? S). * No início e. * No final de seu padrão regex.

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: verdadeiro

2. resultado: verdadeiro