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


5 Answers

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

"(\\d+)"

devrait être capable de trouver la première chaîne de chiffres. Vous n'avez pas besoin de spécifier ce qui est avant, si vous êtes sûr que ce sera la première chaîne de chiffres. De même, il est inutile de spécifier ce qu'il y a après, sauf si vous le souhaitez. Si vous voulez juste le nombre, et êtes sûr que ce sera la première chaîne d'un ou plusieurs chiffres alors c'est tout ce dont vous avez besoin.

Si vous vous attendez à ce qu'il soit compensé par des espaces, cela le rendra encore plus distinct pour spécifier

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

pourrait être mieux.

Si vous avez besoin des trois parties, cela fera:

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

EDIT Les expressions données par Allain et Jack suggèrent que vous devez spécifier un sous-ensemble de non-chiffres afin de capturer des chiffres . Si vous dites au moteur regex que vous cherchez \d alors il va ignorer tout avant les chiffres. Si l'expression de J ou A correspond à votre modèle, alors la correspondance entière est égale à la chaîne d'entrée . Et il n'y a aucune raison de le spécifier. Il ralentit probablement un match propre, si ce n'est pas totalement ignoré.

Question

J'ai plusieurs chaînes sous la forme brute:

[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 (bien que toutes les suggestions soient les bienvenues). Ce qui m'intéresse vraiment, ce sont les appels Java pour prendre la chaîne regex et l'utiliser sur les données source pour produire la valeur de [un certain nombre].

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




Que diriez-vous de [^\\d]*([0-9]+[\\s]*[.,]{0,1}[\\s]*[0-9]*).* Je pense que ce serait prends soin des nombres avec une partie fractionnaire. J'ai inclus des espaces blancs et inclus , comme séparateur possible. J'essaye d'obtenir les nombres sur une chaîne comprenant des flotteurs et en tenant compte du fait que l'utilisateur pourrait faire une erreur et inclure des espaces blancs tout en tapant le nombre.




Regardez, vous pouvez le faire en utilisant StringTokenizer

String str = "as:"+123+"as:"+234+"as:"+345;
StringTokenizer st = new StringTokenizer(str,"as:");

while(st.hasMoreTokens())
{
  String k = st.nextToken();    // you will get first numeric data i.e 123
  int kk = Integer.parseInt(k);
  System.out.println("k string token in integer        " + kk);

  String k1 = st.nextToken();   //  you will get second numeric data i.e 234
  int kk1 = Integer.parseInt(k1);
  System.out.println("new string k1 token in integer   :" + kk1);

  String k2 = st.nextToken();   //  you will get third numeric data i.e 345
  int kk2 = Integer.parseInt(k2);
  System.out.println("k2 string token is in integer   : " + kk2);
}

Puisque nous prenons ces données numériques en trois variables différentes, nous pouvons utiliser ces données n'importe où dans le code (pour une utilisation ultérieure)




si vous lisez le fichier, cela peut vous aider

              try{
             InputStream inputStream = (InputStream) mnpMainBean.getUploadedBulk().getInputStream();
             BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
             String line;
             //Ref:03
             while ((line = br.readLine()) != null) {
                if (line.matches("[A-Z],\\d,(\\d*,){2}(\\s*\\d*\\|\\d*:)+")) {
                     String[] splitRecord = line.split(",");
                     //do something
                 }
                 else{
                     br.close();
                     //error
                     return;
                 }
             }
                br.close();

             }
         }
         catch (IOException  ioExpception){
             logger.logDebug("Exception " + ioExpception.getStackTrace());
         }



En plus de Pattern , la classe Java String a aussi plusieurs méthodes qui peuvent fonctionner avec des expressions régulières, dans votre cas, le code sera:

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

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




Cette fonction collecte toutes les séquences correspondantes de la chaîne. Dans cet exemple, il prend toutes les adresses e-mail de la chaîne.

static final String EMAIL_PATTERN = "[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@"
        + "[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})";

public List<String> getAllEmails(String message) {      
    List<String> result = null;
    Matcher matcher = Pattern.compile(EMAIL_PATTERN).matcher(message);

    if (matcher.find()) {
        result = new ArrayList<String>();
        result.add(matcher.group());

        while (matcher.find()) {
            result.add(matcher.group());
        }
    }

    return result;
}

Pour message = "adf@gmail.com, <another@osiem.osiem>>>> lalala@aaa.pl" il va créer une liste de 3 éléments.






Related



Tags

java java   regex