Wie kann am besten überprüft werden, ob ein String in Java eine Ganzzahl darstellt?

Normalerweise verwende ich die folgende Redewendung, um zu überprü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 hackisch? Was ist ein besserer Weg?

In meiner Antwort (mit Benchmarks, basierend auf der früheren Antwort von CodingWithSpike ) erfahren Sie , warum ich meine Position umgekehrt und Jonas Klemmings Antwort auf dieses Problem akzeptiert habe . Ich denke, dieser ursprüngliche Code wird von den meisten Leuten verwendet, weil er schneller zu implementieren und wartbarer ist, aber um Größenordnungen langsamer, wenn nicht ganzzahlige Daten bereitgestellt werden.

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

public static boolean isInteger(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 < '0' || c > '9') {
            return false;
        }
    }
    return true;
}

Sie haben es, aber Sie sollten nur fangen NumberFormatException.

Habe einen schnellen Benchmark gemacht. Ausnahmen sind eigentlich nicht so teuer, es sei denn, Sie beginnen, mehrere Methoden zurückzusetzen, und die JVM muss viel Arbeit leisten, um den Ausführungsstapel einzurichten. Wenn sie in der gleichen Methode bleiben, sind sie keine schlechten Darsteller.

 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 :)

Da es die Möglichkeit gibt, dass die Leute immer noch hierher kommen und nach den Benchmarks gegen Regex voreingenommen sind ... Also werde ich eine aktualisierte Version des Benchmarks mit einer kompilierten Version des Regex geben. Was im Gegensatz zu den vorherigen Benchmarks zeigt, dass die Regex-Lösung tatsächlich eine konstant gute Leistung aufweist.

Von 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

org.apache.commons.lang.StringUtils.isNumeric 

obwohl Javas Standardbibliothek solche Dienstprogrammfunktionen wirklich vermisst

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

Schade, dass es noch nicht auf Java5 portiert ist

Dies hängt teilweise davon ab, was Sie unter "kann in eine Ganzzahl konvertiert werden" verstehen.

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

Bei den zeichenweisen Überprüfungen werden Fälle "überhaupt keine Ganzzahl" effizient zurückgewiesen, sodass "es ist eine Ganzzahl, aber Java kann sie nicht verarbeiten" -Fälle von der langsameren Ausnahmeroute abgefangen werden. Sie könnten dies auch von Hand tun, aber es wäre viel komplizierter.

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

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

und auch das:

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

bewirkt bei jedem Methodenaufruf eine Kompilierung des Musters. Um es richtig zu verwenden, folgen Sie:

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();
    }
}

Es gibt eine Guavenversion:

import com.google.common.primitives.Ints;

Integer intValue = Ints.tryParse(stringValue);

Es wird null zurückgegeben, anstatt eine Ausnahme auszulösen, wenn die Zeichenfolge nicht analysiert werden kann.

Ich habe den Code aus der Antwort von Rally25 kopiert und einige Tests für nicht ganzzahlige Daten hinzugefügt. Die Ergebnisse sprechen zweifellos für die von Jonas Klemming veröffentlichte Methode. Die Ergebnisse für die Ausnahmemethode, die ich ursprünglich veröffentlicht habe, sind ziemlich gut, wenn Sie ganzzahlige Daten haben, aber sie sind die schlechtesten, wenn Sie dies nicht tun, während die Ergebnisse für die RegEx-Lösung (auf die ich wetten werde, dass viele Leute sie verwenden) waren durchweg schlecht. In Felipes Antwort finden Sie 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

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 ausgeführt ):

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

Persönlich würde ich, da die Implementierung in einer Hilfsmethode weggezerrt ist und die Korrektheit die Länge übertrumpft, einfach so etwas wie das machen, was Sie haben (abzüglich des Abfangens der Basisklasse Exceptionanstatt NumberFormatException).

Sie können die Übereinstimmungsmethode der Zeichenfolgenklasse verwenden. Das [0-9] repräsentiert alle Werte, die es sein kann, das + bedeutet, dass es mindestens ein Zeichen lang sein muss, und das * bedeutet, dass es null oder mehr Zeichen lang 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

Wie wäre es mit:

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

Dies ist eine Java 8-Variante der Antwort 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

Sie überprü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 
 }  

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

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

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

Wenn Sie überprüfen möchten, ob die Zeichenfolge eine Ganzzahl darstellt, die in einen int-Typ passt, habe ich die Antwort der Jonas geringfügig geändert, sodass Zeichenfolgen, die Ganzzahlen darstellen, die größer als Integer.MAX_VALUE oder kleiner als Integer.MIN_VALUE sind, jetzt zurückgegeben werden falsch. Beispiel: "3147483647" gibt false zurück, da 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;
}

Sie können Apache-Utils ausprobieren

NumberUtils.isCreatable(myText)

Sehen Sie den Javadoc hier

Sie müssen wahrscheinlich auch den Anwendungsfall berücksichtigen:

Wenn Sie die meiste Zeit erwarten, dass Zahlen gültig sind, verursacht das Abfangen der Ausnahme nur dann einen Leistungsaufwand, wenn Sie versuchen, ungültige Zahlen zu konvertieren. Während einige Aufruf isInteger()Methode und wandeln dann unter Verwendung Integer.parseInt()wird immer für gültige Zahlen Ursache einer Leistungsaufwand - die Saiten zweimal analysiert werden, einmal durch die Prüfung und einmal durch die Umwandlung.

Dies ist eine Modifikation von Jonas 'Code, die prüft, 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;
}

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

TextUtils.isDigitsOnly(str);

Andere Option:

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

is_number = true;
try {
  Integer.parseInt(mystr)
} catch (NumberFormatException  e) {
  is_number = false;
}

Was Sie getan haben, funktioniert, aber Sie sollten es wahrscheinlich nicht immer so überprüfen. Das Auslösen von Ausnahmen sollte "außergewöhnlichen" Situationen vorbehalten sein (möglicherweise passt dies jedoch in Ihren Fall) und ist in Bezug auf die Leistung sehr kostspielig.

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

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;        
}

Das funktioniert bei mir. Einfach identifizieren, ob ein String ein Grundelement 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;
    }

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 es Zeichen gibt, die nicht ganzzahlig sind. Daher schlägt der Test fehl, wenn er wahr ist. Nur NICHT das und du wirst wahr beim Erfolg.

Finden Sie dies kann hilfreich sein:

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

Ich glaube , dass es Null - Risiko in eine Ausnahme ausgeführt wird , weil , wie Sie unten sehen Sie können immer sicher analysieren intzuString und nicht umgekehrt.

So:

1. Sie überprüfen, ob jeder Zeichenschlitz in Ihrer Zeichenfolge mit mindestens einem der Zeichen {"0", "1", "2", "3", "4", "5", "6", "7", übereinstimmt. "8", "9"} .

   if(aString.substring(j, j+1).equals(String.valueOf(i)))

2. Sie summieren alle Zeiten, die Sie in den Slots auf die oben genannten Zeichen gestoßen sind.

   digits++;

3. Und schließlich überprüfen Sie , ob die Zeiten, zu denen Sie auf Ganzzahlen als Zeichen gestoßen sind, 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 !!

Ebenso können Sie überprüfen, ob a Stringein floatoder ein ist, doubleaber in diesen Fällen müssen Sie nur auf eines stoßen . (Punkt) in der Zeichenfolge und natürlich prüfen, ob digits == (aString.length()-1)

Auch hier besteht kein Risiko, dass eine Parsing-Ausnahme auftritt. Wenn Sie jedoch eine bekannte Zeichenfolge analysieren möchten, die eine Zahl enthält (z. B. int- Datentyp), müssen Sie zunächst prüfen, ob sie in den Datentyp passt. Sonst musst du es besetzen.

ich hoffe ich habe geholfen