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

Question

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

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

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

Answer 1

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

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

Answer 2

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

Answer 3

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

Answer 4

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

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

Answer 5

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

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

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

Answer 6

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

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

Answer 7

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

• Опция # 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;
  }
  

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

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

Answer 9

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

Answer 10

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

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