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

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

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

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

2586
задан Unknown user 07 апр. '11 в 21:27
источник поделиться
38 ответов
  • 1
  • 2
String myString = "1234";
int foo = Integer.parseInt(myString);

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

3630
ответ дан Rob Hruska 07 апр. '11 в 21:29
источник поделиться

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

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

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

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

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

606
ответ дан smas 07 апр. '11 в 21:36
источник поделиться

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

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

221
ответ дан Ali Akdurak 30 апр. '13 в 9:54
источник поделиться

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

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

    //Check for negative sign; if it 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;
}
75
ответ дан Billz 11 сент. '13 в 5:08
источник поделиться

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

 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
40
ответ дан Oak 21 марта '14 в 2:51
источник поделиться

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

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

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

Apache NumberUtils API версии 3.4

36
ответ дан Ryboflavin 27 авг. '15 в 15:07
источник поделиться

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, вы можете использовать:

  • Распаковка:

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

    Integer.decode("12").intValue();
    
29
ответ дан ROMANIA_engineer 07 марта '16 в 3:42
источник поделиться

Всякий раз, когда имеется малейшая вероятность того, что данная строка не содержит целочисленного значения, вам придется обрабатывать этот частный случай. К сожалению, стандартные Java-методы Integer::parseInt и Integer::valueOf бросают a 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));

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

23
ответ дан Stefan Dollase 04 апр. '16 в 6:13
источник поделиться

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

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

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

String strValue = "12345";
Integer intValue = NumberUtils.toInt(strValue);
20
ответ дан Giridhar Kumar 20 окт. '15 в 12:51
источник поделиться

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

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

Integer.parseInt("1"); //ОК

Integer.parseInt("-1"); //ОК

Integer.parseInt("+1"); //ОК

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

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

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

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

Существует только один тип исключения: NumberFormatException

18
ответ дан Lukas Bauer 06 окт. '17 в 22:00
источник поделиться

У меня есть решение, но я не знаю, насколько он эффективен. Но он работает хорошо, и я думаю, вы могли бы его улучшить. С другой стороны, я сделал пару тестов с 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));
        }
    }
}
17
ответ дан fitorec 23 мая '14 в 18:38
источник поделиться

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

 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 и большая статья о конвертации здесь.

17
ответ дан Dmytro Shvechikov 03 окт. '17 в 22: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);
16
ответ дан Anton Balaniuc 09 нояб. '16 в 14:34
источник поделиться

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

Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null) {
  ...
}
14
ответ дан Vitalii Fedorenko 06 авг. '16 в 20:56
источник поделиться

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

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

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

12
ответ дан Thijser 20 окт. '13 в 16:11
источник поделиться

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

    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
  }
10
ответ дан nxhoaf 01 авг. '16 в 17:44
источник поделиться

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

9
ответ дан Christian Ullenboom 28 февр. '17 в 23:36
источник поделиться

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

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

    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;
    }
    
  • Для положительных и отрицательных целых чисел:

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

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

8
ответ дан Raman Sahasi 24 апр. '17 в 8:36
источник поделиться

Как уже упоминалось, Apache Commons NumberUtils может это сделать. Какой return 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; 
8
ответ дан Alireza Fattahi 26 июля '16 в 8:26
источник поделиться

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

  • Вариант № 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: Reset затронутая переменная, если поток выполнения может продолжаться в случае исключения. Например, с некоторыми изменениями в блоке catch

    catch (NumberFormatException ex) {
        integerValue = 0;
    }
    

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

8
ответ дан manikant gautam 31 дек. '16 в 8:28
источник поделиться

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

  • Используйте 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
7
ответ дан Vishal Yadav 14 сент. '17 в 22:45
источник поделиться

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

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

Для String builder и String буфера вы можете использовать:

Integer.parseInt(myBuilderOrBuffer.toString());
6
ответ дан Aditya 18 авг. '16 в 10:07
источник поделиться
int foo=Integer.parseInt("1234");

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

6
ответ дан iKing 20 апр. '16 в 12:54
источник поделиться

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

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

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

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


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

public Integer(String var1) throws NumberFormatException {
    this.value = parseInt(var1, 10);
}
6
ответ дан djm.im 23 апр. '18 в 23:49
источник поделиться

Здесь мы идем

String str="1234";
int number = Integer.parseInt(str);
print number;//1234
6
ответ дан Shivanandam Sirmarigari 20 нояб. '16 в 7:24
источник поделиться

Используйте 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);
    }
 }
5
ответ дан David 11 нояб. '17 в 4:58
источник поделиться

Один из методов: 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);
5
ответ дан Pankaj Mandale 12 авг. '17 в 17:25
источник поделиться

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

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;
     }
    }
4
ответ дан Anup Gupta 01 сент. '17 в 9:53
источник поделиться

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

int i = Integer.parseInt(null);

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

3
ответ дан Pavel Molchanov 21 июня '18 в 0:26
источник поделиться
  • 1
  • 2

Другие вопросы по меткам