Expression régulière correspondant littéral entier

Quelque chose comme ça:

virgule:
(?:0|[1-9](?:_*[0-9])*)[lL]?

hexadécimal:
0x[a-fA-F0-9](?:_*[a-fA-F0-9])*[lL]?

octal:
0[0-7](?:_*[0-7])*[lL]?

binaire:
0[bB][01](?:_*[01])*[lL]?

Tous ensemble: (en freespacing mode)

(?:
    0
    (?:
        x [a-fA-F0-9] (?: _* [a-fA-F0-9] )*
      |
        [0-7] (?: _* [0-7] )*
      |
        [bB] [01] (?: _* [01] )*
    )?
  |
    [1-9] (?: _* [0-9] )*
)
[lL]?

tester

Après la réponse de Casimir, j'ai décidé de prendre un peu plus loin et la mise en œuvre du code de réellement analyser les entiers ainsi, inclus ci-dessous. Il comprend le moins et plus de symboles, même si ceux-ci ne sont pas officiellement partie de l'entier littéral comme décrit dans la JLS; ils sont des opérateurs unaires.

package nl.owlstead.ifprops;

import java.math.BigInteger;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public final class JavaIntegerParser {
    private static final Pattern BINARY = Pattern.compile("(0b)([01](?:_*[01])*)(L?)", Pattern.CASE_INSENSITIVE);
    private static final Pattern OCTAL = Pattern.compile("(0)([0-7](?:_*[0-7])*)(L?)", Pattern.CASE_INSENSITIVE);
    private static final Pattern DECIMAL = Pattern.compile("()(0|(?:[1-9](?:_*[0-9])*))(L?)", Pattern.CASE_INSENSITIVE);
    private static final Pattern HEXADECIMAL = Pattern.compile("(0x)([0-9a-f](?:_*[0-9a-f])*)(L?)", Pattern.CASE_INSENSITIVE);
   
    // NOTE: OCTAL should be before DECIMAL if this is used to find the pattern
    private static final Pattern SIGNED_INTEGER_LITERAL = Pattern.compile(
            "(?:([+-])\\s*)?(" + 
            BINARY + "|" + OCTAL + "|" + DECIMAL + "|" + HEXADECIMAL + 
            ")", Pattern.CASE_INSENSITIVE);
        
    public static int parseJavaInteger(String javaInteger) throws NumberFormatException {
        BigInteger value = parseIntegerAsBigInt(javaInteger);
        try {
            return value.intValueExact();
        } catch (@SuppressWarnings("unused") ArithmeticException e) {
            throw new NumberFormatException("Number is not between Integer.MIN_VALUE and Integer.MAX_VALUE");
        }
    }
    
    public static long parseJavaLong(String javaLong) throws NumberFormatException {
        BigInteger value = parseIntegerAsBigInt(javaLong);
        try {
            return value.longValueExact();
        } catch (@SuppressWarnings("unused") ArithmeticException e) {
            throw new NumberFormatException("Number is not between Integer.MIN_VALUE and Integer.MAX_VALUE");
        }
    }

    private static BigInteger parseIntegerAsBigInt(String javaLiteral) {
        Matcher intMatcher = SIGNED_INTEGER_LITERAL.matcher(javaLiteral);
        if (!intMatcher.matches()) {
            throw new NumberFormatException(javaLiteral + " is not recognized as a Java integer literal");
        }
        
        String signGroup = intMatcher.group(1);
        String prefixAndValueGroup = intMatcher.group(2);
        String radixGroup = "";
        String valueGroup = "";
        // String longGroup = "";
        List<Pattern> patterns = List.of(BINARY, OCTAL, DECIMAL, HEXADECIMAL);
        for (Pattern pattern : patterns) {
            Matcher specificMatcher = pattern.matcher(prefixAndValueGroup);
            if (specificMatcher.matches()) {
                radixGroup = specificMatcher.group(1);
                valueGroup = specificMatcher.group(2);
                // longGroup = specificMatcher.group(3);
                break;
            }
        }
        
        if (valueGroup == null) {
            throw new RuntimeException("Number both matches but doesn't contain a value (parser error)");
        }

        BigInteger sign = signGroup != null && signGroup.matches("-") ? BigInteger.ONE.negate() : BigInteger.ONE; 
        
        int radix;
        switch (radixGroup.toLowerCase()) {
        case "0b":
            radix = 2;
            break;
        case "0":
            radix = 8;
            break;
        case "":
            radix = 10;
            break;
        case "0x":
            radix = 16;
            break;
        default:
            throw new RuntimeException();
        }
 
        BigInteger value = new BigInteger(valueGroup.replaceAll("_", ""), radix).multiply(sign);
        return value;
    }
}

J'ai aussi essayé d'utiliser le code pour trouver plusieurs nombres entiers à partir d'une chaîne, mais qui ne vont pas bien. Le problème est que certains invalides littéraux tels que 0__0 j'ai été accepté comme deux littéraux avec la valeur zéro; pas exactement ce que vous voulez. Veuillez utiliser les regex pour détecter si une chaîne est en fait un entier et séparer les nombres entiers en utilisant par exemple String.split(SEPARATOR_REGEX).

C'est marrant, mon IDE Eclipse n'a accepter 0__0 comme un littéral, même si elle n'est pas officiellement compatible avec les JLS. Pas un biggy, mais bizarre aucun-le-moins.

Bien.... en termes plus simples, la base 2, 8, et 10 nombre pourrait utiliser le même modèle puisque leurs valeurs sont toutes des caractères numériques. MAIS, vous voulez probablement une expression pour chaque type. Le problème, c'est que vous n'avez pas votre intention. Je vais sur l'hypothèse que vous voulez l'expression de valider ce que la base de la valeur particulière est.

String base10Regex = "[0-9]+";
String base2Regex = "[0-1]+";
String base8Regex = "[0-7]+";
String base16Regex = "^[0-9A-F]+$";

Pour l'octal et des valeurs décimales, vous devez ajouter votre expression pour vérifier un signe optionnel caractère "^[\\+|-]?". Pour les valeurs en hexadécimal, si vous vous attendez à ce que les valeurs de commencer par "0x", je propose d'ajouter de l'expression de ces valeurs littérales.