J'ai besoin d'écrire un modèle pour supprimer le symbole monétaire et la virgule. par exemple Fr.-145,000.01 Après le pattern matcher doit retourner -145000.01.

Le modèle que j'utilise:

^[^0-9\\-]*([0-9\\-\\.\\,]*?)[^0-9\\-]*$

Cela renverra -145,000.01

Ensuite, je supprime la virgule pour obtenir -145000.01, je veux demander si c'est possible que je change le modèle et obtienne directement -145000.01

String pattern = "^[^0-9\\-]*([0-9\\-\\.\\,]*?)[^0-9\\-]*$";
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(str);
if(m.matches()) {
 System.out.println(m.group(1));
}

J'espère que la sortie pourrait résoudre la virgule

2
X.walt 19 juin 2019 à 17:50

5 réponses

Meilleure réponse

Vous pouvez simplement le faire avec String.replaceAll() et une expression régulière plus simple (à condition que vous vous attendiez à ce que l'entrée soit raisonnablement saine, c'est-à-dire sans plusieurs points décimaux intégrés dans les nombres ou plusieurs signes négatifs)

   String str = "Fr.-145,000.01";
   str.replaceAll("[^\\d-.]\\.?", "")

Si vous empruntez cette voie, je vérifierais la santé mentale en analysant la sortie avec BigDecimal ou Double.

1
Marc G. Smith 19 juin 2019 à 15:28

Une approche consisterait simplement à collecter les chiffres souhaités, ., + et - dans un groupe de capture suivi d'une virgule facultative, puis à les joindre:

([+-]?[0-9][0-9.]+),?

Tester

import java.util.regex.Matcher;
import java.util.regex.Pattern;

final String regex = "([+-]?[0-9][0-9.]+),?";
final String string = "Fr.-145,000.01\n"
     + "Fr.-145,000\n"
     + "Fr.-145,000,000\n"
     + "Fr.-145\n"
     + "Fr.+145,000.01\n"
     + "Fr.+145,000\n"
     + "Fr.145,000,000\n"
     + "Fr.145\n"
     + "Fr.145,000,000,000.01";

final Pattern pattern = Pattern.compile(regex, Pattern.MULTILINE);
final Matcher matcher = pattern.matcher(string);

while (matcher.find()) {
    System.out.println("Full match: " + matcher.group(0));
    for (int i = 1; i <= matcher.groupCount(); i++) {
        System.out.println("Group " + i + ": " + matcher.group(i));
    }
}

Démo

1
Emma 19 juin 2019 à 14:59
String str = "Fr.-145,000.01";

Pattern regex = Pattern.compile("^[^0-9-]*(-?[0-9]+)(?:,([0-9]{3}))?(?:,([0-9]{3}))?(?:,([0-9]{3}))?(\\.[0-9]+)?[^0-9-]*$");
Matcher matcher = regex.matcher(str);
System.out.println(matcher.replaceAll("$1$2$3$4$5"));

Production:

-145000.01

Il recherche un nombre avec jusqu'à 3 virgules (jusqu'à 999 999 999 999,99) et le remplace par les chiffres.

1
Markus Jarderot 19 juin 2019 à 15:08

Mon approche serait de supprimer toutes les parties inutiles en utilisant replaceAll.

Les parties inutiles sont, apparemment:

  1. Toute séquence qui n'est ni chiffres ni moins au début de la chaîne.
  2. Virgules

Le premier motif est représenté par ^[^\\d-]+. Le second est simplement ,.

Associez-les avec un |:

Pattern p = Pattern.compile("(^[^\\d-]+)|,");
Matcher m = p.matcher(str);
String result = m.replaceAll("");
1
RealSkeptic 19 juin 2019 à 15:18

Vous pouvez capturer deux groupes et utiliser la répétition de la correspondance en utilisant l'ancre \G pour affirmer la position à la fin de la correspondance précédente.

(?:^[^0-9+-]+(?=[.+,\d-]*\.\d+$)([+-]?\d{1,3})|\G(?!^)),(\d{3})

En Java

String regex = "(?:^[^0-9+-]+(?=[.+,\\d-]*\\.\\d+$)([+-]?\\d{1,3})|\\G(?!^)),(\\d{3})";

Explication

  • (?: Groupe non capturant
  • ^[^0-9+-]+ Faites correspondre plus de 1 fois pas un chiffre, + ou -
  • (?= Recherche positive, affirmer que ce qui suit est:
    • [.+,\d-]*\.\d+$ Faire correspondre 0 fois ou plus ce qui est autorisé et affirmer se terminant par . et 1 chiffre ou plus
  • ) Fermer l'anticipation positive
  • ( Capture du groupe 1
    • [+-]?\d{1,3}) Correspondance facultative + ou - suivie de 1 à 3 chiffres
    • | Ou
    • \G(?!^) Affirmer sa position à la fin de la correspondance précédente, pas au début
  • ), Fermez le groupe de capture 1 et faites correspondre ,
  • (\d{3}) Capturer dans le groupe 2 correspondant à 3 chiffres

Dans le remplacement, utilisez les 2 groupes de capture $1$2

Voir la démo Regex | Démo Java

1
The fourth bird 19 juin 2019 à 16:17