конвертировать данные из строки в integer / numeric [duplicate]

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

• Используйте 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

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

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

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

Integer.parseInt(myBuilderOrBuffer.toString());

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

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

NumberUtils.toInt(String str, int defaultValue)

example:

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; 

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

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

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

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

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

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

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

Используйте 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

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

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

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

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

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

Java 8 - Integer (String) .

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

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

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

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

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

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

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

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

Apache NumberUtils API Version 3.4

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

• Параметр # 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;
  }
  

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

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

    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
  }

Один из методов: 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);

Кстати, помните, что если строка равна null, вызов:

int i = Integer.parseInt(null);

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

Используйте 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);
    }
 }

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

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().

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. Unboxing:

   int val = Integer.decode("12"); 
   

2. intValue():

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

Здесь мы идем

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

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

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

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

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

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

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

Мы можем использовать метод 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);

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

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

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

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

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