文字列がJavaで整数を表すかどうかを確認する最良の方法は何ですか？

私は通常、次のイディオムを使用して、文字列を整数に変換できるかどうかを確認します。

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

それは私だけですか、それとも少しハックに見えますか？より良い方法は何ですか？

私の回答を（CodingWithSpikeによる以前の回答に基づいたベンチマークを使用して）確認し、私が自分の立場を逆転させ、この問題に対するJonas Klemmingの回答を受け入れた理由を確認します。この元のコードは実装が迅速で保守性が高いため、ほとんどの人が使用すると思いますが、整数以外のデータが提供されると桁違いに遅くなります。

潜在的なオーバーフローの問題に関心がない場合、この関数はを使用するよりも約20〜30倍速く実行されます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;
}

あなたはそれを持っていますが、あなたは捕まえるだけNumberFormatExceptionです。

簡単なベンチマークを行いました。複数のメソッドのポップバックを開始し、JVMが実行スタックを配置するために多くの作業を行わなければならない場合を除き、例外は実際にはそれほど高価ではありません。同じ方法にとどまるとき、彼らは悪い実行者ではありません。

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

出力：

ByException：31

ByRegex：453（注：パターンを毎回再コンパイルします）

ByJonas：16

Jonas Kのソリューションも最も堅牢であることに同意します。彼が勝つように見えます:)

人々がまだここを訪れ、ベンチマーク後にRegexに偏る可能性があるので...それで、コンパイルされたバージョンのRegexを使用して、ベンチマークの更新バージョンを提供します。以前のベンチマークとは対照的に、これはRegexソリューションが実際に一貫して優れたパフォーマンスを持っていることを示しています。

ビルザトカゲからコピーし、コンパイル済みバージョンで更新：

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

結果：

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 

Javaの標準ライブラリは本当にそのようなユーティリティ関数を見逃していますが

Apache CommonsはすべてのJavaプログラマーにとって「なくてはならない」ものだと思います

残念ながら、まだJava5に移植されていません

それは、「整数に変換できる」という意味に部分的に依存します。

「Javaでintに変換できる」という意味の場合、Jonasからの回答は適切なスタートですが、仕事を完全に終えることはできません。たとえば、999999999999999999999999999999を渡します。メソッドの最後に、独自の質問からの通常のtry / catch呼び出しを追加します。

文字ごとのチェックは、「整数ではない」というケースを効率的に拒否し、「整数であるがJavaはそれを処理できない」ケースを低速の例外ルートでキャッチします。手でこれを行うこともできますが、かなり複雑になります。

正規表現についての1つのコメント。ここで提供されるすべての例は間違っています！。正規表現を使用する場合は、パターンのコンパイルに時間がかかることを忘れないでください。この：

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

そしてこれも：

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

すべてのメソッド呼び出しでパターンをコンパイルします。正しく使用するには、次のようにします。

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

グアバのバージョンがあります：

import com.google.common.primitives.Ints;

Integer intValue = Ints.tryParse(stringValue);

文字列の解析に失敗した場合、例外をスローする代わりにnullを返します。

rally25rsの回答からコードをコピーし、非整数データのテストをいくつか追加しました。結果は、Jonas Klemmingによって投稿された方法に賛成です。私が最初に投稿したExceptionメソッドの結果は、整数データが​​ある場合はかなり良いですが、ない場合は最悪ですが、RegExソリューションの結果（多くの人が使用することになるでしょう）た一貫悪いです。コンパイルされた正規表現の例については、Felipeの回答を参照してください。これははるかに高速です。

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

結果：

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

これは短いですが、短いほど良いとは限りません（そして、danatelのコメントで指摘されているように、範囲外の整数値をキャッチしません）。

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

個人的には、実装はヘルパーメソッドにリスカーされ、正しさが長さよりも優先されるので、私はあなたが持っているようなものを使用します（マイナスExceptionではなく、基本クラスをキャッチしますNumberFormatException）。

文字列クラスのmatchesメソッドを使用できます。[0-9]は取り得るすべての値を表し、+は少なくとも1文字でなければならないことを意味し、*は0文字以上の長さであることを意味します。

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

どうですか：

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

これは、Jonas Klemmingの回答のJava 8バリエーションです。

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

テストコード：

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

テストコードの結果：

        1231231 true
    -1232312312 true
   +12313123131 true
  qwqe123123211 false
              2 true
  0000000001111 true
                false
           123- false
          ++123 false
         123-23 false
           null false
          +-123 false

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 
 }  

文字列配列に純粋な整数と文字列が含まれている場合、以下のコードが機能するはずです。あなただけの最初の文字を見る必要があります。例["4"、 "44"、 "abc"、 "77"、 "bond"]

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

Scannerクラスを使用し、hasNextInt（）を使用することもできます。これにより、フロートなどの他のタイプもテストできます。

文字列がint型に収まる整数を表すかどうかを確認する場合は、ジョナスの回答に少し変更を加えたので、Integer.MAX_VALUEより大きいまたはInteger.MIN_VALUEより小さい整数を表す文字列が返されるようになりました偽。たとえば、「3147483647」は3147483647が2147483647より大きいためfalseを返します。同様に、「-2147483649」も-2147483649が-2147483648より小さいためfalseを返します。

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

あなたはApache Utilsを試すことができます

NumberUtils.isCreatable(myText)

こちらのjavadocをご覧ください

おそらくユースケースも考慮する必要があります：

ほとんどの場合、数値が有効であると予想される場合、例外をキャッチしても、無効な数値を変換しようとしたときにパフォーマンスのオーバーヘッドが発生するだけです。一方、isInteger()メソッドを呼び出してから変換を使用Integer.parseInt()すると、常に有効な数値のパフォーマンスオーバーヘッドが発生します。文字列は、チェックと変換の2回ずつ解析されます。

これは、文字列が整数にキャストされる範囲内にあるかどうかをチェックするJonasのコードの変更です。

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

Android APIを使用している場合は、以下を使用できます。

TextUtils.isDigitsOnly(str);

別のオプション：

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

あなたがしたことはうまくいきますが、おそらくあなたはいつもそのようにチェックすべきではありません。例外のスローは「例外的な」状況（ただし、ケースに当てはまる場合があります）のために予約する必要があり、パフォーマンスの点で非常にコストがかかります。

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

これは正の整数に対してのみ機能します。

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

これは私にとってはうまくいきます。文字列がプリミティブか数値かを識別するだけです。

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

すべてのint文字をチェックするには、単純に二重否定を使用できます。

if（！searchString.matches（ "[^ 0-9] + $"））...

[^ 0-9] + $は、整数ではない文字があるかどうかを確認するため、trueの場合、テストは失敗します。それだけではなく、あなたは成功を収めます。

これは役立つかもしれません：

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

あなたがあなたの下に見ることができるように常に安全に解析するので、私は、例外に実行してゼロリスクがあると信じているintにString、その逆はしない。

そう：

1. あなたがチェックであれば、あなたの文字列が一致した文字の少なくとも一つの文字のすべてのスロット{「0」、「1」、「2」、「3」、「4」、「5」、「6」、「7」、 "8"、 "9"}。

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

2. あなたは合計あなたがスロットで上記の文字を検出したことを、すべての回。

   digits++;

3. そして最後に、整数を文字として検出した回数が、指定された文字列の長さに等しいかどうかを確認します。

   if(digits == aString.length())

そして実際には、

    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!!");
    }

結果は次のとおりです。

整数です!!

整数ではありません!!

同様に、a Stringがaであるfloatかa であるかを検証できますdoubleが、その場合は、1つだけを検出する必要があります。（ドット）文字列で、もちろん digits == (aString.length()-1)

繰り返しになりますが、ここでは解析の例外が発生するリスクはありませんが、数値を含むことがわかっている文字列（intデータ型としましょう）の解析を計画している場合は、まずデータ型に適合するかどうかを確認する必要があります。それ以外の場合は、キャストする必要があります。

私が助けてくれたことを願っています