Je souhaiterais utiliser les expressions r=E9guli=E8res (API regex JDK
1=2E4) pour remplacer le caract=E8re '.' par le caract=E8re '#' dans une
cha=EEne de caract=E8re.
J'ai essay=E9 plusieurs expressions r=E9guli=E8res suivantes:
Pattern p =3D Pattern.compile("\\.{1}")
Pattern p =3D Pattern.compile("(.)")
.=2E.
mais sans succ=E8s.
Existe il une expression r=E9guli=E8re adapt=E9e ?
Merci d'avance pour vos r=E9ponses
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Insitu
"mc31" writes:
Bonjour à tous,
Je souhaiterais utiliser les expressions régulières (API regex JDK 1.4) pour remplacer le caractère '.' par le caractère '#' dans une chaîne de caractère.
J'ai essayé plusieurs expressions régulières suivantes: Pattern p = Pattern.compile(".{1}") Pattern p = Pattern.compile("(.)") ... mais sans succès.
Existe il une expression régulière adaptée ?
Peut-etre ([^.].)* pour capturer le pattern a.
Par contre, pour effectuer le remplacement dans la chaine, il ne'est pas possible de le faire directement avec une regex, il faut utiliser l'API matcher. voir http://java.sun.com/j2se/1.5.0/docs/api/java/util/regex/Matcher.html#appendReplacement(java.lang.StringBuffer,%20java.lang.String)
insitu.
"mc31" <mcostes@hotmail.com> writes:
Bonjour à tous,
Je souhaiterais utiliser les expressions régulières (API regex JDK
1.4) pour remplacer le caractère '.' par le caractère '#' dans une
chaîne de caractère.
J'ai essayé plusieurs expressions régulières suivantes:
Pattern p = Pattern.compile("\.{1}")
Pattern p = Pattern.compile("(.)")
...
mais sans succès.
Existe il une expression régulière adaptée ?
Peut-etre
([^.]\.)*
pour capturer le pattern a.
Par contre, pour effectuer le remplacement dans la chaine, il ne'est
pas possible de le faire directement avec une regex, il faut utiliser
l'API matcher.
voir
http://java.sun.com/j2se/1.5.0/docs/api/java/util/regex/Matcher.html#appendReplacement(java.lang.StringBuffer,%20java.lang.String)
Je souhaiterais utiliser les expressions régulières (API regex JDK 1.4) pour remplacer le caractère '.' par le caractère '#' dans une chaîne de caractère.
J'ai essayé plusieurs expressions régulières suivantes: Pattern p = Pattern.compile(".{1}") Pattern p = Pattern.compile("(.)") ... mais sans succès.
Existe il une expression régulière adaptée ?
Peut-etre ([^.].)* pour capturer le pattern a.
Par contre, pour effectuer le remplacement dans la chaine, il ne'est pas possible de le faire directement avec une regex, il faut utiliser l'API matcher. voir http://java.sun.com/j2se/1.5.0/docs/api/java/util/regex/Matcher.html#appendReplacement(java.lang.StringBuffer,%20java.lang.String)
J'ai essayé plusieurs expressions régulières suivantes: Pattern p = Pattern.compile(".{1}") Pattern p = Pattern.compile("(.)") ... mais sans succès.
Existe il une expression régulière adaptée ?
Personnellement, je ne me casserais pas la tête, un truc comme ça je le ferais spontanément en 2 temps et 3 mouvements :
1e étape : .. -> ZORGLUB 2e étape : . -> # 3e étape : ZORGLUB -> ..
(quand je dis ZORGLUB, bien sûr tu peux mettre ce que tu veux, un unique caractère si tu veux, pourvu qu'il ne se retrouve nulle part ailleurs dans la chaîne de caractères que tu veux modifier)
J'ai essayé plusieurs expressions régulières suivantes:
Pattern p = Pattern.compile("\.{1}")
Pattern p = Pattern.compile("(.)")
...
mais sans succès.
Existe il une expression régulière adaptée ?
Personnellement, je ne me casserais pas la tête, un truc comme ça je le
ferais spontanément en 2 temps et 3 mouvements :
1e étape : .. -> ZORGLUB
2e étape : . -> #
3e étape : ZORGLUB -> ..
(quand je dis ZORGLUB, bien sûr tu peux mettre ce que tu veux, un unique
caractère si tu veux, pourvu qu'il ne se retrouve nulle part ailleurs
dans la chaîne de caractères que tu veux modifier)
J'ai essayé plusieurs expressions régulières suivantes: Pattern p = Pattern.compile(".{1}") Pattern p = Pattern.compile("(.)") ... mais sans succès.
Existe il une expression régulière adaptée ?
Personnellement, je ne me casserais pas la tête, un truc comme ça je le ferais spontanément en 2 temps et 3 mouvements :
1e étape : .. -> ZORGLUB 2e étape : . -> # 3e étape : ZORGLUB -> ..
(quand je dis ZORGLUB, bien sûr tu peux mettre ce que tu veux, un unique caractère si tu veux, pourvu qu'il ne se retrouve nulle part ailleurs dans la chaîne de caractères que tu veux modifier)
-- Christophe Franco
Zazoun
On Jan 17, 3:28 pm, Insitu wrote:
"mc31" writes:
Bonjour à tous,
Je souhaiterais utiliser les expressions régulières (API regex JDK 1.4) pour remplacer le caractère '.' par le caractère '#' dans une chaîne de caractère.
J'ai essayé plusieurs expressions régulières suivantes: Pattern p = Pattern.compile(".{1}") Pattern p = Pattern.compile("(.)") ... mais sans succès.
Existe il une expression régulière adaptée ?Peut-etre ([^.].)*
pour capturer le pattern a.
Par contre, pour effectuer le remplacement dans la chaine, il ne'est pas possible de le faire directement avec une regex, il faut utiliser l'API matcher. voirhttp://java.sun.com/j2se/1.5.0/docs/api/java/util/regex/Matcher.html# ...)
insitu.
Eh si c'est possible ! Il faut utiliser le pattern : "(?<!.).(?!.)", c'est-à-dire : un "." qui n'est ni suivi ni précédé par un ".".
On Jan 17, 3:28 pm, Insitu <ins...@achilleus.net> wrote:
"mc31" <mcos...@hotmail.com> writes:
Bonjour à tous,
Je souhaiterais utiliser les expressions régulières (API regex JDK
1.4) pour remplacer le caractère '.' par le caractère '#' dans une
chaîne de caractère.
J'ai essayé plusieurs expressions régulières suivantes:
Pattern p = Pattern.compile("\.{1}")
Pattern p = Pattern.compile("(.)")
...
mais sans succès.
Existe il une expression régulière adaptée ?Peut-etre
([^.]\.)*
pour capturer le pattern a.
Par contre, pour effectuer le remplacement dans la chaine, il ne'est
pas possible de le faire directement avec une regex, il faut utiliser
l'API matcher.
voirhttp://java.sun.com/j2se/1.5.0/docs/api/java/util/regex/Matcher.html# ...)
insitu.
Eh si c'est possible ! Il faut utiliser le pattern :
"(?<!\.)\.(?!\.)", c'est-à-dire : un "." qui n'est ni suivi ni
précédé par un ".".
Je souhaiterais utiliser les expressions régulières (API regex JDK 1.4) pour remplacer le caractère '.' par le caractère '#' dans une chaîne de caractère.
J'ai essayé plusieurs expressions régulières suivantes: Pattern p = Pattern.compile(".{1}") Pattern p = Pattern.compile("(.)") ... mais sans succès.
Existe il une expression régulière adaptée ?Peut-etre ([^.].)*
pour capturer le pattern a.
Par contre, pour effectuer le remplacement dans la chaine, il ne'est pas possible de le faire directement avec une regex, il faut utiliser l'API matcher. voirhttp://java.sun.com/j2se/1.5.0/docs/api/java/util/regex/Matcher.html# ...)
insitu.
Eh si c'est possible ! Il faut utiliser le pattern : "(?<!.).(?!.)", c'est-à-dire : un "." qui n'est ni suivi ni précédé par un ".".
Maxime Daniel
...
Eh si c'est possible ! Il faut utiliser le pattern : "(?<!.).(?!.)", c'est-à-dire : un "." qui n'est ni suivi ni précédé par un ".". Bien joué !
En revanche, à moins que le nombre d'invocations soit réduit, donc que les performances ne soient pas problématiques, je taperais personnellement directement dans une machine à états qui va bien.
...
Eh si c'est possible ! Il faut utiliser le pattern :
"(?<!\.)\.(?!\.)", c'est-à-dire : un "." qui n'est ni suivi ni
précédé par un ".".
Bien joué !
En revanche, à moins que le nombre d'invocations soit réduit, donc
que les performances ne soient pas problématiques, je taperais
personnellement directement dans une machine à états qui va bien.
Eh si c'est possible ! Il faut utiliser le pattern : "(?<!.).(?!.)", c'est-à-dire : un "." qui n'est ni suivi ni précédé par un ".". Bien joué !
En revanche, à moins que le nombre d'invocations soit réduit, donc que les performances ne soient pas problématiques, je taperais personnellement directement dans une machine à états qui va bien.
Hervé AGNOUX
Maxime Daniel wrote:
Bien joué ! En revanche, à moins que le nombre d'invocations soit réduit, donc que les performances ne soient pas problématiques, je taperais personnellement directement dans une machine à états qui va bien.
Mais... les regexps ne sont pas traduites en machine à états, au final ??
Si non, elles sont traduites en quoi, alors ?
Si oui, qu'est-ce que cela apporterait de plus, à fonctionnement équivalent ?
-- Hervé AGNOUX http://www.diaam-informatique.com
Maxime Daniel wrote:
Bien joué !
En revanche, à moins que le nombre d'invocations soit réduit, donc
que les performances ne soient pas problématiques, je taperais
personnellement directement dans une machine à états qui va bien.
Mais... les regexps ne sont pas traduites en machine à états, au final ??
Si non, elles sont traduites en quoi, alors ?
Si oui, qu'est-ce que cela apporterait de plus, à fonctionnement
équivalent ?
Bien joué ! En revanche, à moins que le nombre d'invocations soit réduit, donc que les performances ne soient pas problématiques, je taperais personnellement directement dans une machine à états qui va bien.
Mais... les regexps ne sont pas traduites en machine à états, au final ??
Si non, elles sont traduites en quoi, alors ?
Si oui, qu'est-ce que cela apporterait de plus, à fonctionnement équivalent ?
-- Hervé AGNOUX http://www.diaam-informatique.com
Insitu
"Zazoun" writes:
Eh si c'est possible ! Il faut utiliser le pattern :
Le "possible" s'appliquait au remplacement, pas à la définition d'une expression.
insitu.
"Zazoun" <zazoun@gmail.com> writes:
Eh si c'est possible ! Il faut utiliser le pattern :
Le "possible" s'appliquait au remplacement, pas à la définition d'une
expression.
Eh si c'est possible ! Il faut utiliser le pattern :
Le "possible" s'appliquait au remplacement, pas à la définition d'une expression.
insitu.
Zazoun
Eh si c'est possible ! Il faut utiliser le pattern :Le "possible" s'app liquait au remplacement, pas à la définition d'une expression.
Au temps pour moi si j'avais mal compris. En tout cas, une fois l'expression régulière définie, on peut utiliser simplement la méthode String.replaceAll(...) (qui elle-même utilise Matcher et Pattern de toutes façons)
Eh si c'est possible ! Il faut utiliser le pattern :Le "possible" s'app liquait au remplacement, pas à la définition d'une
expression.
Au temps pour moi si j'avais mal compris. En tout cas, une fois
l'expression régulière définie, on peut utiliser simplement la
méthode String.replaceAll(...) (qui elle-même utilise Matcher et
Pattern de toutes façons)
Eh si c'est possible ! Il faut utiliser le pattern :Le "possible" s'app liquait au remplacement, pas à la définition d'une expression.
Au temps pour moi si j'avais mal compris. En tout cas, une fois l'expression régulière définie, on peut utiliser simplement la méthode String.replaceAll(...) (qui elle-même utilise Matcher et Pattern de toutes façons)
Maxime Daniel
Maxime Daniel wrote:
Bien joué ! En revanche, à moins que le nombre d'invocations soit réduit, donc que les performances ne soient pas problématiques, je taperais personnellement directement dans une machine à états qui va bien.
Mais... les regexps ne sont pas traduites en machine à états, au fina l ??
Il y a plusieurs classes de machines à états, même pour des
expressions lexicales (l'analyse des expressions syntaxiques implique le plus souvent des machines à piles). Par ailleurs, la technique normale pour des expressions fournies à runtime consiste à faire travailler un moteur générique et invariant sur des tables qui, elles, reflètent l'expression particulière considérée. de sorte que, pour un cas simpliste comme celui exposé, et s'il s'agit d'un besoin isolé, on gagnera à implanter une machine à états dédiée et optimisée.
Si non, elles sont traduites en quoi, alors ?
A priori donc, et sans avoir regardé l'implantation dans la
bibliothèque, elles sont traduites en un paramétrage d'une machine à états générique.
Si oui, qu'est-ce que cela apporterait de plus, à fonctionnement équivalent ?
Des performances.
Lorsque l'expression ou l'ensemble d'expressions considérés sont complexes, l'utilisation d'un moteur générique ayant bénéficié d'un effort important tant au point de vue de la théorie que de l'implantation, et des algorithmes d'optimisation des paramètres associés (minimisation du nombre d'états par réduction des sous-graphes similaires, techniques de codages à indirections comme dans lex, etc.) amènent un gain par rapport à ce que le programmeur peut espérer atteindre avec un effort raisonnable. Le premier gain est d'ailleurs la réduction du nombre d'erreurs potentielles. Mais dans le cas simpliste et évident, le codage manuel est à la fois raisonnable en termes de coût et de risque, et optimal en temps et espace. C'est un peu le même arbitrage qu'entre l'utilisation de la calculatrice et l'utilisation du tableur. Au-delà d'une certaine complexité et d'un certain volume, le tableur apporte des avantages indéniables. Mais pour une opération toute simple, la calculatrice est plus commode et plus rapide.
-- Hervé AGNOUX http://www.diaam-informatique.com
Maxime Daniel wrote:
Bien joué !
En revanche, à moins que le nombre d'invocations soit réduit, donc
que les performances ne soient pas problématiques, je taperais
personnellement directement dans une machine à états qui va bien.
Mais... les regexps ne sont pas traduites en machine à états, au fina l ??
Il y a plusieurs classes de machines à états, même pour des
expressions lexicales (l'analyse des expressions syntaxiques implique
le plus souvent des machines à piles). Par ailleurs, la technique
normale pour des expressions fournies à runtime consiste à faire
travailler un moteur générique et invariant sur des tables qui,
elles, reflètent l'expression particulière considérée. de sorte
que, pour un cas simpliste comme celui exposé, et s'il s'agit d'un
besoin isolé, on gagnera à implanter une machine à états dédiée
et optimisée.
Si non, elles sont traduites en quoi, alors ?
A priori donc, et sans avoir regardé l'implantation dans la
bibliothèque, elles sont traduites en un paramétrage d'une machine à
états générique.
Si oui, qu'est-ce que cela apporterait de plus, à fonctionnement
équivalent ?
Des performances.
Lorsque l'expression ou l'ensemble d'expressions considérés sont
complexes, l'utilisation d'un moteur générique ayant bénéficié
d'un effort important tant au point de vue de la théorie que de
l'implantation, et des algorithmes d'optimisation des paramètres
associés (minimisation du nombre d'états par réduction des
sous-graphes similaires, techniques de codages à indirections comme
dans lex, etc.) amènent un gain par rapport à ce que le programmeur
peut espérer atteindre avec un effort raisonnable. Le premier gain est
d'ailleurs la réduction du nombre d'erreurs potentielles. Mais dans le
cas simpliste et évident, le codage manuel est à la fois raisonnable
en termes de coût et de risque, et optimal en temps et espace.
C'est un peu le même arbitrage qu'entre l'utilisation de la
calculatrice et l'utilisation du tableur. Au-delà d'une certaine
complexité et d'un certain volume, le tableur apporte des avantages
indéniables. Mais pour une opération toute simple, la calculatrice
est plus commode et plus rapide.
Bien joué ! En revanche, à moins que le nombre d'invocations soit réduit, donc que les performances ne soient pas problématiques, je taperais personnellement directement dans une machine à états qui va bien.
Mais... les regexps ne sont pas traduites en machine à états, au fina l ??
Il y a plusieurs classes de machines à états, même pour des
expressions lexicales (l'analyse des expressions syntaxiques implique le plus souvent des machines à piles). Par ailleurs, la technique normale pour des expressions fournies à runtime consiste à faire travailler un moteur générique et invariant sur des tables qui, elles, reflètent l'expression particulière considérée. de sorte que, pour un cas simpliste comme celui exposé, et s'il s'agit d'un besoin isolé, on gagnera à implanter une machine à états dédiée et optimisée.
Si non, elles sont traduites en quoi, alors ?
A priori donc, et sans avoir regardé l'implantation dans la
bibliothèque, elles sont traduites en un paramétrage d'une machine à états générique.
Si oui, qu'est-ce que cela apporterait de plus, à fonctionnement équivalent ?
Des performances.
Lorsque l'expression ou l'ensemble d'expressions considérés sont complexes, l'utilisation d'un moteur générique ayant bénéficié d'un effort important tant au point de vue de la théorie que de l'implantation, et des algorithmes d'optimisation des paramètres associés (minimisation du nombre d'états par réduction des sous-graphes similaires, techniques de codages à indirections comme dans lex, etc.) amènent un gain par rapport à ce que le programmeur peut espérer atteindre avec un effort raisonnable. Le premier gain est d'ailleurs la réduction du nombre d'erreurs potentielles. Mais dans le cas simpliste et évident, le codage manuel est à la fois raisonnable en termes de coût et de risque, et optimal en temps et espace. C'est un peu le même arbitrage qu'entre l'utilisation de la calculatrice et l'utilisation du tableur. Au-delà d'une certaine complexité et d'un certain volume, le tableur apporte des avantages indéniables. Mais pour une opération toute simple, la calculatrice est plus commode et plus rapide.
