Regex pour trouver un entier au sein d'une chaîne

Je voudrais utiliser des regex avec Java.

Ce que je veux faire est de trouver le premier entier en une chaîne de caractères.

Exemple:

String = "the 14 dogs ate 12 bones"

Serait de retour 14.

String = "djakld;asjl14ajdka;sdj"

Serait également de retour 14.

C'est ce que j'ai jusqu'à présent.

Pattern intsOnly = Pattern.compile("\\d*");
Matcher makeMatch = intsOnly.matcher("dadsad14 dssaf jfdkasl;fj");
makeMatch.find();
String inputInt = makeMatch.group();
System.out.println(inputInt);

Ce que je fais mal?

InformationsquelleAutor mscccc | 2008-12-16

50

Vous allez avoir 0 ou plusieurs chiffres. Vous devez vous poser pour 1 ou plus:
```
"\\d+"
```
- Que faire si vous voulez trouver le même résultat, mais aussi tous les négatifs et positifs + char en face? I. e. +3 ou 5 ou 8...
InformationsquelleAutor
3

Il semble comme les autres solutions ont échoué à poignée +/- et des cas comme 2e3, qui java.lang.Integer.parseInt(String) prend en charge, donc je vais prendre mon go sur le problème. Je suis un peu inexpérimenté à regex, donc j'ai peut-être fait quelques erreurs, utilisé quelque chose que Java regex analyseur ne prend pas en charge, ou il fait trop compliqué, mais les états semblent travailler dans Kiki 0.5.6.

Toutes les expressions régulières sont fournis dans les deux non échappés de format pour la lecture, et un format d'échappement que vous pouvez utiliser comme un littéral de chaîne en Java.

Pour obtenir un byte, short, int, long ou à partir d'une chaîne:
```
unescaped: ([\+-]?\d+)([eE][\+-]?\d+)?
  escaped: ([\\+-]?\\d+)([eE][\\+-]?\\d+)?
```
...et pour les points de bonus...

Pour obtenir un double ou float à partir d'une chaîne:
```
unescaped: ([\+-]?\d(\.\d*)?|\.\d+)([eE][\+-]?(\d(\.\d*)?|\.\d+))?
  escaped: ([\\+-]?\\d(\\.\\d*)?|\\.\d+)([eE][\\+-]?(\\d(\\.\\d*)?|\\.\\d+))?
```
- Cette attirent encore des chiffres comme 099, sur lequel java parseInt va jeter NumberFormatException.
- Je doit être un malentendu vous. 099 est converti à 99 par Integer.parseInt(), voir: pastie.org/1881188
- Est-ce à encore fonctionner si le nombre est dans une chaîne comme "2-1"? Il serait correctement trouver le premier match "2", mais le deuxième match "-1" est incorrect, car il l'est un opérateur. Vous devez utiliser quelque chose d'encore plus fantaisiste (impliquant un lookbehind qui serait disinclude un + ou un - si le précède immédiatement le truc, c'est aussi un nombre)
InformationsquelleAutor bgw

Heres une pratique que j'ai fait pour le C# avec les génériques. Il permettra de match en fonction de votre expression régulière et retourner les types dont vous avez besoin:

public T[] GetMatches<T>(string Input, string MatchPattern) where T : IConvertible
    {
        List<T> MatchedValues = new List<T>();
        Regex MatchInt = new Regex(MatchPattern);

        MatchCollection Matches = MatchInt.Matches(Input);
        foreach (Match m in Matches)
            MatchedValues.Add((T)Convert.ChangeType(m.Value, typeof(T)));

        return MatchedValues.ToArray<T>();
    }

alors si vous voulais récupérer uniquement les chiffres et de les renvoyer dans une string[] tableau:

string Test = "22$data44abc";
string[] Matches = this.GetMatches<string>(Test, "\\d+");

Espérons que cela est utile à quelqu'un...

InformationsquelleAutor Chris Smith

0

En plus de ce PiPeep dit, si vous essayez de faire correspondre des nombres entiers à l'intérieur d'une expression, de sorte que 1 + 2 - 3 ne correspondent 1, 2, et 3, plutôt que de 1, + 2 et - 3, vous avez réellement besoin d'un lookbehind déclaration, et la partie que vous voulez réellement être retourné par Matcher.group(2) plutôt que de simplement Matcher.group().
```
unescaped: ([0-9])?((?(1)(?:[\+-]?\d+)|)(?:[eE][\+-]?\d+)?)
  escaped: ([0-9])?((?(1)(?:[\\+-]?\\d+)|)(?:[eE][\\+-]?\\d+)?)
```
Également, pour des choses comme someNumber - 3, où someNumber est un nom de variable ou quelque chose comme ça, vous pouvez utiliser
```
unescaped: (\w)?((?(1)(?:[\+-]?\d+)|)(?:[eE][\+-]?\d+)?)
  escaped: (\\w)?((?(1)(?:[\\+-]?\\d+)|)(?:[eE][\\+-]?\\d+)?)
```
Même si bien sûr, qui ne fonctionneront pas si vous êtes de l'analyse d'une chaîne de caractères comme The net change to blahblah was +4
- Je ne vois pas de lookbehinds dans les regexes. Ce que je vois sont conditions, qui ne sont pas pris en charge dans Java.
InformationsquelleAutor AJMansfield

la java spec donne réellement de ce monstre d'une regex pour l'analyse en double.
cependant, il est considéré comme une mauvaise pratique, tout en essayant d'analyser le type et la capture de l'erreur, a tendance à être un peu plus lisible.

DOUBLE_PATTERN = Pattern
        .compile("[\\x00-\\x20]*[+-]?(NaN|Infinity|((((\\p{Digit}+)(\\.)?((\\p{Digit}+)?)"
                + "([eE][+-]?(\\p{Digit}+))?)|(\\.((\\p{Digit}+))([eE][+-]?(\\p{Digit}+))?)|"
                + "(((0[xX](\\p{XDigit}+)(\\.)?)|(0[xX](\\p{XDigit}+)?(\\.)(\\p{XDigit}+)))"
                + "[pP][+-]?(\\p{Digit}+)))[fFdD]?))[\\x00-\\x20]*");

InformationsquelleAutor user3034617

Utiliser l'un d'eux:

Pattern intsOnly = Pattern.compile("[0-9]+");

Pattern intsOnly = Pattern.compile("\\d+");

InformationsquelleAutor Sanjaya Deshapriya

Vous devez vous connecter pour publier un commentaire.