webentwicklung-frage-antwort-db.com.de

Wie prüfe ich am besten, ob ein String eine ganze Zahl in Java darstellt?

Normalerweise verwende ich den folgenden Ausdruck, um zu prüfen, ob ein String in eine Ganzzahl konvertiert werden kann.

public boolean isInteger( String input ) {
    try {
        Integer.parseInt( input );
        return true;
    }
    catch( Exception e ) {
        return false;
    }
}

Ist es nur ich oder scheint das ein bisschen hackig zu sein? Was ist ein besserer Weg?


Sehen Sie meine Antwort (mit Benchmarks basierend auf der früheren Antwort by CodingWithSpike ), um zu sehen, warum ich meine Position geändert habe und Jonas Klemmings Antwort zu diesem Problem akzeptiert habe. Ich denke, dass der ursprüngliche Code von den meisten Benutzern verwendet wird, da er schneller implementiert werden kann und einfacher zu warten ist. Er ist jedoch um Größenordnungen langsamer, wenn nicht ganzzahlige Daten bereitgestellt werden.

188
Bill the Lizard

Wenn Sie sich nicht mit möglichen Überlaufproblemen beschäftigen, wird diese Funktion etwa 20 bis 30 Mal schneller ausgeführt als mit Integer.parseInt().

public static boolean isInteger(String str) {
    if (str == null) {
        return false;
    }
    if (str.isEmpty()) {
        return false;
    }
    int i = 0;
    if (str.charAt(0) == '-') {
        if (length == 1) {
            return false;
        }
        i = 1;
    }
    for (; i < length; i++) {
        char c = str.charAt(i);
        if (c < '0' || c > '9') {
            return false;
        }
    }
    return true;
}
152
Jonas Klemming

Sie haben es, aber Sie sollten nur NumberFormatException fangen.

56
Ovidiu Pacurar

Hat einen schnellen Benchmark gemacht. Ausnahmen sind nicht wirklich teuer, es sei denn, Sie beginnen, mehrere Methoden zurückzublättern, und die JVM muss eine Menge Arbeit verrichten, um den Ausführungsstack zu installieren. Wenn sie auf dieselbe Weise bleiben, sind sie keine schlechten Künstler.

 public void RunTests()
 {
     String str = "1234567890";

     long startTime = System.currentTimeMillis();
     for(int i = 0; i < 100000; i++)
         IsInt_ByException(str);
     long endTime = System.currentTimeMillis();
     System.out.print("ByException: ");
     System.out.println(endTime - startTime);

     startTime = System.currentTimeMillis();
     for(int i = 0; i < 100000; i++)
         IsInt_ByRegex(str);
     endTime = System.currentTimeMillis();
     System.out.print("ByRegex: ");
     System.out.println(endTime - startTime);

     startTime = System.currentTimeMillis();
     for(int i = 0; i < 100000; i++)
         IsInt_ByJonas(str);
     endTime = System.currentTimeMillis();
     System.out.print("ByJonas: ");
     System.out.println(endTime - startTime);
 }

 private boolean IsInt_ByException(String str)
 {
     try
     {
         Integer.parseInt(str);
         return true;
     }
     catch(NumberFormatException nfe)
     {
         return false;
     }
 }

 private boolean IsInt_ByRegex(String str)
 {
     return str.matches("^-?\\d+$");
 }

 public boolean IsInt_ByJonas(String str)
 {
     if (str == null) {
             return false;
     }
     int length = str.length();
     if (length == 0) {
             return false;
     }
     int i = 0;
     if (str.charAt(0) == '-') {
             if (length == 1) {
                     return false;
             }
             i = 1;
     }
     for (; i < length; i++) {
             char c = str.charAt(i);
             if (c <= '/' || c >= ':') {
                     return false;
             }
     }
     return true;
 }

Ausgabe:

ByException: 31

ByRegex: 453 (Hinweis: Das Muster wird jedes Mal neu kompiliert.)

ByJonas: 16

Ich stimme zu, dass die Lösung von Jonas K auch die robusteste ist. Sieht aus wie er gewinnt :)

35
CodingWithSpike

Da gibt es die Möglichkeit, dass die Leute noch hierher kommen und nach den Benchmarks gegen Regex voreingenommen sind ... Ich werde also eine aktualisierte Version des Benchmarks mit einer kompilierten Version der Regex geben. Im Gegensatz zu den vorangegangenen Benchmarks zeigt dieser hier, dass die Regex-Lösung eine konstant gute Leistung aufweist.

Aus Bill the Lizard kopiert und mit der kompilierten Version aktualisiert:

private final Pattern pattern = Pattern.compile("^-?\\d+$");

public void runTests() {
    String big_int = "1234567890";
    String non_int = "1234XY7890";

    long startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByException(big_int);
    long endTime = System.currentTimeMillis();
    System.out.print("ByException - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByException(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByException - non-integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByRegex(big_int);
    endTime = System.currentTimeMillis();
    System.out.print("\nByRegex - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByRegex(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByRegex - non-integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++)
            IsInt_ByCompiledRegex(big_int);
    endTime = System.currentTimeMillis();
    System.out.print("\nByCompiledRegex - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++)
            IsInt_ByCompiledRegex(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByCompiledRegex - non-integer data: ");
    System.out.println(endTime - startTime);


    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByJonas(big_int);
    endTime = System.currentTimeMillis();
    System.out.print("\nByJonas - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
            IsInt_ByJonas(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByJonas - non-integer data: ");
    System.out.println(endTime - startTime);
}

private boolean IsInt_ByException(String str)
{
    try
    {
        Integer.parseInt(str);
        return true;
    }
    catch(NumberFormatException nfe)
    {
        return false;
    }
}

private boolean IsInt_ByRegex(String str)
{
    return str.matches("^-?\\d+$");
}

private boolean IsInt_ByCompiledRegex(String str) {
    return pattern.matcher(str).find();
}

public boolean IsInt_ByJonas(String str)
{
    if (str == null) {
            return false;
    }
    int length = str.length();
    if (length == 0) {
            return false;
    }
    int i = 0;
    if (str.charAt(0) == '-') {
            if (length == 1) {
                    return false;
            }
            i = 1;
    }
    for (; i < length; i++) {
            char c = str.charAt(i);
            if (c <= '/' || c >= ':') {
                    return false;
            }
    }
    return true;
}

Ergebnisse:

ByException - integer data: 45
ByException - non-integer data: 465

ByRegex - integer data: 272
ByRegex - non-integer data: 131

ByCompiledRegex - integer data: 45
ByCompiledRegex - non-integer data: 26

ByJonas - integer data: 8
ByJonas - non-integer data: 2
34
Felipe
org.Apache.commons.lang.StringUtils.isNumeric 

obwohl Javas Standard-Bibliothek solche Dienstfunktionen wirklich vermisst

Ich denke, dass Apache Commons für jeden Java-Programmierer ein "Muss" ist

schade, dass es noch nicht auf Java5 portiert ist

28
Łukasz Bownik

Es hängt zum Teil davon ab, was Sie mit "kann in eine ganze Zahl umgewandelt werden" meinen.

Wenn Sie meinen, dass "in Java in ein Int konvertiert werden kann", dann ist die Antwort von Jonas ein guter Anfang, beendet aber den Job nicht ganz. Es würde zum Beispiel 9999999999999999999999999999 übergeben. Ich würde den normalen Try/Catch-Aufruf von Ihrer eigenen Frage am Ende der Methode hinzufügen.

Die zeichenweisen Überprüfungen lehnen Fälle von "überhaupt keine Ganzzahl" ab und lassen Fälle von "es ist eine Ganzzahl, aber Java kann nicht damit umgehen", die von der langsameren Ausnahmeroute abgefangen werden. Sie könnten tun dieses Stück auch von Hand, aber es wäre ein viel komplizierter.

22
Jon Skeet

Nur ein Kommentar zu Regex. Jedes hier angegebene Beispiel ist falsch! Wenn Sie regexp verwenden möchten, vergessen Sie nicht, dass das Kompilieren des Patterns viel Zeit in Anspruch nimmt. Diese:

str.matches("^-?\\d+$")

und auch dies:

Pattern.matches("-?\\d+", input);

bewirkt das Kompilieren des Musters bei jedem Methodenaufruf. Um es richtig anzuwenden, folgen Sie bitte:

import Java.util.regex.Pattern;

/**
 * @author Rastislav Komara
 */
public class NaturalNumberChecker {
    public static final Pattern PATTERN = Pattern.compile("^\\d+$");

    boolean isNaturalNumber(CharSequence input) {
        return input != null && PATTERN.matcher(input).matches();
    }
}
14

Ich habe den Code aus der Antwort von rally25rs kopiert und einige Tests für nicht ganzzahlige Daten hinzugefügt. Die Ergebnisse sprechen eindeutig für die Methode von Jonas Klemming. Die Ergebnisse für die Exceptions-Methode, die ich ursprünglich gepostet habe, sind ziemlich gut, wenn Sie über ganzzahlige Daten verfügen, aber die schlechtesten, wenn Sie dies nicht tun, während die Ergebnisse für die RegEx-Lösung (auf die ich wette, viele Leute setzen). waren konsequent schlecht. Siehe Felipes Antwort für ein kompiliertes Regex-Beispiel, das viel schneller ist.

public void runTests()
{
    String big_int = "1234567890";
    String non_int = "1234XY7890";

    long startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByException(big_int);
    long endTime = System.currentTimeMillis();
    System.out.print("ByException - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByException(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByException - non-integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByRegex(big_int);
    endTime = System.currentTimeMillis();
    System.out.print("\nByRegex - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByRegex(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByRegex - non-integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByJonas(big_int);
    endTime = System.currentTimeMillis();
    System.out.print("\nByJonas - integer data: ");
    System.out.println(endTime - startTime);

    startTime = System.currentTimeMillis();
    for(int i = 0; i < 100000; i++)
        IsInt_ByJonas(non_int);
    endTime = System.currentTimeMillis();
    System.out.print("ByJonas - non-integer data: ");
    System.out.println(endTime - startTime);
}

private boolean IsInt_ByException(String str)
{
    try
    {
        Integer.parseInt(str);
        return true;
    }
    catch(NumberFormatException nfe)
    {
        return false;
    }
}

private boolean IsInt_ByRegex(String str)
{
    return str.matches("^-?\\d+$");
}

public boolean IsInt_ByJonas(String str)
{
    if (str == null) {
            return false;
    }
    int length = str.length();
    if (length == 0) {
            return false;
    }
    int i = 0;
    if (str.charAt(0) == '-') {
            if (length == 1) {
                    return false;
            }
            i = 1;
    }
    for (; i < length; i++) {
            char c = str.charAt(i);
            if (c <= '/' || c >= ':') {
                    return false;
            }
    }
    return true;
}

Ergebnisse:

ByException - integer data: 47
ByException - non-integer data: 547

ByRegex - integer data: 390
ByRegex - non-integer data: 313

ByJonas - integer data: 0
ByJonas - non-integer data: 16
12
Bill the Lizard

Es gibt eine Guavenversion:

import com.google.common.primitives.Ints;

Integer intValue = Ints.tryParse(stringValue);

Wenn keine Zeichenfolge analysiert werden kann, wird null zurückgegeben, anstatt eine Ausnahme auszulösen.

8
abalcerek

Dies ist kürzer, aber kürzer ist nicht unbedingt besser (und es werden keine ganzzahligen Werte erfasst, die außerhalb des Bereichs liegen, wie in Danatels Kommentar ):

input.matches("^-?\\d+$");

Ich persönlich würde, da die Implementierung in einer Hilfsmethode weggezaubert wird und die Korrektheit die Länge übertrumpft, einfach etwas mit dem machen, was Sie haben (minus dem Einfangen der Exception-Basisklasse statt NumberFormatException).

6
Jonny Buchanan

Sie können die Matches-Methode der String-Klasse verwenden. Das [0-9] stellt alle Werte dar, die es sein kann, das Plus bedeutet, dass es mindestens ein Zeichen lang sein muss, und das * bedeutet, dass es null oder mehr Zeichen sein kann. 

boolean isNumeric = yourString.matches("[0-9]+"); // 1 or more characters long, numbers only
boolean isNumeric = yourString.matches("[0-9]*"); // 0 or more characters long, numbers only
6
Kaitie

Dies ist eine Java 8-Variante von Jonas Klemming:

public static boolean isInteger(String str) {
    return str != null && str.length() > 0 &&
         IntStream.range(0, str.length()).allMatch(i -> i == 0 && (str.charAt(i) == '-' || str.charAt(i) == '+')
                  || Character.isDigit(str.charAt(i)));
}

Testcode:

public static void main(String[] args) throws NoSuchAlgorithmException, UnsupportedEncodingException {
    Arrays.asList("1231231", "-1232312312", "+12313123131", "qwqe123123211", "2", "0000000001111", "", "123-", "++123",
            "123-23", null, "+-123").forEach(s -> {
        System.out.printf("%15s %s%n", s, isInteger(s));
    });
}

Ergebnisse des Testcodes:

        1231231 true
    -1232312312 true
   +12313123131 true
  qwqe123123211 false
              2 true
  0000000001111 true
                false
           123- false
          ++123 false
         123-23 false
           null false
          +-123 false
4
gil.fernandes

Sie können auch die Klasse Scanner und hasNextInt () - verwenden. Auf diese Weise können Sie auch nach anderen Typen wie Floats usw. suchen.

3

Wenn Ihr String-Array reine Ganzzahlen und Strings enthält, sollte der folgende Code funktionieren. Sie müssen nur das erste Zeichen betrachten. [4, 44, abc ", 77," bond "]

if (Character.isDigit(string.charAt(0))) {
    //Do something with int
}
3
realPK

Sie können Apache-Utils ausprobieren

NumberUtils.isNumber( myText)

Sehen Sie den Javadoc hier

2
borjab

Sie prüfen nur NumberFormatException : -

 String value="123";
 try  
 {  
    int s=Integer.parseInt(any_int_val);
    // do something when integer values comes 
 }  
 catch(NumberFormatException nfe)  
 {  
          // do something when string values comes 
 }  
2
duggu

Wahrscheinlich müssen Sie den Anwendungsfall auch im Konto berücksichtigen:

Wenn Sie meist davon ausgehen, dass Zahlen gültig sind, führt das Erfassen der Ausnahme nur zu einem Performance-Overhead, wenn Sie versuchen, ungültige Zahlen zu konvertieren. Während das Aufrufen einer isInteger()-Methode und die Konvertierung mit Integer.parseInt()always einen Performance-Overhead für gültige Zahlen verursachen, werden die Zeichenfolgen zweimal analysiert, einmal durch die Prüfung und einmal durch die Konvertierung.

1
mobra66

Wie wäre es mit:

return Pattern.matches("-?\\d+", input);
1
Kristian

Wenn Sie die Android-API verwenden, können Sie Folgendes verwenden:

TextUtils.isDigitsOnly(str);
1
timxyz

Andere Option:

private boolean isNumber(String s) {
    boolean isNumber = true;
    for (char c : s.toCharArray()) {
        isNumber = isNumber && Character.isDigit(c);
    }
    return isNumber;
}
1
Gabriel Kaffka

Wenn Sie überprüfen möchten, ob die Zeichenfolge eine Ganzzahl darstellt, die in einen Int-Typ passt, habe ich die Antwort der Jonas ein wenig geändert, sodass jetzt Zeichenfolgen zurückgegeben werden, die ganze Zahlen darstellen, die größer als Integer.MAX_VALUE oder kleiner als Integer.MIN_VALUE sind falsch. Beispiel: "3147483647" gibt "false" zurück, weil 3147483647 größer als 2147483647 ist, und "-2147483649" gibt ebenfalls "false" zurück, da -2147483649 kleiner als -2147483648 ist.

public static boolean isInt(String s) {
  if(s == null) {
    return false;
  }
  s = s.trim(); //Don't get tricked by whitespaces.
  int len = s.length();
  if(len == 0) {
    return false;
  }
  //The bottom limit of an int is -2147483648 which is 11 chars long.
  //[note that the upper limit (2147483647) is only 10 chars long]
  //Thus any string with more than 11 chars, even if represents a valid integer, 
  //it won't fit in an int.
  if(len > 11) {
    return false;
  }
  char c = s.charAt(0);
  int i = 0;
  //I don't mind the plus sign, so "+13" will return true.
  if(c == '-' || c == '+') {
    //A single "+" or "-" is not a valid integer.
    if(len == 1) {
      return false;
    }
    i = 1;
  }
  //Check if all chars are digits
  for(; i < len; i++) {
    c = s.charAt(i);
    if(c < '0' || c > '9') {
      return false;
    }
  }
  //If we reached this point then we know for sure that the string has at
  //most 11 chars and that they're all digits (the first one might be a '+'
  // or '-' thought).
  //Now we just need to check, for 10 and 11 chars long strings, if the numbers
  //represented by the them don't surpass the limits.
  c = s.charAt(0);
  char l;
  String limit;
  if(len == 10 && c != '-' && c != '+') {
    limit = "2147483647";
    //Now we are going to compare each char of the string with the char in
    //the limit string that has the same index, so if the string is "ABC" and
    //the limit string is "DEF" then we are gonna compare A to D, B to E and so on.
    //c is the current string's char and l is the corresponding limit's char
    //Note that the loop only continues if c == l. Now imagine that our string
    //is "2150000000", 2 == 2 (next), 1 == 1 (next), 5 > 4 as you can see,
    //because 5 > 4 we can guarantee that the string will represent a bigger integer.
    //Similarly, if our string was "2139999999", when we find out that 3 < 4,
    //we can also guarantee that the integer represented will fit in an int.
    for(i = 0; i < len; i++) {
      c = s.charAt(i);
      l = limit.charAt(i);
      if(c > l) {
        return false;
      }
      if(c < l) {
        return true;
      }
    }
  }
  c = s.charAt(0);
  if(len == 11) {
    //If the first char is neither '+' nor '-' then 11 digits represent a 
    //bigger integer than 2147483647 (10 digits).
    if(c != '+' && c != '-') {
      return false;
    }
    limit = (c == '-') ? "-2147483648" : "+2147483647";
    //Here we're applying the same logic that we applied in the previous case
    //ignoring the first char.
    for(i = 1; i < len; i++) {
      c = s.charAt(i);
      l = limit.charAt(i);
      if(c > l) {
        return false;
      }
      if(c < l) {
        return true;
      }
    }
  }
  //The string passed all tests, so it must represent a number that fits
  //in an int...
  return true;
}
1
user8513960

Dies ist eine Modifikation des Jonas '- Codes, mit der geprüft wird, ob sich die Zeichenfolge innerhalb des Bereichs befindet, der in eine Ganzzahl umgewandelt werden soll. 

public static boolean isInteger(String str) {
    if (str == null) {
        return false;
    }
    int length = str.length();
    int i = 0;

    // set the length and value for highest positive int or lowest negative int
    int maxlength = 10;
    String maxnum = String.valueOf(Integer.MAX_VALUE);
    if (str.charAt(0) == '-') { 
        maxlength = 11;
        i = 1;
        maxnum = String.valueOf(Integer.MIN_VALUE);
    }  

    // verify digit length does not exceed int range
    if (length > maxlength) { 
        return false; 
    }

    // verify that all characters are numbers
    if (maxlength == 11 && length == 1) {
        return false;
    }
    for (int num = i; num < length; num++) {
        char c = str.charAt(num);
        if (c < '0' || c > '9') {
            return false;
        }
    }

    // verify that number value is within int range
    if (length == maxlength) {
        for (; i < length; i++) {
            if (str.charAt(i) < maxnum.charAt(i)) {
                return true;
            }
            else if (str.charAt(i) > maxnum.charAt(i)) {
                return false;
            }
        }
    }
    return true;
}
1
Wayne

Ich habe hier viele Antworten gesehen, aber die meisten können feststellen, ob der String numerisch ist, aber sie prüfen nicht, ob die Zahl im Integer-Bereich liegt ...

Deshalb verstehe ich so etwas:

public static boolean isInteger(String str) {
    if (str == null || str.isEmpty()) {
        return false;
    }
    try {
        long value = Long.valueOf(str);
        return value >= -2147483648 && value <= 2147483647;
    } catch (Exception ex) {
        return false;
    }
}
0
Ellrohir
public class HelloWorld{

    static boolean validateIP(String s){
        String[] value = s.split("\\.");
        if(value.length!=4) return false;
        int[] v = new int[4];
        for(int i=0;i<4;i++){
            for(int j=0;j<value[i].length();j++){
                if(!Character.isDigit(value[i].charAt(j))) 
                 return false;
            }
            v[i]=Integer.parseInt(value[i]);
            if(!(v[i]>=0 && v[i]<=255)) return false;
        }
        return true;
    }

    public static void main(String[] argv){
        String test = "12.23.8.9j";
        if(validateIP(test)){
            System.out.println(""+test);
        }
    }
}
0
salaheddine

Das funktioniert für mich. Einfach feststellen, ob ein String ein Primitiv oder eine Zahl ist.

private boolean isPrimitive(String value){
        boolean status=true;
        if(value.length()<1)
            return false;
        for(int i = 0;i<value.length();i++){
            char c=value.charAt(i);
            if(Character.isDigit(c) || c=='.'){

            }else{
                status=false;
                break;
            }
        }
        return status;
    }

Wenn Erklärungen wichtiger sind als Leistung

Ich bemerkte viele Diskussionen darüber, wie effizient bestimmte Lösungen sind, aber keine über , warum eine Zeichenfolge keine ganze Zahl ist. Außerdem schienen alle davon auszugehen, dass die Zahl "2.00" nicht gleich "2" ist. Mathematisch und menschlich gesehen sind sie gleich (auch wenn die Informatik dies aus gutem Grund nicht behauptet). Aus diesem Grund sind die oben genannten "Integer.parseInt" -Lösungen schwach (abhängig von Ihren Anforderungen).

Um Software intelligenter und menschlicher zu machen, müssen wir auf jeden Fall Software entwickeln, die so denkt wie wir und erklärt , warum etwas fehlgeschlagen ist. In diesem Fall:

public static boolean isIntegerFromDecimalString(String possibleInteger) {
possibleInteger = possibleInteger.trim();
try {
    // Integer parsing works great for "regular" integers like 42 or 13.
    int num = Integer.parseInt(possibleInteger);
    System.out.println("The possibleInteger="+possibleInteger+" is a pure integer.");
    return true;
} catch (NumberFormatException e) {
    if (possibleInteger.equals(".")) {
        System.out.println("The possibleInteger=" + possibleInteger + " is NOT an integer because it is only a decimal point.");
        return false;
    } else if (possibleInteger.startsWith(".") && possibleInteger.matches("\\.[0-9]*")) {
        if (possibleInteger.matches("\\.[0]*")) {
            System.out.println("The possibleInteger=" + possibleInteger + " is an integer because it starts with a decimal point and afterwards is all zeros.");
            return true;
        } else {
            System.out.println("The possibleInteger=" + possibleInteger + " is NOT an integer because it starts with a decimal point and afterwards is not all zeros.");
            return false;
        }
    } else if (possibleInteger.endsWith(".")  && possibleInteger.matches("[0-9]*\\.")) {
        System.out.println("The possibleInteger="+possibleInteger+" is an impure integer (ends with decimal point).");
        return true;
    } else if (possibleInteger.contains(".")) {
        String[] partsOfPossibleInteger = possibleInteger.split("\\.");
        if (partsOfPossibleInteger.length == 2) {
            //System.out.println("The possibleInteger=" + possibleInteger + " is split into '" + partsOfPossibleInteger[0] + "' and '" + partsOfPossibleInteger[1] + "'.");
            if (partsOfPossibleInteger[0].matches("[0-9]*")) {
                if (partsOfPossibleInteger[1].matches("[0]*")) {
                    System.out.println("The possibleInteger="+possibleInteger+" is an impure integer (ends with all zeros after the decimal point).");
                    return true;
                } else if (partsOfPossibleInteger[1].matches("[0-9]*")) {
                    System.out.println("The possibleInteger=" + possibleInteger + " is NOT an integer because it the numbers after the decimal point (" + 
                                partsOfPossibleInteger[1] + ") are not all zeros.");
                    return false;
                } else {
                    System.out.println("The possibleInteger=" + possibleInteger + " is NOT an integer because it the 'numbers' after the decimal point (" + 
                            partsOfPossibleInteger[1] + ") are not all numeric digits.");
                    return false;
                }
            } else {
                System.out.println("The possibleInteger=" + possibleInteger + " is NOT an integer because it the 'number' before the decimal point (" + 
                        partsOfPossibleInteger[0] + ") is not a number.");
                return false;
            }
        } else {
            System.out.println("The possibleInteger="+possibleInteger+" is NOT an integer because it has a strange number of decimal-period separated parts (" +
                    partsOfPossibleInteger.length + ").");
            return false;
        }
    } // else
    System.out.println("The possibleInteger='"+possibleInteger+"' is NOT an integer, even though it has no decimal point.");
    return false;
}
}

Testcode:

String[] testData = {"0", "0.", "0.0", ".000", "2", "2.", "2.0", "2.0000", "3.14159", ".0001", ".", "$4.0", "3E24", "6.0221409e+23"};
int i = 0;
for (String possibleInteger : testData ) {
    System.out.println("");
    System.out.println(i + ". possibleInteger='" + possibleInteger +"' isIntegerFromDecimalString=" + isIntegerFromDecimalString(possibleInteger));
    i++;
}
0
Tihamer
is_number = true;
try {
  Integer.parseInt(mystr)
} catch (NumberFormatException  e) {
  is_number = false;
}
0
Ricardo Acras

Was Sie getan haben, funktioniert, aber Sie sollten es wahrscheinlich nicht immer überprüfen. Ausnahmen für das Werfen sollten für "Ausnahmesituationen" reserviert sein (die vielleicht in Ihren Fall passen) und sind sehr kostspielig.

0
lucas

Ich mag keine Methode mit Regex, weil Regex keine Bereiche prüfen kann (Integer.MIN_VALUE, Integer.MAX_VALUE).

Wenn Sie in den meisten Fällen einen int-Wert erwarten und int nicht ungewöhnlich ist, empfehle ich eine Version mit Integer.valueOf oder Integer.parseInt mit NumberFormatException catching. Vorteil dieses Ansatzes - Ihr Code ist gut lesbar:

public static boolean isInt(String s) {
  try {
    Integer.parseInt(s);
    return true;
  } catch (NumberFormatException nfe) {
    return false;
  }
}

Wenn Sie überprüfen müssen, ob String eine Ganzzahl ist, und sich um die Leistung kümmern möchten, ist es am besten, Java jdk-Implementierung von Integer.parseInt zu verwenden, jedoch nur geringfügig zu ändern (Ersetzen von throw durch return false):

Diese Funktion hat eine gute Leistung und garantiert das richtige Ergebnis:

   public static boolean isInt(String s) {
    int radix = 10;

    if (s == null) {
        return false;
    }

    if (radix < Character.MIN_RADIX) {
        return false;
    }

    if (radix > Character.MAX_RADIX) {
        return false;
    }

    int result = 0;
    boolean negative = false;
    int i = 0, len = s.length();
    int limit = -Integer.MAX_VALUE;
    int multmin;
    int digit;

    if (len > 0) {
        char firstChar = s.charAt(0);
        if (firstChar < '0') { // Possible leading "+" or "-"
            if (firstChar == '-') {
                negative = true;
                limit = Integer.MIN_VALUE;
            } else if (firstChar != '+')
                return false;

            if (len == 1) // Cannot have lone "+" or "-"
                return false;
            i++;
        }
        multmin = limit / radix;
        while (i < len) {
            // Accumulating negatively avoids surprises near MAX_VALUE
            digit = Character.digit(s.charAt(i++), radix);
            if (digit < 0) {
                return false;
            }
            if (result < multmin) {
                return false;
            }
            result *= radix;
            if (result < limit + digit) {
                return false;
            }
            result -= digit;
        }
    } else {
        return false;
    }
    return true;
}
0
Balconsky

Um nach allen Int-Zeichen zu suchen, können Sie einfach ein doppeltes Negativ verwenden. 

if (! searchString.matches ("[^ 0-9] + $")) ...

[^ 0-9] + $ prüft, ob Zeichen vorhanden sind, die nicht ganzzahlig sind. Der Test schlägt fehl, wenn er wahr ist. Nur NICHT das und Sie werden auf Erfolg wahr.

0
Roger F. Gay
Number number;
try {
    number = NumberFormat.getInstance().parse("123");
} catch (ParseException e) {
    //not a number - do recovery.
    e.printStackTrace();
}
//use number
0
Ran Biron

Ich glaube, es besteht kein Risiko für eine Ausnahme, denn wie Sie unten sehen können, analysieren Sie int immer sicher in String und nicht umgekehrt. 

So:

  1. Sie check, wenn jeder Platz in Ihrer Zeichenfolge mindestens übereinstimmtEine der Zeichen {"0", "1", "2", "3", "4") "5", "6", "7", "8", "9"}

    if(aString.substring(j, j+1).equals(String.valueOf(i)))
    
  2. Sie Summe zu allen Zeiten, zu denen Sie in den Steckplätzen die oben genannten Zeichen gefunden haben.

    digits++;
    
  3. Und schließlich check, wenn die Zeiten, die Sie als -Zeichen angetroffen haben, der Länge der angegebenen Zeichenfolge entsprechen. 

    if(digits == aString.length())
    

Und in der Praxis haben wir:

    String aString = "1234224245";
    int digits = 0;//count how many digits you encountered
    for(int j=0;j<aString.length();j++){
        for(int i=0;i<=9;i++){
            if(aString.substring(j, j+1).equals(String.valueOf(i)))
                    digits++;
        }
    }
    if(digits == aString.length()){
        System.out.println("It's an integer!!");
        }
    else{
        System.out.println("It's not an integer!!");
    }

    String anotherString = "1234f22a4245";
    int anotherDigits = 0;//count how many digits you encountered
    for(int j=0;j<anotherString.length();j++){
        for(int i=0;i<=9;i++){
            if(anotherString.substring(j, j+1).equals(String.valueOf(i)))
                    anotherDigits++;
        }
    }
    if(anotherDigits == anotherString.length()){
        System.out.println("It's an integer!!");
        }
    else{
        System.out.println("It's not an integer!!");
    }

Und die Ergebnisse sind:

Es ist eine ganze Zahl !!

Es ist keine ganze Zahl !!

In ähnlicher Weise können Sie überprüfen, ob ein String ein float oder ein double ist. In diesen Fällen müssen Sie jedoch nur einen. (Punkt) im String erkennen und natürlich prüfen, ob digits == (aString.length()-1)

Auch hier besteht kein Risiko, dass eine Parsing-Ausnahme auftritt. Wenn Sie jedoch planen, eine Zeichenfolge zu analysieren, von der bekannt ist, dass sie eine Zahl enthält (sagen wir int Datentyp), müssen Sie zuerst prüfen, ob sie in den Datentyp. Ansonsten musst du es werfen.

Ich hoffe ich habe geholfen

0
mark_infinite

Finden Sie das kann hilfreich sein:

public static boolean isInteger(String self) {
    try {
        Integer.valueOf(self.trim());
        return true;
    } catch (NumberFormatException nfe) {
        return false;
    }
}
0
shellbye

Dies würde nur für positive ganze Zahlen funktionieren.

public static boolean isInt(String str) {
    if (str != null && str.length() != 0) {
        for (int i = 0; i < str.length(); i++) {
            if (!Character.isDigit(str.charAt(i))) return false;
        }
    }
    return true;        
}
0
callejero