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

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

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

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

2585
int java string type-conversion

30 ответов

String myString = "1234";
int foo = Integer.parseInt(myString);

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

3629

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

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

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

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

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

606

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

сделать это вручную:

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

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

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

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

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

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

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

Apache NumberUtils API версии 3.4

36

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

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

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

23

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

  • строка содержит только числа 0-9?
  • что с -/+ до или после строки? Возможно ли это (ссылаясь на бухгалтерские номера)?
  • что с MAX_-/MIN_INFINITY? что произойдет, если строка 9999999999999999999999? Может машина обработать это строки как int?
21

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

например:

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

на Integer класс также предоставляет valueOf(String str) способ:

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

мы также можем использовать toInt(String strValue) of Служебный Класс NumberUtils для преобразования:

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

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

18

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

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

 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)

целое число.valueOf производит целочисленный объект, все остальные методы-примитивный int.

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

17

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

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

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

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

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

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

12

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

    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

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

9

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

  • Option #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;
}

  • Option #2: сбросьте затронутую переменную, если поток выполнения может продолжаться в случае исключения. Например, с некоторыми изменениями в блоке catch

    catch (NumberFormatException ex) {
    integerValue = 0;
}

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

8

как уже упоминалось Apache Commons NumberUtils можете сделать это. Какой возврат 0 если он не может преобразовать string в 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

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

  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() перед дальнейшей обработкой.

8

просто вы можете попробовать это:

  • использовать Integer.parseInt(your_string); преобразование String to int
  • использовать Double.parseDouble(your_string); преобразование String to 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

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

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

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

Integer.parseInt(myBuilderOrBuffer.toString());
6
int foo=Integer.parseInt("1234");

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

6

поехали

String str="1234";
int number = Integer.parseInt(str);
print number;//1234
6

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

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

В Java 8 - Целое Число(Строка).

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

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

public Integer(String var1) throws NumberFormatException {
    this.value = parseInt(var1, 10);
}
6

один метод 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

Использовать Целое Число.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

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

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

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

int i = Integer.parseInt(null);

выбрасывает NumberFormatException, а не NullPointerException.

3