Самый эффективный способ преобразовать Строку в Целое число в Java

Лучше всего использовать Integer.parseInt. Это вернет int , но это может быть автоматически упаковано в целое число. Это немного быстрее, чем valueOf, так как, когда ваши числа между -128 и 127, он будет использовать кэш Integer, а не создавать новые объекты. Самый медленный метод Apache.

private String data = "99";

public void testParseInt() throws Exception {
    long start = System.currentTimeMillis();
    long count = 0;
    for (int i = 0; i < 100000000; i++) {
        Integer o = Integer.parseInt(data);
        count += o.hashCode();
    }
    long diff = System.currentTimeMillis() - start;
    System.out.println("parseInt completed in " + diff + "ms");
    assert 9900000000L == count;
}

public void testValueOf() throws Exception {
    long start = System.currentTimeMillis();
    long count = 0;
    for (int i = 0; i < 100000000; i++) {
        Integer o = Integer.valueOf(data);
        count += o.hashCode();
    }
    long diff = System.currentTimeMillis() - start;
    System.out.println("valueOf completed in " + diff + "ms");
    assert 9900000000L == count;
}


public void testIntegerConverter() throws Exception {
    long start = System.currentTimeMillis();
    IntegerConverter c = new IntegerConverter();
    long count = 0;
    for (int i = 0; i < 100000000; i++) {
        Integer o = (Integer) c.convert(Integer.class, data);
        count += o.hashCode();
    }
    long diff = System.currentTimeMillis() - start;
    System.out.println("IntegerConverter completed in " + diff + "ms");
    assert 9900000000L == count;
}

parseInt completed in 5906ms
valueOf completed in 7047ms
IntegerConverter completed in 7906ms

Я всегда удивляюсь, как быстро многие из нас отказываются от какого-либо расследования проблем с производительностью. Разбор int для базы 10 является очень распространенной задачей во многих программах. Ускорение этого может иметь заметный положительный эффект во многих средах.

Поскольку синтаксический анализ и int на самом деле являются довольно тривиальной задачей, я попытался реализовать более прямой подход, чем тот, который используется в реализации JDK с переменной базой. Оказалось, что он более чем в два раза быстрее и должен вести себя точно так же, как Integer.parseInt ().

public static int intValueOf( String str )
{
    int ival = 0, idx = 0, end;
    boolean sign = false;
    char ch;

    if( str == null || ( end = str.length() ) == 0 ||
       ( ( ch = str.charAt( 0 ) ) < '0' || ch > '9' )
          && ( !( sign = ch == '-' ) || ++idx == end || ( ( ch = str.charAt( idx ) ) < '0' || ch > '9' ) ) )
        throw new NumberFormatException( str );

    for(;; ival *= 10 )
    {
        ival += '0'- ch;
        if( ++idx == end )
            return sign ? ival : -ival;
        if( ( ch = str.charAt( idx ) ) < '0' || ch > '9' )
            throw new NumberFormatException( str );
    }
}

Чтобы получить объект типа Integer, используйте автобокс или явный

Interger.valueOf( intValueOf( str ) ).

Вот хорошая статья, сравнивающая производительность различных методов синтаксического анализа целых чисел

А вот код, используемый с проверками переполнения / недостаточности.

public static int parseInt( final String s )
{
    if ( string == null )
        throw new NumberFormatException( "Null string" );

    // Check for a sign.
    int num  = 0;
    int sign = -1;
    final int len  = s.length( );
    final char ch  = s.charAt( 0 );
    if ( ch == '-' )
    {
        if ( len == 1 )
            throw new NumberFormatException( "Missing digits:  " + s );
        sign = 1;
    }
    else
    {
        final int d = ch - '0';
        if ( d < 0 || d > 9 )
            throw new NumberFormatException( "Malformed:  " + s );
        num = -d;
    }

    // Build the number.
    final int max = (sign == -1) ?
        -Integer.MAX_VALUE : Integer.MIN_VALUE;
    final int multmax = max / 10;
    int i = 1;
    while ( i < len )
    {
        int d = s.charAt(i++) - '0';
        if ( d < 0 || d > 9 )
            throw new NumberFormatException( "Malformed:  " + s );
        if ( num < multmax )
            throw new NumberFormatException( "Over/underflow:  " + s );
        num *= 10;
        if ( num < (max+d) )
            throw new NumberFormatException( "Over/underflow:  " + s );
        num -= d;
    }

    return sign * num;
}

И даже более быстрая реализация, без проверок переполнения / недостаточности.

public static int parseInt( final String s )
{
    // Check for a sign.
    int num  = 0;
    int sign = -1;
    final int len  = s.length( );
    final char ch  = s.charAt( 0 );
    if ( ch == '-' )
        sign = 1;
    else
        num = '0' - ch;

    // Build the number.
    int i = 1;
    while ( i < len )
        num = num*10 + '0' - s.charAt( i++ );

    return sign * num;
} 

ParseInt возвращает int, а не java.lang.Integer, поэтому, если вы используете метод tat, вам придется сделать

new Integer (Integer.parseInt(number));

Я много раз слышал, что вместо этого вызывается Integer.valueOf () new Integer () лучше по причинам памяти (это подходит для pmd)

В JDK 1.5 вызов new Integer () вызывает выделение памяти. Integer.valueOf () более дружественный к памяти.

http://pmd.sourceforge.net/rules/migrating.html

Кроме того, Integer.valueOf разрешает кэширование, так как значения от -127 до 128 гарантированно иметь кэшированные экземпляры. (начиная с версии 1.5)

Другим способом является этот метод:

public class stringtoInteger {

    private static int stringtoInteger(String x) {
        String value = "";
        for (int i = 0; i < x.length(); i++) {
            char character = x.charAt(i);
            if (Character.isDigit(character)) {
                value = value + character;
            }
        }
        return Integer.parseInt(value);
    }
}  

Надеюсь, что это помогает!

Если вас беспокоит эффективность, то создание объекта Integer намного дороже, чем его анализ. Если вам нужно создать целочисленный объект, я бы не стал слишком беспокоиться о том, как он анализируется.

Примечание: Java 6u14 позволяет увеличить размер вашего целочисленного пула с помощью параметра командной строки -Djava.lang.Integer .IntegerCache.high = 1024, например.

Примечание 2: Если вы читаете необработанные данные, например байты из файла или сети, преобразование этих байтов в строку также является относительно дорогостоящим. Если вы собираетесь написать собственный синтаксический анализатор, я предлагаю пропустить этап обращения к строке и проанализировать необработанные исходные данные.

Примечание 3: если вы создаете целое число, чтобы вы могли поместить его в коллекцию, вы можете избежать это с помощью GNU Trove (trove4j), который позволяет хранить примитивы в коллекциях,

Я знаю, что этого нет среди ваших вариантов выше. IntegerConverter в порядке, но вам нужно создать его экземпляр. Взгляните на NumberUtils в Commons Lang:

Commons Lang NumberUtils

, это предоставляет метод toInt:

static int toInt(java.lang.String str, int defaultValue) 

, который позволяет вам указать значение по умолчанию в случае сбоя.

NumberUtils.toInt("1", 0)  = 1

Это лучшее решение I На данный момент найдено.

Если вас беспокоит эффективность, используйте int: он намного быстрее, чем Integer.

В противном случае class Integer предлагает вам по крайней мере пару ясных и понятных способов:

Integer myInteger = new Integer(someString);
Integer anotherInteger = Integer.valueOf(someOtherString);