Recherche de mots correspondants à un pattern

Version imprimable

Bonjour !

Ma demande concerne simplement l'obtention d'une idée concernant la recherche de mots présents dans un tableau de Strings, mots correspondants à un pattern.

Par exemple, le pattern
"?A???N"
accepte les mots "MAISON" et SAISON", mais pas "ZIRCON".

L'embryon de code ci-après fonctionne, mais est fort primaire.
Existe-t-il un moyen plus évolué de réaliser cette recherche ?
Merci pour votre aide.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Main {
  public static void main(String[] args) {
    String pattern = "?A???N";
    String[] words = new String[]{
      "MAISON", "RAISON", "CUIVRE",
      "BAGDES", "ZIRCON", "SAISON" };
 
    boolean status = false;
    for (int i = 0; i < words.length; i++) {
      for (int j = 0; j < pattern.length(); j++) {
        if (pattern.charAt(j) == '?') {
          continue;
        } else if (pattern.charAt(j) == words[i].charAt(j)) {
          status = true;
        } else {
          status = false;
          break;
        }
      }
      if (status == true) System.out.println(words[i]);
    }
  }
}
 
// Affiche :
MAISON
RAISON
SAISON

Avec une Regexp ça serait plus simple.
Là c'est un exemple qui ignore la casse :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private static List<String> values = Arrays.asList("Maison", "Raison", "Cuivre", "Badges", "Zircon", "Saison");
 
public static void main(String[] args)
{
    Pattern pattern = Pattern.compile("(.a..on)", Pattern.CASE_INSENSITIVE);
    for (String value : values)
    {
        Matcher matcher = pattern.matcher(value);
        if (matcher.find())
        {
            System.out.println(matcher.group(1) + " correspond à la recherche");
        }
    }
}

@OButterlin
Merci pour votre code qui répond parfaitement au problème.
Il me faut vraiment étudier les regex !

Je me suis permis de le modifier quelque peu pour un usage plus général : ajout du pattern à trouver (strToSearchFor) et gestion des ajouts à la liste (add).
De plus, avec l'ajout des import, cet ensemble fonctionnel pourra certainement aider quelqu'un d'autre.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.util.*;
import java.util.regex.*;
 
public class Main {
  //private static List<String> values = Arrays.asList("Maison", "Raison", "Cuivre", "Badges", "Zircon", "Saison");
  static List<String> values = new ArrayList<String>();
  static String strToSearchFor = "(.a..on)";
 
  public static void main(String[] args)
  {
    values.add("Maison");
    values.add("Raison");
    values.add("Cuivre");
    values.add("Badges");
    values.add("Zircon");
    values.add("Saison");
 
    Pattern pattern = Pattern.compile(strToSearchFor, Pattern.CASE_INSENSITIVE);
    for (String value : values)
    {
      Matcher matcher = pattern.matcher(value);
      if (matcher.find())
      {
        System.out.println(matcher.group(1) + " correspond à la recherche");
      }
    }
  }
}

05/03/2024, 22h12
OButterlin

Pas de problème, vous pouvez modifier comme vous voulez ;)

Une petite précision (je crois comprendre que vous ne connaissez pas trop les RegExp) :

Le pattern utilisé est entouré de parenthèses (dans "(.a..on)"), ce qui indique un groupe capturant qu'on récupère via matcher.group(1) ici.
On n'en aurait pas besoin ici pour juste savoir si le mot est conforme à l'expression régulière, un simple matcher.find() ou matcher.matches() aurait suffit.

Et oui, vous devriez vous intéresser aux expressions régulières, c'est super puissant... à défaut d'avoir une syntaxe lisible :aie:
06/03/2024, 11h57
#define

@OButterlin
Bien noté !
Regex en cours de lecture...
Encore merci.
06/03/2024, 23h50
thelvin

@OButterlin Pour info, group() et group(0) permettent de récupérer le texte que la regex a repérée, sans parenthèse. Il n'est donc pas utile de mettre une regex entière entre parenthèses.
07/03/2024, 22h07
OButterlin

1 pièce(s) jointe(s)

Citation:

Envoyé par thelvin

@OButterlin Pour info, group() et group(0) permettent de récupérer le texte que la regex a repérée, sans parenthèse. Il n'est donc pas utile de mettre une regex entière entre parenthèses.

Oui, effectivement, dans ce cas précis ce n'est pas utile.
Mais bon, les groupes capturant sont intéressants quand on cherche des sous-groupes d'une expression
Par exemple pour les groupes de numéros dans un téléphone (format france) : ([0-9]{1,2})-([0-9]{2})-([0-9]{2})-([0-9]{2})-([0-9]{2})

Pièce jointe 651883
https://www.developpez.net/forums/im...BJRU5ErkJggg==