Как преобразовать String в int в Java?

Как я могу преобразовать String в int в Java?

Моя строка содержит только числа, и я хочу вернуть число, которое она представляет.

Например, для данной строки "1234" результатом должно быть число 1234 .

Ответов (25)

Решение
String myString = "1234";
int foo = Integer.parseInt(myString);

Если вы посмотрите документацию по Java, то заметите «загвоздку» в том, что эта функция может генерировать a NumberFormatException, что, конечно же, нужно обработать:

int foo;
try {
   foo = Integer.parseInt(myString);
}
catch (NumberFormatException e)
{
   foo = 0;
}

(Это лечение по умолчанию устанавливает неправильное число равным 0, но вы можете сделать что-нибудь еще, если хотите.)

В качестве альтернативы вы можете использовать Ints метод из библиотеки Guava, который в сочетании с Java 8 Optional обеспечивает мощный и лаконичный способ преобразования строки в int:

import com.google.common.primitives.Ints;

int foo = Optional.ofNullable(myString)
 .map(Ints::tryParse)
 .orElse(0)

Сделайте это вручную:

public static int strToInt(String str){
    int i = 0;
    int num = 0;
    boolean isNeg = false;

    // Check for negative sign; if it's there, set the isNeg flag
    if (str.charAt(0) == '-') {
        isNeg = true;
        i = 1;
    }

    // Process each character of the string;
    while( i < str.length()) {
        num *= 10;
        num += str.charAt(i++) - '0'; // Minus the ASCII code of '0' to get the value of the charAt(i++).
    }

    if (isNeg)
        num = -num;
    return num;
}

Вы также можете начать с удаления всех нечисловых символов, а затем проанализировать целое число:

String mystr = mystr.replaceAll("[^\\d]", "");
int number = Integer.parseInt(mystr);

Но имейте в виду, что это работает только для неотрицательных чисел.

Преобразование строки в int сложнее, чем просто преобразование числа. Вы задумались над следующими проблемами:

  • Строка содержит только цифры 0-9 ?
  • Что случилось с - / + до или после строки? Возможно ли это (по бухгалтерским цифрам)?
  • Что случилось с MAX _- / MIN_INFINITY? Что будет, если строка будет 99999999999999999999? Может ли машина рассматривать эту строку как int?

В настоящее время я делаю задание для колледжа, где я не могу использовать определенные выражения, такие как приведенные выше, и, посмотрев на таблицу ASCII, мне удалось это сделать. Это гораздо более сложный код, но он может помочь другим, которые ограничены, как и я.

Первое, что нужно сделать, это получить ввод, в данном случае строку цифр; Я назову его String number, и в данном случае я проиллюстрирую его цифрой 12, поэтому String number = "12";

Еще одним ограничением было то, что я не мог использовать повторяющиеся циклы, следовательно, for цикл (который был бы идеальным) тоже нельзя было использовать. Это немного ограничивает нас, но, опять же, это цель. Поскольку мне нужны были только две цифры (последние две цифры), простая charAt задача решена:

 // Obtaining the integer values of the char 1 and 2 in ASCII
 int semilastdigitASCII = number.charAt(number.length() - 2);
 int lastdigitASCII = number.charAt(number.length() - 1);

Имея коды, нам просто нужно взглянуть на таблицу и внести необходимые коррективы:

 double semilastdigit = semilastdigitASCII - 48;  // A quick look, and -48 is the key
 double lastdigit = lastdigitASCII - 48;

Почему же удваивать? Ну из-за действительно «странного» шага. В настоящее время у нас есть два двойных, 1 и 2, но нам нужно превратить их в 12, мы не можем выполнить никаких математических операций.

Мы делим последнюю (последнюю цифру) на 10 следующим образом 2/10 = 0.2 (следовательно, удваиваем):

 lastdigit = lastdigit / 10;

Это просто игра с числами. Мы превращали последнюю цифру в десятичную. Но теперь посмотрите, что происходит:

 double jointdigits = semilastdigit + lastdigit; // 1.0 + 0.2 = 1.2

Не вдаваясь в математику, мы просто отделяем единицы от цифр числа. Видите ли, поскольку мы рассматриваем только 0–9, деление на число, кратное 10, похоже на создание «коробки», в которой вы его храните (вспомните, когда ваш учитель первого класса объяснил вам, что такое единица и сотня). Так:

 int finalnumber = (int) (jointdigits*10); // Be sure to use parentheses "()"

Вот и все. Вы превратили строку цифр (в данном случае две цифры) в целое число, состоящее из этих двух цифр, с учетом следующих ограничений:

  • Нет повторяющихся циклов
  • Никаких "волшебных" выражений, таких как parseInt

У меня есть решение, но я не знаю, насколько оно эффективно. Но он работает хорошо, и я думаю, вы могли бы его улучшить. С другой стороны, я провел пару тестов с JUnit, которые шагнули правильно. Прикрепил функцию и тестирование:

static public Integer str2Int(String str) {
    Integer result = null;
    if (null == str || 0 == str.length()) {
        return null;
    }
    try {
        result = Integer.parseInt(str);
    } 
    catch (NumberFormatException e) {
        String negativeMode = "";
        if(str.indexOf('-') != -1)
            negativeMode = "-";
        str = str.replaceAll("-", "" );
        if (str.indexOf('.') != -1) {
            str = str.substring(0, str.indexOf('.'));
            if (str.length() == 0) {
                return (Integer)0;
            }
        }
        String strNum = str.replaceAll("[^\\d]", "" );
        if (0 == strNum.length()) {
            return null;
        }
        result = Integer.parseInt(negativeMode + strNum);
    }
    return result;
}

Тестирование с JUnit:

@Test
public void testStr2Int() {
    assertEquals("is numeric", (Integer)(-5), Helper.str2Int("-5"));
    assertEquals("is numeric", (Integer)50, Helper.str2Int("50.00"));
    assertEquals("is numeric", (Integer)20, Helper.str2Int("$ 20.90"));
    assertEquals("is numeric", (Integer)5, Helper.str2Int(" 5.321"));
    assertEquals("is numeric", (Integer)1000, Helper.str2Int("1,000.50"));
    assertEquals("is numeric", (Integer)0, Helper.str2Int("0.50"));
    assertEquals("is numeric", (Integer)0, Helper.str2Int(".50"));
    assertEquals("is numeric", (Integer)0, Helper.str2Int("-.10"));
    assertEquals("is numeric", (Integer)Integer.MAX_VALUE, Helper.str2Int(""+Integer.MAX_VALUE));
    assertEquals("is numeric", (Integer)Integer.MIN_VALUE, Helper.str2Int(""+Integer.MIN_VALUE));
    assertEquals("Not
     is numeric", null, Helper.str2Int("czv.,xcvsa"));
    /**
     * Dynamic test
     */
    for(Integer num = 0; num < 1000; num++) {
        for(int spaces = 1; spaces < 6; spaces++) {
            String numStr = String.format("%0"+spaces+"d", num);
            Integer numNeg = num * -1;
            assertEquals(numStr + ": is numeric", num, Helper.str2Int(numStr));
            assertEquals(numNeg + ": is numeric", numNeg, Helper.str2Int("- " + numStr));
        }
    }
}

Альтернативное решение - использовать NumberUtils Apache Commons :

int num = NumberUtils.toInt("1234");

Утилита Apache хороша тем, что если строка имеет недопустимый числовой формат, всегда возвращается 0. Следовательно, вы экономите блок try catch.

Apache NumberUtils API версии 3.4

Мы можем использовать parseInt(String str) метод класса- Integer оболочки для преобразования значения String в целочисленное значение.

Например:

String strValue = "12345";
Integer intValue = Integer.parseInt(strVal);

Integer Класс также обеспечивает valueOf(String str) метод:

String strValue = "12345";
Integer intValue = Integer.valueOf(strValue);

Мы также можем использовать toInt(String strValue) в NumberUtils Utility класса для преобразования:

String strValue = "12345";
Integer intValue = NumberUtils.toInt(strValue);

Integer.decode

Вы также можете использовать public static Integer decode(String nm) throws NumberFormatException .

Это также работает для базы 8 и 16:

// base 10
Integer.parseInt("12");     // 12 - int
Integer.valueOf("12");      // 12 - Integer
Integer.decode("12");       // 12 - Integer
// base 8
// 10 (0,1,...,7,10,11,12)
Integer.parseInt("12", 8);  // 10 - int
Integer.valueOf("12", 8);   // 10 - Integer
Integer.decode("012");      // 10 - Integer
// base 16
// 18 (0,1,...,F,10,11,12)
Integer.parseInt("12",16);  // 18 - int
Integer.valueOf("12",16);   // 18 - Integer
Integer.decode("#12");      // 18 - Integer
Integer.decode("0x12");     // 18 - Integer
Integer.decode("0X12");     // 18 - Integer
// base 2
Integer.parseInt("11",2);   // 3 - int
Integer.valueOf("11",2);    // 3 - Integer

Если вы хотите получить int вместо, Integer вы можете использовать:

  1. Распаковка:

    int val = Integer.decode("12"); 
    
  2. intValue():

    Integer.decode("12").intValue();
    

Всякий раз, когда есть малейшая вероятность того, что данная строка не содержит целого числа, вы должны обработать этот особый случай. К сожалению, стандартные методы Java Integer::parseInt и Integer::valueOf бросают, NumberFormatException чтобы сигнализировать об этом особом случае. Таким образом, вы должны использовать исключения для управления потоком, что обычно считается плохим стилем кодирования.

На мой взгляд, в этом особом случае следует возвращать пустое значение Optional<Integer> . Поскольку Java не предлагает такого метода, я использую следующую оболочку:

private Optional<Integer> tryParseInteger(String string) {
    try {
        return Optional.of(Integer.valueOf(string));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
}

Пример использования:

// prints "12"
System.out.println(tryParseInteger("12").map(i -> i.toString()).orElse("invalid"));
// prints "-1"
System.out.println(tryParseInteger("-1").map(i -> i.toString()).orElse("invalid"));
// prints "invalid"
System.out.println(tryParseInteger("ab").map(i -> i.toString()).orElse("invalid"));

Хотя он все еще использует исключения для внутреннего управления потоком, код использования становится очень чистым. Кроме того, вы можете четко различить случай, когда -1 анализируется как допустимое значение, и случай, когда недопустимая строка не может быть проанализирована.

Помимо предыдущих ответов, я хотел бы добавить несколько функций. Вот результаты, пока вы их используете:

public static void main(String[] args) {
  System.out.println(parseIntOrDefault("123", 0)); // 123
  System.out.println(parseIntOrDefault("aaa", 0)); // 0
  System.out.println(parseIntOrDefault("aaa456", 3, 0)); // 456
  System.out.println(parseIntOrDefault("aaa789bbb", 3, 6, 0)); // 789
}

Реализация:

public static int parseIntOrDefault(String value, int defaultValue) {
  int result = defaultValue;
  try {
    result = Integer.parseInt(value);
  }
  catch (Exception e) {
  }
  return result;
}

public static int parseIntOrDefault(String value, int beginIndex, int defaultValue) {
  int result = defaultValue;
  try {
    String stringValue = value.substring(beginIndex);
    result = Integer.parseInt(stringValue);
  }
  catch (Exception e) {
  }
  return result;
}

public static int parseIntOrDefault(String value, int beginIndex, int endIndex, int defaultValue) {
  int result = defaultValue;
  try {
    String stringValue = value.substring(beginIndex, endIndex);
    result = Integer.parseInt(stringValue);
  }
  catch (Exception e) {
  }
  return result;
}

Как уже упоминалось, Apache Commons NumberUtils может это сделать. Он возвращается, 0 если не может преобразовать строку в int.

Вы также можете определить собственное значение по умолчанию:

NumberUtils.toInt(String str, int defaultValue)

Пример:

NumberUtils.toInt("3244", 1) = 3244
NumberUtils.toInt("", 1)     = 1
NumberUtils.toInt(null, 5)   = 5
NumberUtils.toInt("Hi", 6)   = 6
NumberUtils.toInt(" 32 ", 1) = 1 // Space in numbers are not allowed
NumberUtils.toInt(StringUtils.trimToEmpty("  32 ", 1)) = 32;

В Google Guava есть tryParse (String) , который возвращает, null если строка не может быть проанализирована, например:

Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null) {
  ...
}

Способы сделать это:

  1. Integer.parseInt(s)
  2. Integer.parseInt(s, radix)
  3. Integer.parseInt(s, beginIndex, endIndex, radix)
  4. Integer.parseUnsignedInt(s)
  5. Integer.parseUnsignedInt(s, radix)
  6. Integer.parseUnsignedInt(s, beginIndex, endIndex, radix)
  7. Integer.valueOf(s)
  8. Integer.valueOf(s, radix)
  9. Integer.decode(s)
  10. NumberUtils.toInt(s)
  11. NumberUtils.toInt(s, defaultValue)

Integer.valueOf создает объект Integer, а все другие методы - примитивный int.

Последние два метода взяты из commons-lang3 и большая статья о преобразовании здесь .

Используйте Integer.parseInt(yourString).

Помните следующее:

Integer.parseInt("1"); // Ok

Integer.parseInt("-1"); // Ok

Integer.parseInt("+1"); // Ok

Integer.parseInt(" 1"); // Исключение (пустое место)

Integer.parseInt("2147483648"); // Исключение (целое число ограничено максимальным значением 2 147 483 647)

Integer.parseInt("1.1"); // Исключение ( . Или , или что не разрешено)

Integer.parseInt(""); // Исключение (не 0 или что-то в этом роде)

Есть только один тип исключения: NumberFormatException

Я написал этот быстрый метод для синтаксического анализа введенной строки в int или long. Он быстрее, чем текущий JDK 11 Integer.parseInt или Long.parseLong. Хотя вы просили только int, я также включил длинный синтаксический анализатор. Для парсера кода ниже требуется, чтобы метод парсера был небольшим, чтобы он работал быстро. Альтернативная версия находится под тестовым кодом. Альтернативная версия довольно быстрая и не зависит от размера класса.

Этот класс проверяет переполнение, и вы можете настроить код в соответствии со своими потребностями. Пустая строка вернет 0 с моим методом, но это сделано намеренно. Вы можете изменить это в соответствии со своим случаем или использовать как есть.

Это только часть класса, в которой необходимы parseInt и parseLong. Обратите внимание, что это касается только чисел с основанием 10.

Тестовый код для парсера int находится под кодом ниже.

/*
 * Copyright 2019 Khang Hoang Nguyen
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * @author: Khang Hoang Nguyen - [email protected]
 **/
final class faiNumber{
    private static final long[] longpow = {0L, 1L, 10L, 100L, 1000L, 10000L, 100000L, 1000000L, 10000000L, 100000000L, 1000000000L,
                                           10000000000L, 100000000000L, 1000000000000L, 10000000000000L, 100000000000000L,
                                           1000000000000000L, 10000000000000000L, 100000000000000000L, 1000000000000000000L,
                                          };

    private static final int[] intpow = { 0, 1, 10, 100, 1000, 10000,
                                          100000, 1000000, 10000000, 100000000, 1000000000
                                        };

    /**
     * parseLong(String str) parse a String into Long.
     * All errors throw by this method is NumberFormatException.
     * Better errors can be made to tailor to each use case.
     **/
    public static long parseLong(final String str) {
        final int length = str.length();
        if (length == 0)
            return 0L;

        char c1 = str.charAt(0);
        int start;

        if (c1 == '-' || c1 == '+') {
            if (length == 1)
                throw new NumberFormatException(String.format("Not a valid long value. Input '%s'.", str));
            start = 1;
        } else {
            start = 0;
        }

        /*
         * Note: if length > 19, possible scenario is to run through the string
         * to check whether the string contains only valid digits.
         * If the check had only valid digits then a negative sign meant underflow, else, overflow.
         */
        if (length - start > 19)
            throw new NumberFormatException(String.format("Not a valid long value. Input '%s'.", str));

        long c;
        long out = 0L;

        for ( ; start < length; start++) {
            c = (str.charAt(start) ^ '0');
            if (c > 9L)
                throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            out += c * longpow[length - start];
        }

        if (c1 == '-') {
            out = ~out + 1L;
            // If out > 0 number underflow(supposed to be negative).
            if (out > 0L)
                throw new NumberFormatException(String.format("Not a valid long value. Input '%s'.", str));
            return out;
        }
        // If out < 0 number overflow (supposed to be positive).
        if (out < 0L)
            throw new NumberFormatException(String.format("Not a valid long value. Input '%s'.", str));
        return out;
    }

    /**
     * parseInt(String str) parse a string into an int.
     * return 0 if string is empty.
     **/
    public static int parseInt(final String str) {
        final int length = str.length();
        if (length == 0)
            return 0;

        char c1 = str.charAt(0);
        int start;

        if (c1 == '-' || c1 == '+') {
            if (length == 1)
                throw new NumberFormatException(String.format("Not a valid integer value. Input '%s'.", str));
            start = 1;
        } else {
            start = 0;
        }

        int out = 0; int c;
        int runlen = length - start;

        if (runlen > 9) {
            if (runlen > 10)
                throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));

            c = (str.charAt(start) ^ '0'); // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57
            if (c > 9)
                throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));
            if (c > 2)
                throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));
            out += c * intpow[length - start++];
        }

        for ( ; start < length; start++) {
            c = (str.charAt(start) ^ '0');
            if (c > 9)
                throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));
            out += c * intpow[length - start];
        }

        if (c1 == '-') {
            out = ~out + 1;
            if (out > 0)
                throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));
            return out;
        }

        if (out < 0)
            throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));
        return out;
    }
}

Раздел тестового кода. Это должно занять около 200 секунд.

// Int Number Parser Test;
long start = System.currentTimeMillis();
System.out.println("INT PARSER TEST");
for (int i = Integer.MIN_VALUE; i != Integer.MAX_VALUE; i++){
   if (faiNumber.parseInt(""+i) != i)
       System.out.println("Wrong");
   if (i == 0)
       System.out.println("HalfWay Done");
}

if (faiNumber.parseInt("" + Integer.MAX_VALUE) != Integer.MAX_VALUE)
    System.out.println("Wrong");
long end = System.currentTimeMillis();
long result = (end - start);
System.out.println(result);
// INT PARSER END */

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

public static int parseInt(final String str) {
    final int length = str.length();
    if (length == 0)
        return 0;

    char c1 = str.charAt(0);
    int start;

    if (c1 == '-' || c1 == '+') {
        if (length == 1)
            throw new NumberFormatException(String.format("Not a valid integer value. Input '%s'.", str));
        start = 1;
    } else {
        start = 0;
    }

    int out = 0;
    int c;
    while (start < length && str.charAt(start) == '0')
        start++; // <-- This to disregard leading 0. It can be
                 // removed if you know exactly your source
                 // does not have leading zeroes.
    int runlen = length - start;

    if (runlen > 9) {
        if (runlen > 10)
            throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));

        c = (str.charAt(start++) ^ '0');  // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57
        if (c > 9)
            throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));
        if (c > 2)
            throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));
        out = (out << 1) + (out << 3) + c; // <- Alternatively this can just be out = c or c above can just be out;
    }

    for ( ; start < length; start++) {
        c = (str.charAt(start) ^ '0');
        if (c > 9)
            throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));
        out = (out << 1) + (out << 3) + c;
    }

    if (c1 == '-') {
        out = ~out + 1;
        if (out > 0)
            throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));
        return out;
    }

    if (out < 0)
        throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));
    return out;
}

Вот некоторые из способов преобразования String в Int :

  1. Вы можете использовать Integer.parseInt():

    String test = "4568";
    int new = Integer.parseInt(test);
    
  2. Также вы можете использовать Integer.valueOf():

    String test = "4568";
    int new = Integer.valueOf(test);
    

Используйте этот метод:

public int ConvertStringToInt(String number) {
    int num = 0;

    try {
        int newNumber = Integer.ParseInt(number);
        num = newNumber;
    } catch(Exception ex) {
        num = 0;
        Log.i("Console", ex.toString);
    }
    return num;
}

Собственный алгоритм:

public static int toInt(String value) {
  int output = 0;
  boolean isFirstCharacter = true;
  boolean isNegativeNumber = false;
  byte bytes[] = value.getBytes();
  for (int i = 0; i < bytes.length; i++) {
    char c = (char) bytes[i];
    if (!Character.isDigit(c)) {
      isNegativeNumber = (c == '-');
      if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {
        throw new NumberFormatException("For input string \"" + value + "\"");
      }
    } else {
      int number = Character.getNumericValue(c);
      output = output * 10 + number;
    }
    isFirstCharacter = false;
  }
  if (isNegativeNumber)
    output *= -1;
  return output;
}

Другое решение:

(Используйте метод string charAt вместо преобразования строки в массив байтов)

public static int toInt(String value) {
  int output = 0;
  boolean isFirstCharacter = true;
  boolean isNegativeNumber = false;
  for (int i = 0; i < value.length(); i++) {
    char c = value.charAt(i);
    if (!Character.isDigit(c)) {
      isNegativeNumber = (c == '-');
      if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {
        throw new NumberFormatException("For input string \"" + value + "\"");
      }
    } else {
      int number = Character.getNumericValue(c);
      output = output * 10 + number;
    }
    isFirstCharacter = false;
  }
  if (isNegativeNumber)
    output *= -1;
  return output;
}

Примеры:

int number1 = toInt("20");
int number2 = toInt("-20");
int number3 = toInt("+20");
System.out.println("Numbers = " + number1 + ", " + number2 + ", " + number3);

try {
  toInt("20 Hadi");
} catch (NumberFormatException e) {
  System.out.println("Error: " + e.getMessage());
}

Существуют различные способы преобразования строкового значения int в значение типа данных Integer. Вам необходимо обработать NumberFormatException для проблемы со строковым значением.

  1. Integer.parseInt

     foo = Integer.parseInt(myString);
    
  2. Integer.valueOf

     foo = Integer.valueOf(myString);
    
  3. Использование дополнительного API Java 8

     foo = Optional.of(myString).map(Integer::parseInt).get();
    

Помимо всех этих ответов я нашел один новый способ, хотя он использует внутренне Integer.parseInt(),

Используя

import javafx.util.converter.IntegerStringConverter;

new IntegerStringConverter().fromString("1234").intValue()

или

new IntegerStringConverter().fromString("1234")

Хотя создание новых объектов обходится немного дороже, я просто хотел добавить, поскольку узнал новый способ.

Просто пройдите через javafx.util.StringConverter<T> класс, он помогает преобразовать любое значение класса-оболочки в строку или наоборот.

Пожалуйста, используйте NumberUtils для анализа целых чисел из строки.

  • Эта функция также может обрабатывать исключение, если заданная строка слишком длинная.
  • Мы также можем указать значения по умолчанию .

Вот пример кода.

NumberUtils.toInt("00450");
NumberUtils.toInt("45464646545645400000");
NumberUtils.toInt("45464646545645400000", 0); // Where 0 is the default value.

output:
450
0
0

Что ж, очень важный момент, который следует учитывать, заключается в том, что парсер Integer выдает исключение NumberFormatException, как указано в Javadoc .

int foo;
String StringThatCouldBeANumberOrNot = "26263Hello"; //will throw exception
String StringThatCouldBeANumberOrNot2 = "26263"; //will not throw exception
try {
      foo = Integer.parseInt(StringThatCouldBeANumberOrNot);
} catch (NumberFormatException e) {
      //Will Throw exception!
      //do something! anything to handle the exception.
}

try {
      foo = Integer.parseInt(StringThatCouldBeANumberOrNot2);
} catch (NumberFormatException e) {
      //No problem this time, but still it is good practice to care about exceptions.
      //Never trust user input :)
      //Do something! Anything to handle the exception.
}

Это исключение важно обрабатывать при попытке получить целочисленные значения из разделенных аргументов или при динамическом анализе чего-либо.

Вы можете использовать Integer.parseInt (str)

Например :

String str = "2";

int num = Intger.parseInt(str);

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

Например, есть два способа:

Integer x = Integer.valueOf(str);
// or
int y = Integer.parseInt(str);

Между этими методами есть небольшая разница:

  • valueOf возвращает новый или кешированный экземпляр java.lang.Integer
  • parseIntвозвращает примитив int.

То же самое для всех случаев: Short.valueOf / parseShort, Long.valueOf / parseLong и т. Д.