Discussion :

[#define]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[OButterlin]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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");
        }
    }
}

[#define]

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

Sélectionner tout - Visualiser dans une fenêtre à part

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");
      }
    }
  }
}

[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

[#define]

@OButterlin
Bien noté !
Regex en cours de lecture...
Encore merci.

[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.

[OButterlin]

@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})