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

"1234"  →  1234
3401
Unknown user 7 Апр 2011 в 22:27
4
Кстати, имейте в виду, что если строка равна нулю, вызов: int i = Integer.parseInt(null); генерирует исключение NumberFormatException, а не исключение NullPointerException.
 – 
Pavel Molchanov
21 Июн 2018 в 00:26
9
Я немного удивлен, что этот вопрос должен быть так высоко оценен, когда отсутствует важная часть спецификации: что должно произойти, если строка НЕ ​​содержит только цифры? Например, многие ответы будут успешно анализировать «-1» и возвращать -1, но мы не знаем, приемлемо ли это.
 – 
Michael Kay
6 Авг 2019 в 13:29
1
В вопросе необходимо уточнить основание. Это 10, 16, 8? какие ? Может основание 7
 – 
yerlilbilgin
9 Фев 2022 в 09:20

31 ответ

Лучший ответ
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, который в сочетании с Optional в Java 8 дает мощный и лаконичный способ преобразования строки в int:

import com.google.common.primitives.Ints;

int foo = Optional.ofNullable(myString)
 .map(Ints::tryParse)
 .orElse(0)
4438
Roland 30 Дек 2021 в 16:51
41
В дополнение к перехвату NumberFormatException пользователь также должен быть осторожен с длиной строк, которые он передает; если они достаточно длинные, чтобы переполнить целое число, они могут вместо этого рассмотреть возможность использования Long::parseLong.
 – 
Allison
17 Янв 2018 в 12:37
Это работает отлично. Благодарю вас!
 – 
Ali Mamedov
13 Янв 2022 в 08:50

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

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

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

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

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

761
nanofarad 30 Июн 2015 в 23:15
86
О различиях между двумя методами см. этот вопрос
 – 
hertzsprung
19 Май 2013 в 12:38
23
Метод valueOf просто return valueOf(parseInt(string));
 – 
Paul Verest
28 Окт 2014 в 11:55

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

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

267
Peter Mortensen 17 Фев 2016 в 02:35
Как я могу разобрать "26263Hello"? Я хочу извлечь 26263 в этом случае
 – 
463035818_is_not_a_number
16 Май 2018 в 11:01
1
- См. docs.oracle.com/ javase/8/docs/api/java/util/regex/… — шаблон регулярного выражения "([0-9]+)" будет «захватывать» первую последовательность из одной или нескольких цифр от одной до девяти. Посмотрите на класс Matcher в этом пакете.
 – 
Mark Stewart
8 Июн 2018 в 19:16

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

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;
}
91
Peter Mortensen 21 Авг 2020 в 18:31
26
Что делать, если ввод больше 2^32? Что делать, если ввод содержит нечисловые символы?
 – 
yohm
22 Окт 2014 в 07:43
96
Одна из вещей, которую программист должен усвоить при приеме на работу, если не раньше, — это никогда не изобретать велосипеды. Это может быть забавным упражнением, но не ожидайте, что ваш код пройдет код-ревью, если вы делаете такие вещи в коммерческих условиях.
 – 
Dawood ibn Kareem
1 Янв 2016 в 07:16
Это особый случай; вы можете обрабатывать длинные и некоторые регулярные выражения; однако к тому времени вы можете использовать parseInt.
 – 
Billz
1 Янв 2016 в 08:18
49
-1 Извините, но это довольно плохой алгоритм с кучей ограничений, без обработки ошибок и некоторыми странными аномалиями (например, "" выдает исключение, "-" выдает 0, а "+" выдает -5). Почему кто-то выбрал это, а не Integer.parseInt(s)? - Я вижу смысл в том, что это вопрос для собеседования, но а) это не означает, что вы должны делать это таким образом (именно это спросил вопрошающий), и б) этот ответ в любом случае является довольно плохим примером.
 – 
SusanW
28 Июл 2016 в 20:27
1
-1 потому что что, если я хочу разобрать базу 31 int? Integer.parseInt(str, 31) — это один лайнер для этого. Немного шутливый комментарий, но серьезный смысл под ним. Никогда не изобретайте велосипеды, если кто-то уже выполнил работу
 – 
Nathan Adams
1 Май 2019 в 21:17

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

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

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

Apache NumberUtils API версии 3.4

64
Jonah Graham 6 Мар 2016 в 01:25
40
Вы редко хотите, чтобы 0 использовался при анализе недопустимого числа.
 – 
wnoise
22 Мар 2016 в 18:18
15
Нет, это не так. Один из них — четко определенная языковая семантика, а другой — исключение.
 – 
etherous
2 Июн 2017 в 01:25
Вы также можете указать собственное значение по умолчанию с помощью перегруженного метода NumberUtils.toInt(String, int);
 – 
Yann Vo
20 Апр 2022 в 12:31

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();
    
48
ROMANIA_engineer 7 Мар 2016 в 03:42

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

Мы делим последнюю (последнюю цифру) на 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
46
Peter Mortensen 21 Авг 2020 в 18:45
12
Непонятно, какую проблему пытается решить этот ответ, во-первых, почему у кого-либо должно быть это ограничение, которое вы описываете, во-вторых, почему вы должны смотреть на таблицу ASCII, поскольку вместо этого вы можете просто использовать '0' для символа 48, и вам никогда не придется возиться с его фактическим числовым значением. В-третьих, весь обход со значениями double вообще не имеет смысла, так как вы делите на десять, чтобы потом умножить на десять. Результат просто semilastdigit * 10 + lastdigit, как учили в начальной школе, когда была введена десятичная система...
 – 
Holger
4 Мар 2016 в 13:47

Всякий раз, когда есть малейшая вероятность того, что данная строка не содержит целого числа, вы должны обработать этот особый случай. К сожалению, стандартные методы 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 "12"
System.out.println(tryParseInteger("12").map(i -> i.toString()).orElse("invalid"));
// prints "-1"
System.out.println(tryParseInteger("-1").map(i -> i.toString()).orElse("invalid"));
// prints "invalid"
System.out.println(tryParseInteger("ab").map(i -> i.toString()).orElse("invalid"));

Хотя он все еще использует исключения для внутреннего управления потоком, код использования становится очень чистым. Кроме того, вы можете четко различить случай, когда -1 анализируется как допустимое значение, и случай, когда недопустимая строка не может быть проанализирована.

31
Stefan Dollase 12 Апр 2020 в 20:06

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

25
Peter Mortensen 3 Сен 2019 в 01:50

Способы сделать это:

  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.

Последние два метода взяты из commons-lang3 и большой статьи о преобразовании здесь.

39
Nice18 7 Фев 2022 в 21:49

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

  • Строка содержит только цифры 0–9 ?
  • Что случилось с - / + до или после строки? Возможно ли это (по бухгалтерским цифрам)?
  • Что случилось с MAX _- / MIN_INFINITY? Что произойдет, если строка будет 99999999999999999999? Может ли машина рассматривать эту строку как int?
25
Peter Mortensen 21 Авг 2020 в 18:33

Мы можем использовать метод 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);
24
Tom 17 Фев 2016 в 02:50

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

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

Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null) {
  ...
}
19
Peter Mortensen 3 Сен 2019 в 02:04

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

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;
}
13
Peter Mortensen 3 Сен 2019 в 02:06

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

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

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

20
Abhishek Chugh 24 Ноя 2019 в 19:39
20
Это приведет к тому, что -42 будет проанализировано как 42.
 – 
user289086
11 Окт 2014 в 18:00

Как уже упоминалось, это может сделать 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;
12
Peter Mortensen 3 Сен 2019 в 02:08

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

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

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

10
manikant gautam 5 Мар 2016 в 07:28

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

11
Christian Ullenboom 28 Фев 2017 в 23:36

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

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

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

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

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


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

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

Примечание 2. Он устарел : @Deprecated(since="9") - JavaDoc.

6
djm.im 28 Авг 2020 в 13:28

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

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

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

Integer.parseInt(myBuilderOrBuffer.toString());
8
Peter Mortensen 3 Сен 2019 в 02:03

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

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
Peter Mortensen 3 Сен 2019 в 01:53
2
Нет необходимости изобретать велосипед, просто используйте Integer.parseInt.
 – 
Dorian Gray
10 Ноя 2017 в 14:38
Да, мы можем сделать, но это без использования библиотеки
 – 
Anup Gupta
11 Ноя 2017 в 08:38
@TobiasWeimer, некоторым людям нужно это, как обойтись без использования библиотеки.
 – 
Anup Gupta
11 Ноя 2017 в 17:26
5
Нет, это никому не нужно, потому что это функция внутри JDK, а не какой-то сторонний плагин.
 – 
Dorian Gray
11 Ноя 2017 в 18:00

Вы можете использовать любое из следующего:

  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)
4
Peter Mortensen 21 Авг 2020 в 18:57
Это похоже является плагиатом из Ответ Дмитрия Швечикова (от 2017 г.).
 – 
Peter Mortensen
21 Авг 2020 в 18:58

Используйте 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
Peter Mortensen 22 Фев 2018 в 01:33

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

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

String number = "999";
  1. Ints.tryParse:

    int result = Ints.tryParse (число);

  2. NumberUtils.createInteger:

    Целочисленный результат = NumberUtils.createInteger (число);

  3. NumberUtils.toInt:

    int result = NumberUtils.toInt (число);

  4. Integer.valueOf:

    Целочисленный результат = Integer.valueOf (число);

  5. Integer.parseInt:

    int result = Integer.parseInt (число);

  6. Integer.decode:

    int result = Integer.decode (число);

  7. Integer.parseUnsignedInt:

    int result = Integer.parseUnsignedInt (число);

5
Santosh Jadi 11 Авг 2020 в 07:09
1
NumberUtils также обрабатывает нулевые и пустые сценарии.
 – 
Sundararaj Govindasamy
5 Фев 2019 в 19:24
int foo = Integer.parseInt("1234");

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

6
Peter Mortensen 21 Авг 2020 в 18:49
5
Это точно так же, как выбранный ответ.
 – 
Steve Smith
14 Июн 2017 в 14:15
7
Для сайта нет никакой ценности в повторении ответа, который кто-то разместил за ПЯТЬ ЛЕТ до вас.
 – 
Dawood ibn Kareem
29 Окт 2017 в 21:28
Это уже описано в принятый ответ (опубликовано около 5 лет назад).
 – 
Peter Mortensen
3 Сен 2019 в 02:08

Один из методов - 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);
4
Peter Mortensen 3 Сен 2019 в 01:56
Разве это не описано в предыдущих ответах?
 – 
Peter Mortensen
3 Сен 2019 в 01:56

Вот так

String str = "1234";
int number = Integer.parseInt(str);
print number; // 1234
6
Peter Mortensen 21 Авг 2020 в 18:50
Это уже описано в принятый ответ (опубликовано около 5 лет назад).
 – 
Peter Mortensen
3 Сен 2019 в 02:01

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

  • Используйте 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
6 revs, 5 users 58% 20 Июн 2020 в 12:12

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

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

10
2 revs, 2 users 88% 3 Сен 2019 в 01:59

public static int parseInt(String s) генерирует исключение NumberFormatException

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

Преобразуйте строку "20" в примитивное целое число:

String n = "20";
int r = Integer.parseInt(n); // Returns a primitive int
System.out.println(r);

Выход-20

Если строка не содержит анализируемого целого числа, она выдаст NumberFormatException:

String n = "20I"; // Throws NumberFormatException
int r = Integer.parseInt(n);
System.out.println(r);

public static Integer valueOf(String s) генерирует исключение NumberFormatException

Вы можете использовать Integer.valueOf(). В этом случае он вернет объект Integer.

String n = "20";
Integer r = Integer.valueOf(n); // Returns a new Integer() object.
System.out.println(r);

Выход-20

Использованная литература https://docs.oracle.com/en/

2
Peter Mortensen 3 Сен 2019 в 01:46