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

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

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

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

Ответ 1

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

Если вы посмотрите на Java-документацию, вы заметите, что "уловка" заключается в том, что эта функция может выдавать NumberFormatException, что, конечно, вы должны обрабатывать:

int foo;
try {
   foo = Integer.parseInt(myString);
}
catch (NumberFormatException e)
{
   foo = 0;
}

(По умолчанию для этого искаженного числа установлено значение 0, но вы можете сделать что-нибудь еще, если хотите.)

Кроме того, вы можете использовать метод Ints из библиотеки Guava, который в сочетании с Java 8 Optional обеспечивает мощный и лаконичный способ преобразования строки в тип int:

import com.google.common.primitives.Ints;

int foo = Optional.ofNullable(myString)
 .map(Ints::tryParse)
 .orElse(0)

Ответ 2

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

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

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

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

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

Ответ 3

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

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

Ответ 4

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

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

Ответ 5

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

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

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

Apache NumberUtils API версии 3.4

Ответ 6

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

Ответ 7

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

Ответ 8

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

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

Ответ 9

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

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

Ответ 10

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

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

Ответ 11

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

Ответ 12

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

Ответ 13

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

Ответ 14

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

Ответ 15

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

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

Ответ 16

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

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

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

Ответ 17

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

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

Ответ 18

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

Вариант № 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;
}
```

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

Ответ 19

Как уже упоминалось, 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;

Ответ 20

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

Ответ 21

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

Для действительного положительного целого числа:

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

Ответ 22

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

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

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

Integer.parseInt(myBuilderOrBuffer.toString());

Ответ 23

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

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

Ответ 24

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

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

Ответ 25

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

Итак, вот оно:

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

Java 8 - целое число (строка).

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

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

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

Ответ 26

Вот так

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

Ответ 27

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

Ответ 28

Это можно сделать семью способами:

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

String number = "999";

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

int result = Ints.tryParse(number);

2) Использование NumberUtils.createInteger:

Integer result = NumberUtils.createInteger(number);

3) Использование NumberUtils.toInt:

int result = NumberUtils.toInt(number);

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

Integer result = Integer.valueOf(number);

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

int result = Integer.parseInt(number);

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

int result = Integer.decode(number);

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

int result = Integer.parseUnsignedInt(number);

Ответ 29

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

Ответ 30

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

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