Comment puis-je obtenir le dernier entier "56" de la chaîne comme RA12KE43SH56?

Pattern p = Pattern.compile("[0-9]+$");
Matcher m = p.matcher(str);
if(m.find()) {
    result = m.group();
}

public class PrefixId {

    public String getTransactionNumber() {

    String prevNumber = "123abc321";
    String incredNumber = "";
    for (int i = prevNumber.length() - 1; i >= 0; i--) {
        char ch = prevNumber.charAt(i);

        if (incredNumber.length() > 0 && !Character.isDigit(ch)) {
            break;
        } else if (Character.isDigit(ch)) {
            incredNumber = incredNumber + ch;
        }

    }
    if (incredNumber.length() > 0) {
        incredNumber = new StringBuffer(incredNumber).reverse().toString();
        prevNumber = prevNumber.replace(incredNumber, ""
                + (Long.parseLong(incredNumber) + 1));
    }
    return prevNumber;
}

public static void main(String[] args) {
    PrefixId prefixId = new PrefixId();
    System.out.println(prefixId.getTransactionNumber());

}
}

Peut-être que quelque chose comme ceci est ce que vous voulez ( Voir aussi sur iDoneone.com ):

static String nextId(String id) {
    String[] parts = id.split("(?=\\d+$)", 2);
    final int L = parts[1].length();
    final int num = Integer.parseInt(parts[1]) + 1;
    return parts[0] + String.format("%0"+L+"d", num);
}
public static void main(String[] args) {
    String[] tests = {
        "jamesBond007", "ra12ke43sh57", "-42", "x888y999", "00000"
    };
    for (String test : tests) {
        System.out.println(nextId(test));
    }
    // prints "jamesBond008", "ra12ke43sh58", "-43", "x888y1000", "00001"
}

• en utilisant string.split (string regex, intension intensive) code> , limité à 2 parties
  • pièces [0] code> est le préfixe statique, éventuellement vide li>
  • parties [1] code> est la séquence de chiffres à la fin de la chaîne li> ul> li>
  • Utilisation de la largeur zéro correspondant à la lunette de lunette positive à scinder
    • (? = \ d + $) code> correspond à une position dans laquelle vous pouvez correspondre à \ d + $ code>
      • c'est-à-dire que le caractère du chiffre \ d code> classe de caractères li>
      • ... répété un ou plusieurs fois + code> li>
      • ... jusqu'à la fin de l'ancrage de chaîne $ code> li> ul> li> ul> li>
      • en utilisant string.format code> pour préserver les zéros de premier plan
        • Un format comme % 05d code> signifie:
          • 0 code>: tampon avec des zéros principaux li>
          • 5 code>: largeur est 5 li>
          • d code>: conversion entier décimal li> ul> li> ul> li> ul>

            Questions connexes h3>

            sur les regards de surveillance: p>

            • Comment l'expression régulière (? travail? li>
            • java Split mange mes personnages. li> ul>

              références h3>

              • régulier-expressions.info/lookarounds , classes de caractères , Repetition , Anchers Li> ul> p>

Pas une réponse, il suffit de mentionner que les expressions régulières "évidentes" pour cela (comme indiqué ci-dessus) ont un comportement quadratique méchant dans le pire des cas (je suis sûr que vous ne traitez pas de tels cas dégénéré, mais C'est intéressant dans son propre accord).

Voici un petit graphique que j'ai préparé: Texte alt http://img517.imageshack.us/img517/1158/IMAGEERP.JPG < / a>

J'ai utilisé des chaînes de la forme "111..111111111111111111111" Il existe des occurrences j de '1'.

La raison de la mauvaise performance est évidente: le matcheur continue de voir 1s et pense heureusement que cela va réussir, et seulement quand il trouve a presque la fin, il trouve que a ne correspond pas à $ , de sorte que cela revient tout en arrière et commence au deuxième caractère.

Au départ, je pensais que les quantifiers possessifs aideraient ici, mais cela n'a pas l'air simple. Même si j'écris \ d ++ , si j'appelle Matcher.find (), il essaiera toujours de faire correspondre le motif à partir de chaque index de toute façon, c'est-à-dire que la boucle extérieure ne prend aucune indication de la précédente échoue de quantifiers possessifs. (Notez que ce problème n'affecte pas la correspondance.Matches (), car cela ne tente que de correspondre à un seul index, le début).

Dans ce problème particulier, pour éviter ce problème, nous devrions inverser la chaîne et rechercher avec un modèle ^ \\ d + ou itérer les caractères à l'envers et faire une correspondance manuelle.