Expression régulière "non greedy" en Java

Bonjour,

J'aimerai pouvoir récupérer la petite chaine de caractère qui commence par 'd' fini par 'a' et contient 'o'

Exemple : "fondjswxaeqobdnoajezbpfrehanxi" => "dnoa"

Voilà mon code :

Code:

---

1 2 3 4 5 6

Pattern pattern = Pattern.compile("d.*?o.*?a"); Matcher matcher = pattern.matcher("fondjswxaeqobdnoajezbpfrehanxi"); while (matcher.find()) { system.out.println(matcher.group()); }

---

Ce code affiche "djswxaeqobdnoa" et non "dnoa".

Comment faire pour bien retourner la plus petite ?

Merci

La solution :

Code:

---

1 2 3 4 5 6 7 8 9 10

String shortest = null; Pattern pattern = Pattern.compile("(?=(d.*?o.*?a))"); Matcher matcher = pattern.matcher("ondjswxaeqobdnoajezbpfrehanxi"); while (matcher.find()) { for (int i = 1; i <= matcher.groupCount(); i++) { if (shortest == null || matcher.group(i).length() < shortest.length()) { shortest = matcher.group(i); } }

---

Joli trick avec le positive lookahead pour forcer find() à avancer caractère par caractère :).

Mais il est inutile de boucler sur les groupes : il n'y en a qu'un, et c'est le numéro 1. Il suffit de faire ça :

Code:

---

1 2 3 4 5 6 7 8 9

String shortest = null; Pattern pattern = Pattern.compile("(?=(d.*?o.*?a))"); Matcher matcher = pattern.matcher("ondjswxaeqobdnoajezbpfrehanxi"); while (matcher.find()) { String candidate = matcher.group(1); if (shortest == null || candidate.length() < shortest.length()) { shortest = candidate; } }

---

Comme je n'aime pas trop les tricks et je préfère garder un programme simple à lire et qui exprime clairement mon intention, voici comment j'aurais fait sans modifier la regex :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

String shortest = null; Pattern pattern = Pattern.compile("d.*?o.*?a"); Matcher matcher = pattern.matcher("ondjswxaeqobdnoajezbpfrehanxi");   int start = 0; while (matcher.find(start)) { String candidate = matcher.group(); if (shortest == null || candidate.length() < shortest.length()) { shortest = candidate; } start = matcher.start()+1; }

---

Pareil, find() n'avance que d'un caractère à la fois.

Ou plus simplement

Code:

---

1 2 3 4 5

Pattern pattern = Pattern.compile("d[^d]*?o.[^a]*?a"); Matcher matcher = pattern.matcher("fondjswxaeqobdnoajezbpfrehanxi"); while (matcher.find()) { system.out.println(matcher.group()); }

---

Hum. Je comprends pas trop l'intérêt du [^a], je suppose que c'est une erreur d'inattention.

Mais sinon je vois l'idée : "invalider la recherche si on trouve un d entre le premier d et le o, pour s'assurer d'avoir le plus court."
Ouais, ok, mais alors... Entre le o et le a, il faut rejeter toute séquence valide de d suivi de o... Ça peut se faire, avec un negative lookbehind. Mais "plus simplement" je suis pas convaincu.

La regex donnée en exemple ne trouve pas le plus court. (précisément parce qu'on tombe sur une séquence de d suivi de o, qui elle-même est suivie d'une autre séquence de d suivi de o, avant de tomber sur le a.)

Ha oui tiens, au temps pour moi :aie:

Une solution sans lookarounds:

Code:

---

d[^do]*o[^da]*(?>d[^oa]*)*a

---

Euh, ouais, mais indépendant ou lookaround, la différence en termes de clarté...

Enfin je dis ça, l'indépendant est là que pour des raisons de performances finalement. La même solution serait d[^do]*o[^da]*(d[^oa]*)*a... Qui marche !
Mais à nouveau, en termes de clarté...