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


3027

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

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

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


1
Кстати, имейте в виду, что если строка является нулевой, вызов: int i = Integer.parseInt (null); генерирует NumberFormatException, а не NullPointerException.
Павел Молчанов

2
Я немного удивлен, что этот вопрос стоит так высоко оценивать, когда отсутствует важная часть спецификации: что должно произойти, если строка НЕ ​​содержит только цифры? Например, многие из ответов будут успешно разбирать «-1» и возвращать -1, но мы не знаем, приемлемо ли это.
Майкл Кей

Ответы:


4086
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)

23
В дополнение к перехвату NumberFormatException, пользователь должен также быть осторожным с длиной строк, которые они передают; если они достаточно длинные, чтобы переполнить целое число, они могут вместо этого рассмотреть возможность использования Long :: parseLong.
Эллисон

6
@Allison, особенно если используется поле BIGINT, например, в поле первичного ключа с автоматическим увеличением PostgreSQL. Гораздо безопаснее использовать долго
Летолдрус,

7
Вы можете проверить, является ли строка числом сначала: stackoverflow.com/questions/1102891/…
JPRLCol

Этот метод также выдает исключение, когда строка не является анализируемым целым числом в базе 10. Используйте перегруженный метод для работы с другими базами. например, Integer.parseInt ("1001", 8); для базы 8. Источник .
Lokesh

2
Кроме того, несмотря на то, что использование Guava в сочетании с опциональным Java 8 может быть мощным, оно, вероятно, является излишним и не таким лаконичным, как использование NumberUtils.toInt (String str, int defaultValue) из библиотеки Apache commons-lang :int foo = NumberUtils.toInt(myString, 0);
Kunda

681

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

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

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

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

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


80
Различия между этими
hertzsprung

19
valueOfМетод простоreturn valueOf(parseInt(string));
Пол Верест

@PaulVerest я не понимаю ... valueOfназывает себя рекурсивно?
idclev 463035818,

1
@ user463035818 valueOf имеет две перегрузки - для int и String. valueOf(String)Реализуется, сначала анализируя строку String с помощью int, parseInt(String)а затем оборачивая это int в целое число с помощью valueOf(int). Нет рекурсия здесь , потому что valueOf(String)и valueOf(int)две совершенно разные функции, даже если они имеют такое же имя.
PhilipRoman

244

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

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


как я могу разобрать "26263 Здравствуйте"? Я хочу извлечь 26263 в этом случае
idclev 463035818

1
@ user463035818 - См. docs.oracle.com/javase/8/docs/api/java/util/regex/… - шаблон регулярного выражения "([0-9]+)"воли «захватывает» первую последовательность из одной или нескольких цифр от одной до девяти. Посмотрите на Matcherкласс в этом пакете.
Марк Стюарт

83

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

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

22
Что если входное значение больше 2 ^ 32? Что если ввод содержит нечисловые символы?
yohm

87
Одна из вещей, которую программист должен выучить при присоединении к рабочей силе, если не раньше, - это никогда не изобретать колеса. Это может быть забавное упражнение, но не ожидайте, что ваш код пройдет проверку кода, если вы делаете это в коммерческих условиях.
Дауд ибн Карим

43
-1 Извините, но это довольно плохой алгоритм, с множеством ограничений, без обработки ошибок и некоторыми странными аномалиями (например, "" дает исключение, "-" выдаст 0, а "+" выдаст -5). Почему кто-то выбрал это Integer.parseInt(s)? - Я вижу смысл в том, что это вопрос на собеседовании, но а) это не означает, что вы сделаете это таким образом (о чем спрашивал спрашивающий), и б) этот ответ в любом случае довольно плохой пример.
SusanW,

1
-1 потому что если я захочу разобрать базу 31 int? Integer.parseInt (str, 31) - это одна строка для этого. Слегка остроумный комментарий, но под ним серьезный момент. Никогда не изобретайте колеса, когда кто-то еще вложил работу
Натан Адамс

1
Этот код выглядит так, как будто он был адаптирован из известной библиотеки для быстрого ввода-вывода в соревновательных соревнованиях по программированию. В этом контексте входные данные гарантированно действительны, а решения оцениваются по скорости. Это должно быть быстрее, чем Integer.parseInt потому что он не проверяет.
kaya3

53

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

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

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

Apache NumberUtils API версии 3.4


34
Вы редко хотите, чтобы 0 использовался при анализе неверного числа.
wnoise

4
Ноль - это то, что java использует по умолчанию, если поле int для объекта не установлено. Так что в этом отношении это имеет смысл.
Рыбофлавин

15
@Ryboflavin Нет, это не так. Одним из них является четко определенная языковая семантика, а другим - исключение
эфирное

43

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

Теперь, почему двойной? Ну, из-за действительно "странного" шага. В настоящее время у нас есть два типа double, 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 "()"

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

  • Нет повторяющихся циклов
  • Нет «магических» выражений, таких как parseInt

8
Использование типа double для анализа целого числа не только плохая идея с точки зрения производительности. Значения типа 0.2 являются периодическими числами в представлении с плавающей точкой и не могут быть точно представлены. Попробуйте System.out.println (0,1 + 0,2), чтобы увидеть смысл - результат не будет 0,3! Лучше придерживаться кода библиотеки везде, где вы можете, в этом случае Integer.parseInt ().
ChrisB

10
Непонятно, какую проблему пытается решить этот ответ, во-первых, почему у кого-то должно быть то ограничение, которое вы описываете, во-вторых, почему вы должны смотреть на таблицу ASCII, поскольку вы можете просто использовать '0'ее вместо символа 48и никогда не должны возиться с его фактическим числовым значением. В-третьих, весь обход doubleценностей не имеет никакого смысла, поскольку вы делите на десять, просто умножить на десять потом. Результат просто такой же, semilastdigit * 10 + lastdigitкак в начальной школе, когда была введена десятичная система ...
Хольгер

2
@ Holger Мне лично было дано это ограничение при первом запуске программирования, а также когда мне приходилось писать (ручку / бумагу) похожие взаимодействия в тесте. Это необычно, но это метод, который легко понять, и, несмотря на то, что он не самый эффективный из миль, это метод, который работает достаточно прилично для небольших проектов. SO.SE призван помочь всем, а не только нескольким. Я предоставил альтернативный метод для тех, кто начинает с изучения того, как создать псевдоалгоритм и превратить его в алгоритм, а не использовать готовые выражения Java. Хотя я и забыл, что «0» это круто
Дуб

2
Это не хороший ответ. Вопрос «Как преобразовать строку в int в Java?» нет, «Как мне решить эту домашнюю задачу с произвольными ограничениями?» Это StackOverflow, а не HomeworkOverflow.
DavidS

1
Вы четко объяснили причину использования этого нового подхода, так что это само по себе не является проблемой. Тем не менее, вы подчеркиваете, что ваш подход использует «отсутствие повторяющихся циклов» , однако ваш конкретный пример полностью обходит эту проблему, жестко кодируя решение (для двузначного числа), которое используется только semilastdigitи lastdigit. Как бы вы кодировали свое решение, чтобы избежать «повторяющихся циклов», если бы я предоставил вам допустимую числовую строку произвольной длины (т. Е. Любое значение между «-2147483648» и «2147483647»?)
skomisa

38

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

В заключение! Кто-то, кто действительно потрудился опубликовать результаты / вывод конверсий! Можете ли вы также добавить некоторые со знаком "-"?
not2qubit

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


24

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

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

1
Да - и есть неприятный крайний случай около -2 ^ 31. Если вы попытаетесь отрицать 2 ^ 31, вы можете столкнуться с трудностями ......
SusanW

24

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

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


22

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

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

22

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


Максимальное значение int здесь также дает NumberFormatException?
Кодирование Wombat

Нет, максимальное значение все еще в порядке
Лукас Бауэр

19

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

Вы можете сделать это проще:(int) Double.parseDouble(input.replaceAll("[^0-9\\.\\-]", ""));
Давид Хорват


17

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

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

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


18
Это приведет -42к анализу как 42.

10
Да, это работает только для неотрицательных чисел, которые правильны для начала и, следовательно, не нуждаются в этом шаге замены. В любом другом случае эта попытка автоматически исправить это усугубит ситуацию (как почти каждая попытка автоматически исправить что-то). Если я пройду "4+2", я получу 42в результате без намека на то, что то, что я пытался сделать, было неверным. У пользователя будет впечатление, что ввод базовых выражений, как это 4+2было допустимым вводом, но приложение продолжает работать с неверным значением. Кроме того, тип String, а не string...
Хольгер

Или измените первую строку на -> string mystr = mystr.replaceAll ("[^ \\ d \\ -]", "");
Апр

13

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

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

10

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

9

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

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

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


4
Ввод JOptionPane.showMessageDialog()ответа на ванильный вопрос Java не имеет смысла.
Джон Хэсколл

2
Integer.valueOf(String);не возвращает тип int.
php_coder_3809625


9

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

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


7

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

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

Этот ответ, кажется, не добавляет ничего кроме ответов, рекомендующих Integer.parseInt, опубликованный несколькими годами ранее (преобразование String в double было бы другим вопросом ).
Бернхард Баркер

7

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

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

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

Integer.parseInt(myBuilderOrBuffer.toString());

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

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


5
Это точно так же, как выбор ответа.
Стив Смит,

5
Нет смысла в том, чтобы повторять ответ, который кто-то опубликовал перед вами ПЯТЬ ЛЕТ.
Дауд ибн Карим

Это уже отражено в принятом ответе (опубликованном около 5 лет назад).
Питер Мортенсен

6

Я немного удивлен, что никто не упомянул конструктор 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);
}

5

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

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

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

NumberUtils также обрабатывает пустые и пустые сценарии.
Сундарадж Говиндасами

5

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

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

  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

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

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

2
Нет необходимости изобретать велосипед, просто используйте Integer.parseInt.
Дориан Грей,

@TobiasWeimer да, мы можем сделать, но это без использования библиотеки
Anup Gupta

@TobiasWeimer, некоторые люди нуждаются в этом, как обойтись без использования библиотеки.
Ануп Гупта

5
Нет, это никому не нужно, потому что это функция внутри JDK, а не какой-то сторонний плагин.
Дориан Грей
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.