Utilisation d'expressions régulières pour extraire une valeur en Java

Question

J'ai plusieurs cordes à l'état brut :

[some text] [some number] [some more text]

Je veux extraire le texte dans [un certain nombre] en utilisant les classes Java Regex.

Je sais à peu près quelle expression régulière je veux utiliser (mais toutes les suggestions sont les bienvenues). Ce qui m'intéresse vraiment, ce sont les appels Java qui prennent la chaîne d'expressions régulières et l'utilisent sur les données sources pour produire la valeur de [un certain nombre].

EDIT : Je dois ajouter que je ne suis intéressé que par un seul [un certain nombre] (en fait, la première occurrence). Les chaînes sources sont courtes et je ne vais pas chercher de multiples occurrences de [un certain nombre].

Answer 1

Exemple complet :

private static final Pattern p = Pattern.compile("^([a-zA-Z]+)([0-9]+)(.*)");
public static void main(String[] args) {
    // create matcher for pattern p and given string
    Matcher m = p.matcher("Testing123Testing");

    // if an occurrence if a pattern was found in a given string...
    if (m.find()) {
        // ...then you can use group() methods.
        System.out.println(m.group(0)); // whole matched expression
        System.out.println(m.group(1)); // first expression from round brackets (Testing)
        System.out.println(m.group(2)); // second one (123)
        System.out.println(m.group(3)); // third one (Testing)
    }
}

Puisque vous cherchez le premier nombre, vous pouvez utiliser une telle regexp :

^\D+(\d+).*

et m.group(1) vous renverra le premier nombre. Notez que les nombres signés peuvent contenir un signe moins :

^\D+(-?\d+).*

Answer 2

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

public class Regex1 {
    public static void main(String[]args) {
        Pattern p = Pattern.compile("\\d+");
        Matcher m = p.matcher("hello1234goodboy789very2345");
        while(m.find()) {
            System.out.println(m.group());
        }
    }
}

Sortie :

1234
789
2345

Answer 3

Allain a essentiellement le code Java, vous pouvez donc l'utiliser. Cependant, son expression ne correspond qu'à si vos chiffres sont uniquement précédés d'un flux de caractères de mots.

"(\\d+)"

devrait être capable de trouver la première chaîne de chiffres. Il n'est pas nécessaire de préciser ce qui se trouve avant, si vous êtes sûr qu'il s'agit de la première chaîne de chiffres. De même, il est inutile de préciser ce qui se trouve après, sauf si vous le souhaitez. Si vous voulez simplement le nombre, et que vous êtes sûr qu'il s'agira de la première chaîne d'un ou plusieurs chiffres, c'est tout ce dont vous avez besoin.

Si vous vous attendez à ce qu'il soit décalé par des espaces, il sera encore plus distinct de spécifier

"\\s+(\\d+)\\s+"

pourrait être mieux.

Si vous avez besoin des trois parties, cela fera l'affaire :

"(\\D+)(\\d+)(.*)"

EDIT Les expressions données par Allain et Jack suggèrent que vous devez spécifier un certain sous-ensemble de non-digits afin de capturer chiffres . Si vous dites au moteur de regex que vous recherchez \d alors il va ignorer tout ce qui se trouve avant les chiffres. Si l'expression de J ou A s'adapte à votre modèle, puis l'ensemble de la correspondance est égal à le site chaîne de saisie . Et il n'y a aucune raison de le préciser. Il ralentit probablement un match propre, s'il n'est pas totalement ignoré.

Answer 4

En plus de Patronage le Java Chaîne de caractères a également plusieurs méthodes qui peuvent fonctionner avec des expressions régulières, dans votre cas le code sera :

"ab123abc".replaceFirst("\\D*(\\d*).*", "$1")

où \\D est un caractère non numérique.

Answer 5

En Java 1.4 et plus :

String input = "...";
Matcher matcher = Pattern.compile("[^0-9]+([0-9]+)[^0-9]+").matcher(input);
if (matcher.find()) {
    String someNumberStr = matcher.group(1);
    // if you need this to be an int:
    int someNumberInt = Integer.parseInt(someNumberStr);
}