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

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

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

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

вопрос задан 7.04.2011
Unknown user
15647 репутация

35 ответов


  • 3625 рейтинг
     String myString = "1234";
    int foo = Integer.parseInt(myString);
     

    Дополнительную информацию см. В документации по Java .

    ответ дан Rob Hruska, с репутацией 89759, 7.04.2011
  • 605 рейтинг

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

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

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

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

    Же для всех случаев: Short.valueOf /parseShort , Long.valueOf /parseLong , и т.д.

    ответ дан smas, с репутацией 18384, 7.04.2011
  • 220 рейтинг

    Ну, очень важно рассмотреть, что парсер 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.
    }
     

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

    ответ дан Ali Akdurak, с репутацией 2896, 30.04.2013
  • 75 рейтинг

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

     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;
    }
     
    ответ дан Billz, с репутацией 3415, 11.09.2013
  • 40 рейтинг

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

    Мы делим последний (lastdigit) на 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 "()"
     

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

    • Нет повторяющихся циклов
    • Нет выражений «Magic», таких как parseInt
    ответ дан Oak, с репутацией 563, 20.03.2014
  • 36 рейтинг

    Альтернативным решением является использование NumberUtils для Apache Commons :

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

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

    API Apache NumberUtils версии 3.4

    ответ дан Ryboflavin, с репутацией 481, 27.08.2015
  • 29 рейтинг

    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();
       
    ответ дан ROMANIA_engineer, с репутацией 30975, 7.03.2016
  • 23 рейтинг

    Всякий раз, когда имеется малейшая вероятность того, что данная строка не содержит целочисленного значения, вам придется обрабатывать этот частный случай. К сожалению, стандартные 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 1234
    System.out.println(tryParseInteger("1234").orElse(-1));
    // prints -1
    System.out.println(tryParseInteger("foobar").orElse(-1));
     

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

    ответ дан Stefan Dollase, с репутацией 3051, 4.04.2016
  • 21 рейтинг

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

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

    Мы можем использовать метод 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) класса Utility Utility для преобразования:

     String strValue = "12345";
    Integer intValue = NumberUtils.toInt(strValue);
     
    ответ дан Giridhar Kumar, с репутацией 451, 20.10.2015
  • 18 рейтинг

    Использовать 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

    ответ дан Lukas Bauer, с репутацией 318, 6.10.2017
  • 17 рейтинг

    Методы для этого:

      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.

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

    ответ дан Dmytro Shvechikov, с репутацией 245, 3.10.2017
  • 17 рейтинг

    У меня есть решение, но я не знаю, насколько он эффективен. Но он работает хорошо, и я думаю, вы могли бы его улучшить. С другой стороны, я сделал пару тестов с 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));
            }
        }
    }
     
    ответ дан fitorec, с репутацией 752, 23.05.2014
  • 16 рейтинг

    Просто для удовольствия: вы можете использовать Java 8 Optional для преобразования String в Integer :

     String str = "123";
    Integer value = Optional.of(str).map(Integer::valueOf).get();
    // Will return the integer value of the specified string, or it
    // will throw an NPE when str is null.
    
    value = Optional.ofNullable(str).map(Integer::valueOf).orElse(-1);
    // Will do the same as the code above, except it will return -1
    // when srt is null, instead of throwing an NPE.
     

    Здесь мы просто объединяем Integer.valueOf и Optinal . Вероятно, могут быть ситуации, когда это полезно - например, если вы хотите избежать нулевых проверок. Код Pre Java 8 будет выглядеть так:

     Integer value = (str == null) ? -1 : Integer.parseInt(str);
     
    ответ дан Anton Balaniuc, с репутацией 3874, 9.11.2016
  • 14 рейтинг

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

     Integer fooInt = Ints.tryParse(fooString);
    if (fooInt != null) {
      ...
    }
     
    ответ дан Vitalii Fedorenko, с репутацией 66689, 6.08.2016
  • 12 рейтинг

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

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

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

    ответ дан Thijser, с репутацией 1119, 20.10.2013
  • 10 рейтинг

    Помимо этих выше ответов, я хотел бы добавить несколько функций:

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

    И вот результаты при их запуске:

       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
      }
     
    ответ дан nxhoaf, с репутацией 4887, 1.08.2016
  • 9 рейтинг

    Вы можете использовать new Scanner("1244").nextInt() . Или спросите, существует ли даже int: new Scanner("1244").hasNextInt()

    ответ дан Christian Ullenboom, с репутацией 755, 28.02.2017
  • 8 рейтинг

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

    1. Для действительного натурального числа:

       private static int parseInt(String str) {
          int i, n = 0;
      
          for (i = 0; i < str.length(); i++) {
              n *= 10;
              n += str.charAt(i) - 48;
          }
          return n;
      }
       
    2. Для положительных и отрицательных целых чисел:

       private static int parseInt(String str) {
          int i=0, n=0, sign=1;
          if(str.charAt(0) == '-') {
              i=1;
              sign=-1;
          }
          for(; i<str.length(); i++) {
              n*=10;
              n+=str.charAt(i)-48;
          }
          return sign*n;
      }
       

    3. Если вы ожидаете пробел до или после этих чисел, тогда обязательно сделайте str = str.trim() перед дальнейшей обработкой.

    ответ дан Raman Sahasi, с репутацией 14669, 24.04.2017
  • 8 рейтинг

    Как уже говорилось, 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; 
     
    ответ дан Alireza Fattahi, с репутацией 19424, 26.07.2016
  • 8 рейтинг

    Вы также можете использовать этот код с некоторыми предосторожностями.

    • Вариант № 1: обрабатывать исключение явно, например, показывать диалог сообщения, а затем останавливать выполнение текущего рабочего процесса. Например:

       try
          {
              String stringValue = "1234";
      
              // From String to Integer
              int integerValue = Integer.valueOf(stringValue);
      
              // Or
              int integerValue = Integer.ParseInt(stringValue);
      
              // Now from integer to back into string
              stringValue = String.valueOf(integerValue);
          }
      catch (NumberFormatException ex) {
          //JOptionPane.showMessageDialog(frame, "Invalid input string!");
          System.out.println("Invalid input string!");
          return;
      }
       
    • Вариант № 2: сброс затронутой переменной, если поток выполнения может продолжаться в случае исключения. Например, с некоторыми изменениями в блоке catch

       catch (NumberFormatException ex) {
          integerValue = 0;
      }
       

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

    ответ дан manikant gautam, с репутацией 1483, 31.12.2015
  • 7 рейтинг

    Просто вы можете попробовать следующее:

    • Используйте Integer.parseInt(your_string); для преобразования от String до int
    • Используйте Double.parseDouble(your_string); для преобразования от String до double

    пример

     String str = "8955";
    int q = Integer.parseInt(str);
    System.out.println("Output>>> " + q); // Output: 8955
     

     String str = "89.55";
    double q = Double.parseDouble(str);
    System.out.println("Output>>> " + q); // Output: 89.55
     
    ответ дан Vishal Yadav, с репутацией 705, 14.09.2017
  • 6 рейтинг

    Вот так

     String str="1234";
    int number = Integer.parseInt(str);
    print number;//1234
     
    ответ дан Shivanandam Sirmarigari, с репутацией 743, 20.11.2016
  • 6 рейтинг
     int foo=Integer.parseInt("1234");
     

    Убедитесь, что в строке нет нечисловых данных.

    ответ дан iKing, с репутацией 509, 20.04.2016
  • 6 рейтинг

    Для нормальной строки вы можете использовать:

     int number = Integer.parseInt("1234");
     

    Для String builder и String buffer вы можете использовать:

     Integer.parseInt(myBuilderOrBuffer.toString());
     
    ответ дан Aditya, с репутацией 162, 18.08.2016
  • 6 рейтинг

    Я немного удивлен тем, что никто не упоминал конструктор Integer, который берет String в качестве параметра.
    Итак, вот:

     String myString = "1234";
    int i1 = new Integer(myString);
     

    Java 8 - Целое число (String) .

    Конечно, конструктор вернет тип Integer , а операция распаковки преобразует значение в int .


    Важно упомянуть
    Этот конструктор вызывает parseInt метода.

     public Integer(String var1) throws NumberFormatException {
        this.value = parseInt(var1, 10);
    }
     
    ответ дан djm.im, с репутацией 2058, 23.04.2018
  • 5 рейтинг

    Используйте Integer.parseInt () и поместите его внутри блока try...catch для обработки любых ошибок на всякий случай, если вводится нечисловой символ, например,

     private void ConvertToInt(){
        String string = txtString.getText();
        try{
            int integerValue=Integer.parseInt(string);
            System.out.println(integerValue);
        }
        catch(Exception e){
           JOptionPane.showMessageDialog(
             "Error converting string to integer\n" + e.toString,
             "Error",
             JOptionPane.ERROR_MESSAGE);
        }
     }
     
    ответ дан David, с репутацией 313, 11.11.2017
  • 5 рейтинг

    Один из методов - parseInt (String) возвращает примитив int

     String number = "10";
    int result = Integer.parseInt(number);
    System.out.println(result);
     

    Второй метод: valueOf (String) возвращает новый объект Integer ().

     String number = "10";
    Integer result = Integer.valueOf(number);
    System.out.println(result);
     
    ответ дан Pankaj Mandale, с репутацией 378, 12.08.2017
  • 4 рейтинг

    Это полная программа со всеми условиями положительная, отрицательная без использования библиотеки

     import java.util.Scanner;
    
    
        public class StringToInt {
         public static void main(String args[]) {
          String inputString;
          Scanner s = new Scanner(System.in);
          inputString = s.nextLine();
    
          if (!inputString.matches("([+-]?([0-9]*[.])?[0-9]+)")) {
           System.out.println("Not a Number");
          } else {
           Double result2 = getNumber(inputString);
           System.out.println("result = " + result2);
          }
    
         }
         public static Double getNumber(String number) {
          Double result = 0.0;
          Double beforeDecimal = 0.0;
          Double afterDecimal = 0.0;
          Double afterDecimalCount = 0.0;
          int signBit = 1;
          boolean flag = false;
    
          int count = number.length();
          if (number.charAt(0) == '-') {
           signBit = -1;
           flag = true;
          } else if (number.charAt(0) == '+') {
           flag = true;
          }
          for (int i = 0; i < count; i++) {
           if (flag && i == 0) {
            continue;
    
           }
           if (afterDecimalCount == 0.0) {
            if (number.charAt(i) - '.' == 0) {
             afterDecimalCount++;
            } else {
             beforeDecimal = beforeDecimal * 10 + (number.charAt(i) - '0');
            }
    
           } else {
            afterDecimal = afterDecimal * 10 + number.charAt(i) - ('0');
            afterDecimalCount = afterDecimalCount * 10;
           }
          }
          if (afterDecimalCount != 0.0) {
           afterDecimal = afterDecimal / afterDecimalCount;
           result = beforeDecimal + afterDecimal;
          } else {
           result = beforeDecimal;
          }
    
          return result * signBit;
         }
        }
     
    ответ дан Anup Gupta, с репутацией 521, 1.09.2017
  • 3 рейтинг

    Кстати, имейте в виду, что если строка равна нулю, вызов:

     int i = Integer.parseInt(null);
     

    выдает NumberFormatException, а не исключение NullPointerException.

    ответ дан Pavel Molchanov, с репутацией 1074, 20.06.2018
  • 1 рейтинг

    Можно выполнить 5 способов:

     import com.google.common.primitives.Ints;
    import org.apache.commons.lang.math.NumberUtils;
     

    1) Использование Ints.tryParse :

     String number = "999";
    int result = Ints.tryParse(number);
     

    2) Используя NumberUtils.createInteger :

     String number = "999";
    Integer result = NumberUtils.createInteger(number);
     

    3) Используя NumberUtils.toInt :

     String number = "999";
    int result = NumberUtils.toInt(number);
     

    4) Использование Integer.valueOf :

     String number = "999";
    Integer result = Integer.valueOf(number);
     

    5) Используя Integer.parseInt :

     String number = "999";
    int result = Integer.parseInt(number);
     
    ответ дан Santosh Jadi, с репутацией 518, 12.09.2018
  • 1 рейтинг

    public static int parseInt (String s) выбрасывает NumberFormatException

    вы можете использовать Integer.parseInt() для преобразования строки в int.

    преобразовать String 20 в примитив int.

         String n = "20";
        int r = Integer.parseInt(n);//returns a primitive int       
        System.out.println(r);
     

    Выход-20

    если строка не содержит целочисленное целое число. он бросит NumberFormatException

     String n = "20I";// throwns NumberFormatException
    int r = Integer.parseInt(n);
    System.out.println(r);
     

    public static Integer valueOf (String s) выбрасывает NumberFormatException

    вы можете использовать Integer.valueOf() , в этом он вернет объект Integer.

     String n = "20";
    Integer r = Integer.valueOf(n); //returns a new Integer() object.   
    System.out.println(r);
     

    Выход-20

    Ссылки https://docs.oracle.com/ru/

    ответ дан Poorna Senani Gamage, с репутацией 730, 27.07.2018
  • 0 рейтинг

    Используйте Integer.parseInt() , это поможет вам разобрать значение строки в int.

    Пример:

     String str = "2017";
    int i = Integer.parseInt(str);
    System.out.println(i);
     

    выход: 2017

    ответ дан Alekya, с репутацией 112, 22.08.2018
  • 0 рейтинг

    Попробуйте этот код с различными входами String

             String a="10" , String a="10ssda" , String a=null; String a="12102    "
    
            if(null!=a){
            try{
             int x= Integer.ParseInt(a.trim()); 
             Integer y= Integer.valueOf(a.trim());
            //  It will throw a NumberFormatException in case of invalid string like ("10ssda" or "123 212") so, put this code into try catch
            }catch(NumberFormatException ex){
              // ex.getMessage();
            }
            }
     
    ответ дан Ram Chhabra, с репутацией 17, 7.09.2018
  • -4 рейтинг

    Кроме того, вы можете использовать Integer.valueOf (). Он вернет объект Integer .

     String numberStringFormat = "10";
    Integer resultIntFormat = Integer.valueOf(numberStringFormat);
    LOG.info("result:"+result);
     

    Вывод:

    10

    ответ дан KIBOU Hassan, с репутацией 159, 28.04.2017