Bepaal of een tekenreeks een geheel getal is in Java

Ik probeer te bepalen of een bepaald item in een array van strings een geheel getal is of niet.

Ik ben .split(" ")en bezig met een infix-expressie in de vorm van Stringen probeer vervolgens de resulterende array in twee arrays te splitsen; één voor gehele getallen, één voor operators, terwijl haakjes en andere diverse items worden weggegooid. Wat zou de beste manier zijn om dit te bereiken?

Ik dacht dat ik misschien een Integer.isInteger(String arg)methode of zoiets zou kunnen vinden, maar niet zo’n geluk.

Antwoord 1, autoriteit 100%

De meest naïeve manier zou zijn om de String te herhalen en ervoor te zorgen dat alle elementen geldige cijfers zijn voor de gegeven radix. Dit is ongeveer net zo efficiënt als mogelijk is, omdat je elk element minstens één keer moet bekijken. Ik veronderstel dat we het kunnen optimaliseren op basis van de radix, maar in alle opzichten is dit zo goed als je kunt verwachten.

public static boolean isInteger(String s) {
    return isInteger(s,10);
}
public static boolean isInteger(String s, int radix) {
    if(s.isEmpty()) return false;
    for(int i = 0; i < s.length(); i++) {
        if(i == 0 && s.charAt(i) == '-') {
            if(s.length() == 1) return false;
            else continue;
        }
        if(Character.digit(s.charAt(i),radix) < 0) return false;
    }
    return true;
}

U kunt ook vertrouwen op de Java-bibliotheek om dit te hebben. Het is niet gebaseerd op uitzonderingen en zal zowat elke foutconditie opvangen die u maar kunt bedenken. Het zal iets duurder zijn (je moet een Scanner-object maken, wat je in een kritisch strakke lus niet wilt doen. Maar het zou over het algemeen niet te veel duurder moeten zijn, dus voor de dagelijkse operaties zou het redelijk betrouwbaar moeten zijn.

public static boolean isInteger(String s, int radix) {
    Scanner sc = new Scanner(s.trim());
    if(!sc.hasNextInt(radix)) return false;
    // we know it starts with a valid int, now make sure
    // there's nothing left!
    sc.nextInt(radix);
    return !sc.hasNext();
}

Als praktische tips niet belangrijk voor je zijn, of als je de man wilt trollen die je coderecensies doet, probeer dit dan voor de maat:

public static boolean isInteger(String s) {
    try { 
        Integer.parseInt(s); 
    } catch(NumberFormatException e) { 
        return false; 
    } catch(NullPointerException e) {
        return false;
    }
    // only got here if we didn't return false
    return true;
}

Antwoord 2, autoriteit 78%

Het is beter om reguliere expressies te gebruiken.

str.matches("-?\\d+");
-?     --> negative sign, could have none or one
\\d+   --> one or more digits

Het is niet goed om hier NumberFormatExceptionte gebruiken als je in plaats daarvan if-statementkunt gebruiken.

Als u geen voorloopnullen wilt, kunt u de reguliere expressie als volgt gebruiken:

str.matches("-?(0|[1-9]\\d*)");

Antwoord 3, autoriteit 43%

Of je kunt een beetje hulp inroepen van onze goede vrienden bij Apache Commons: StringUtils.isNumeric(String str)

Antwoord 4, autoriteit 22%

Of gewoon

mystring.matches("\\d+")

hoewel het true zou retourneren voor getallen groter dan een int

Antwoord 5, autoriteit 20%

U wilt de Integer.parseInt(String)methode.

try{
  int num = Integer.parseInt(str);
  // is an integer!
} catch (NumberFormatException e) {
  // not an integer!
}

Antwoord 6, autoriteit 4%

Als alternatieve benadering om te proberen de string te ontleden en NumberFormatExceptionte vangen, zou je een regex kunnen gebruiken; bijv.

if (Pattern.compile("-?[0-9]+").matches(str)) {
    // its an integer
}

Dit gaat waarschijnlijk sneller, vooral als u de regex vooraf compileert en hergebruikt.

Het probleem met deze aanpak is echter dat Integer.parseInt(str)ook zal mislukken als streen getal vertegenwoordigt dat buiten het bereik van de wettelijke intwaarden. Hoewel het mogelijk is om een ​​regex te maken die alleen overeenkomt met gehele getallen in het bereik Integer.MIN_INTtot Integer.MAX_INT, is het geen fraai gezicht. (En ik ga het niet proberen…)

Aan de andere kant … het kan acceptabel zijn om “geen geheel getal” en “geheel getal te groot” afzonderlijk te behandelen voor validatiedoeleinden.

Antwoord 7, autoriteit 2%

U kunt Integer.parseInt(str)gebruiken en de NumberFormatExceptionvangen als de tekenreeks geen geldig geheel getal is, op de volgende manier (zoals aangegeven door alle antwoorden ):

static boolean isInt(String s)
{
 try
  { int i = Integer.parseInt(s); return true; }
 catch(NumberFormatException er)
  { return false; }
}

Houd er echter rekening mee dat als het geëvalueerde gehele getal overloopt, dezelfde uitzondering wordt gegenereerd. Je doel was om erachter te komen of het een geldig geheel getal was. Het is dus veiliger om uw eigen methode te maken om de geldigheid te controleren:

static boolean isInt(String s)  // assuming integer is in decimal number system
{
 for(int a=0;a<s.length();a++)
 {
    if(a==0 && s.charAt(a) == '-') continue;
    if( !Character.isDigit(s.charAt(a)) ) return false;
 }
 return true;
}

Antwoord 8

U kunt Integer.parseInt()of Integer.valueOf()gebruiken om het gehele getal uit de tekenreeks te halen en de uitzondering te vangen als het geen parseerbare int is . Je wilt er zeker van zijn dat je de NumberFormatExceptionopvangt die het kan gooien.

Het kan handig zijn om op te merken dat valueOf() een Integer-object retourneert, niet de primitieve int.

Antwoord 9

public boolean isInt(String str){
    return (str.lastIndexOf("-") == 0 && !str.equals("-0")) ? str.substring(1).matches(
            "\\d+") : str.matches("\\d+");
}