Comment utiliser le regex dans la méthode String.contains() en Java ?

Question

Je veux vérifier si une chaîne contient les mots "stores", "store" et "product" dans cet ordre, peu importe ce qui se trouve entre eux.

J'ai essayé d'utiliser someString.contains(stores%store%product); et aussi .contains("stores%store%product");

Dois-je déclarer explicitement une expression rationnelle et la transmettre à la méthode ou puis-je ne pas transmettre d'expression rationnelle du tout ?

Answer 1

String.contains

String.contains fonctionne avec String, point final. Il ne fonctionne pas avec les expressions rationnelles. Elle vérifiera si la chaîne exacte spécifiée apparaît dans la chaîne actuelle ou non.

Notez que String.contains ne vérifie pas la limite du mot ; il vérifie simplement la sous-chaîne.

Solution Regex

Regex est plus puissant que String.contains puisque vous pouvez imposer une limite de mots aux mots clés (entre autres choses). Cela signifie que vous pouvez rechercher les mots-clés comme mots plutôt que de simplement sous-chaînes .

Utilisez String.matches avec la regex suivante :

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

La regex RAW (supprimez l'échappement effectué dans la chaîne littérale - c'est ce que vous obtenez lorsque vous imprimez la chaîne ci-dessus) :

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

Le site \b vérifie les limites des mots, de sorte que vous n'obtenez pas de correspondance pour restores store products . Notez que stores 3store_product est également rejetée, puisque digit et _ sont considérés comme faisant partie d'un mot, mais je doute que ce cas apparaisse dans un texte naturel.

Comme la limite des mots est vérifiée des deux côtés, la regex ci-dessus recherchera des mots exacts. En d'autres termes, stores stores product ne correspondra pas à la regex ci-dessus, puisque vous recherchez le mot store sans s .

. correspondent normalement à tout caractère sauf un nombre de nouveaux caractères de ligne . (?s) au début fait . correspond à n'importe quel caractère sans exception (merci à Tim Pietzcker de l'avoir signalé).

Answer 2

matcher.find() fait ce dont vous aviez besoin. Exemple :

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

Answer 3

Vous pouvez simplement utiliser matches de la classe String.

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

Answer 4

Si vous voulez vérifier si une chaîne de caractères contient une sous-chaîne ou non en utilisant une expression rationnelle, la méthode la plus proche que vous puissiez utiliser est 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.

Notez la différence entre matches() et find(), matches() retourne vrai si la chaîne entière correspond au modèle donné. find() essaie de trouver une sous-chaîne qui correspond au modèle dans une chaîne d'entrée donnée. De plus, en utilisant find(), vous n'avez pas à ajouter de correspondance supplémentaire comme - (?s).* au début et .* à la fin de votre modèle regex.

Answer 5

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.résultat : vrai

2.résultat : vrai