Какой лучший способ проверить, представляет ли String целое число в Java?

Question

Обычно я использую следующую идиому, чтобы проверить, можно ли преобразовать строку в целое число.

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

Это только я, или это кажется немного хакерским? Какой способ лучше?

---

См. Мой ответ (с оценками, основанными на предыдущем ответе от CodingWithSpike ), чтобы увидеть, почему я изменил свою позицию и принял ответ Джонаса Клемминга к этой проблеме. Я думаю, что этот оригинальный код будет использоваться большинством людей, потому что он быстрее реализуется и более удобен в обслуживании, но он на несколько порядков медленнее, когда предоставляются нецелые данные.

Answer 1

Если вас не беспокоят потенциальные проблемы переполнения, эта функция будет работать примерно в 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;
}

Answer 2

У вас есть, но вы должны только поймать NumberFormatException.

Answer 3

Сделал быстрый тест. Исключения на самом деле не такие уж дорогие, если только вы не начнете использовать несколько методов, а 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

Я согласен, что решение Джонаса К. также является наиболее надежным. Похоже, он выиграл:)

Answer 4

Так как есть вероятность, что люди все еще посещают здесь и будут настроены против Regex после тестов ... Так что я собираюсь дать обновленную версию теста, скомпилированной версией Regex. В отличие от предыдущих тестов, это показывает, что решение Regex на самом деле стабильно хорошо работает.

Скопировано из Bill the Lizard и дополнено скомпилированной версией:

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

Answer 5

org.apache.commons.lang.StringUtils.isNumeric 

хотя стандартная библиотека Java действительно не поддерживает такие служебные функции

Я думаю, что Apache Commons "должен иметь" для каждого Java-программиста

Жаль, что он еще не перенесен на Java5

Answer 6

Отчасти это зависит от того, что вы подразумеваете под «можно преобразовать в целое число».

Если вы имеете в виду «может быть преобразован в int в Java», то ответ от Jonas - хорошее начало, но не совсем завершает работу. Это пройдет 999999999999999999999999999999 например. Я бы добавил обычный вызов try / catch из вашего собственного вопроса в конце метода.

Посимвольные проверки будут эффективно отклонять "не целое число" случаев, оставляя "это целое число, но Java не может его обработать", чтобы случаи были обнаружены более медленным маршрутом исключения. Вы можете сделать этот бит тоже вручную, но это будет лот более сложным.

Answer 7

Только один комментарий о регулярном выражении. Каждый приведенный здесь пример неверен! Если вы хотите использовать регулярные выражения, не забывайте, что компиляция шаблона занимает много времени. Это:

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

Answer 8

Я скопировал код из ответа rally25rs и добавил несколько тестов для нецелых данных. Результаты неоспоримо в пользу метода, публикуемую Йонас Klemming. Результаты для метода Exception, который я первоначально опубликовал, довольно хороши, когда у вас есть целочисленные данные, но они худшие, когда вы этого не делаете, в то время как результаты для решения RegEx (которые, я уверен, многие используют) были последовательно плохо. См. ответ Фелипе для примера скомпилированного регулярного выражения, который намного быстрее.

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

Answer 9

Есть версия гуавы:

import com.google.common.primitives.Ints;

Integer intValue = Ints.tryParse(stringValue);

Он вернет ноль вместо генерации исключения, если не сможет проанализировать строку.

Answer 10

Это короче, но короче не обязательно лучше (и оно не будет ловить целочисленные значения, выходящие за пределы диапазона, , как указано в комментарии danatel ):

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

Лично, поскольку реализация сжимается в вспомогательном методе и корректность имеет меньшую длину, я бы просто пошел с чем-то вроде того, что у вас есть (минус перехват базового класса Exception вместо NumberFormatException).