Expression régulière pour extraire les nombres précédents avec des points facultatifs

Nous pouvons essayer d'utiliser le modèle d'expression régulière suivant sur chaque ligne:

String line = "45.67.21234.3";
String pattern = "^(?!\\D*\\d[^0-9.]+\\d).*\\b\\d+(?:\\.\\d+)?(?=\\s|$).*$";
Pattern r = Pattern.compile(pattern);
Matcher m = r.matcher(line);
if (m.find()) {
    System.out.println("match");
}
else {
    System.out.println("no match");
}

Explication:

^                            from the start of the line
    (?!\D*\d[^0-9.]+\d)      assert that two (or more) separate numbers
                             do not occur in the line
    .*                       then consume anything, up to
    \b\d+(?:\.\d+)?          an integer, or complete decimal
    (?=\\s|$)                where either a space or the end of the line follows
    .*                       then consume anything, up to
$                            the end of the line

Voici un code Java utilisant ceci pattern:

^(?!\D*\d[^0-9.]+\d).*\b\d+(?:\.\d+)?(?=\\s|$).*$

Je l'ai testé avec toutes vos entrées et il semble fonctionner.

L'utilisation de (\ d + \.) + \ d ne correspondra pas à la première entrée car en utilisant le quantificateur + , il doit correspondre au moins 1 fois à un chiffre et à un point.

Ce que vous pouvez faire, c'est utiliser une ancre ^ pour affirmer le début de la chaîne et utiliser un modèle pour faire correspondre les chiffres, puis répéter la correspondance d'un point et des chiffres zéro ou plusieurs fois. correspond à la première entrée.

Après la correspondance, assurez-vous que les chiffres ne sont pas suivis d'un caractère non blanc. S'il ne peut plus y avoir de chiffres à la suite, vous pouvez utiliser une anticipation négative supplémentaire.

String regex = "^\\d+(?:\\.\\d+)*(?!\\S)(?!.*\\d)";

En Java:

^\d+(?:\.\d+)*(?!\S)(?!.*\d)

Explication

• ^ Début de la chaîne
• \ d + (?: \. \ d +) * Correspond à 1+ chiffres suivi d'un motif répétitif pour faire correspondre un point et 1+ chiffres
• (?! \ S) une recherche négative pour vérifier que ce qui se trouve à gauche n'est pas un caractère non blanc
• (?!. * \ d) La recherche négative pour vérifier que ce qui se trouve à droite ne contient pas de chiffre

Une expression régulière que vous pourriez utiliser est:

// TODO: Give proper method name
String test(String str){
  String regex = "^((\\d+\\.)*\\d+) \\D*$";
  if(str.matches(regex))
    return str.replaceFirst(regex, "$1");
    // The `$1` will leave just the match of the first capture group,
    // removing everything else we don't need
  else
    return null;
}

Où le groupe de capture 1 contiendrait votre correspondance.

Explication: p>

^              # Start of the String
 (             # Open capture group 1:
  (\d+\.)      #  One or more digits, followed by a dot
         *     #  Repeated 0 or more times
          \d+  #  Followed by 1 or more digits
 )             # Closing capture group 1
               # Followed by a space
   \D*         # Followed by 0 or more non-digits
$              # Followed by the end of the String

Les ^ et $ nous feront regarder la chaîne entière. Le \ D * s'assurera qu'il n'y a pas de chiffres dans la sous-chaîne après l'espace. Et le \ d + après le (\ d + \.) * s'assure qu'il y a toujours un chiffre de début, avec un ou plusieurs #. avant it (où # est un nombre non négatif).

Pour extraire cette valeur, vous pouvez utiliser cette expression régulière avec un String.matches et .replaceFirst code> comme ceci: p>

^((\d+\.)*\d+) \D*$