Cómo usar regex en el método String.contains () en Java

Quiero comprobar si una cadena contiene las palabras "tiendas", "tienda" y "producto" en ese orden, sin importar lo que haya entre ellas.

Intenté usar someString.contains(stores%store%product);y también.contains("stores%store%product");

¿Necesito declarar explícitamente una expresión regular y pasarla al método o no puedo pasar una expresión regular en absoluto?

String.contains

String.containsfunciona con String, punto. No funciona con expresiones regulares. Verificará si la Cadena exacta especificada aparece en la Cadena actual o no.

Tenga en cuenta que String.containsno comprueba el límite de palabras; simplemente busca una subcadena.

Solución Regex

Regex es más poderoso que String.contains, ya que puede hacer cumplir el límite de palabras en las palabras clave (entre otras cosas). Esto significa que puede buscar las palabras clave como palabras , en lugar de solo como subcadenas .

Úselo String.matchescon la siguiente expresión regular:

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

La expresión regular RAW (elimine el escape realizado en el literal de cadena; esto es lo que obtiene cuando imprime la cadena de arriba):

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

Los \bcheques de límite de palabra, por lo que no se obtiene una coincidencia para restores store products. Tenga en cuenta que stores 3store_producttambién se rechaza, ya que dígito y_ se consideran parte de una palabra, pero dudo que este caso aparezca en texto natural.

Dado que el límite de palabras está marcado para ambos lados, la expresión regular de arriba buscará palabras exactas. En otras palabras, stores stores productno coincidirá con la expresión regular anterior, ya que está buscando la palabra storesin s.

.normalmente coincide con cualquier carácter excepto con un número de caracteres de nueva línea . (?s)al principio hace .coincidir con cualquier personaje sin excepción (gracias a Tim Pietzcker por señalar esto).

matcher.find()hace lo que necesita. Ejemplo:

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

Simplemente puede usar el matchesmétodo de la clase String.

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

Si desea verificar si una cadena contiene subcadena o no usa regex, lo más cercano que puede hacer es 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.

Tenga en cuenta la diferencia entre coincidencias () y buscar (), coincidencias () devuelven verdadero si toda la cadena coincide con el patrón dado. find () intenta encontrar una subcadena que coincida con el patrón en una cadena de entrada dada. Además, al usar find () no tiene que agregar coincidencias adicionales como - (? S). * Al principio y. * Al final de su patrón de expresiones regulares.

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

2.resultado: verdadero