Как преобразовать String
в int
?
"1234" → 1234
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)
Например, есть два способа:
Integer x = Integer.valueOf(str);
// or
int y = Integer.parseInt(str);
Между этими методами есть небольшая разница:
valueOf
возвращает новый или кэшированный экземплярjava.lang.Integer
parseInt
возвращает примитивint
.
То же самое для всех случаев: Short.valueOf
/ parseShort
, Long.valueOf
/ parseLong
и т. Д.
valueOf
просто return valueOf(parseInt(string));
Что ж, очень важный момент, который следует учитывать, заключается в том, что парсер 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.
}
Это исключение важно обрабатывать при попытке получить целочисленные значения из разделенных аргументов или при динамическом анализе чего-либо.
"([0-9]+)"
будет «захватывать» первую последовательность из одной или нескольких цифр от одной до девяти. Посмотрите на класс Matcher
в этом пакете.
Сделайте это вручную:
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;
}
Integer.parseInt(s)
? - Я вижу смысл в том, что это вопрос для собеседования, но а) это не означает, что вы должны делать это таким образом (именно это спросил вопрошающий), и б) этот ответ в любом случае является довольно плохим примером.
Альтернативным решением является использование Apache Commons ' NumberUtils:
int num = NumberUtils.toInt("1234");
Утилита Apache хороша тем, что если строка имеет недопустимый числовой формат, всегда возвращается 0. Следовательно, вы экономите блок try catch.
Apache NumberUtils API версии 3.4
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();
В настоящее время я делаю задание для колледжа, где я не могу использовать определенные выражения, такие как приведенные выше, и, глядя на таблицу 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
'0'
для символа 48
, и вам никогда не придется возиться с его фактическим числовым значением. В-третьих, весь обход со значениями double
вообще не имеет смысла, так как вы делите на десять, чтобы потом умножить на десять. Результат просто semilastdigit * 10 + lastdigit
, как учили в начальной школе, когда была введена десятичная система...
Всякий раз, когда есть малейшая вероятность того, что данная строка не содержит целого числа, вы должны обработать этот особый случай. К сожалению, стандартные методы 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
анализируется как допустимое значение, и случай, когда недопустимая строка не может быть проанализирована.
Используйте 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
Способы сделать это:
Integer.parseInt(s)
Integer.parseInt(s, radix)
Integer.parseInt(s, beginIndex, endIndex, radix)
Integer.parseUnsignedInt(s)
Integer.parseUnsignedInt(s, radix)
Integer.parseUnsignedInt(s, beginIndex, endIndex, radix)
Integer.valueOf(s)
Integer.valueOf(s, radix)
Integer.decode(s)
NumberUtils.toInt(s)
NumberUtils.toInt(s, defaultValue)
Integer.valueOf
создает объект Integer
, а все остальные методы - примитивный тип int.
Последние два метода взяты из commons-lang3 и большой статьи о преобразовании здесь.
Преобразование строки в int сложнее, чем просто преобразование числа. Вы задумались над следующими проблемами:
- Строка содержит только цифры 0–9 ?
- Что случилось с - / + до или после строки? Возможно ли это (по бухгалтерским цифрам)?
- Что случилось с MAX _- / MIN_INFINITY? Что произойдет, если строка будет 99999999999999999999? Может ли машина рассматривать эту строку как int?
Мы можем использовать метод 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);
У меня есть решение, но я не знаю, насколько оно эффективно. Но он работает хорошо, и я думаю, вы могли бы его улучшить. С другой стороны, я провел несколько тестов с 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));
}
}
}
Google Guava имеет tryParse (String), который возвращает null
, если строка не может быть проанализирована, например:
Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null) {
...
}
Помимо предыдущих ответов, я хотел бы добавить несколько функций. Вот результаты, пока вы их используете:
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;
}
Вы также можете начать с удаления всех нечисловых символов, а затем проанализировать целое число:
String mystr = mystr.replaceAll("[^\\d]", "");
int number = Integer.parseInt(mystr);
Но имейте в виду, что это работает только для неотрицательных чисел.
-42
будет проанализировано как 42
.
Как уже упоминалось, это может сделать 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;
Вы также можете использовать этот код, но с некоторыми предосторожностями.
Вариант №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; }
Использование строковой константы для сравнения или любых вычислений всегда является хорошей идеей, потому что константа никогда не возвращает нулевое значение.
Вы можете использовать new Scanner("1244").nextInt()
. Или спросите, существует ли вообще int: new Scanner("1244").hasNextInt()
Я немного удивлен, что никто не упомянул конструктор 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.
Для обычной строки вы можете использовать:
int number = Integer.parseInt("1234");
Для построителя строк и буфера строк вы можете использовать:
Integer.parseInt(myBuilderOrBuffer.toString());
Это полная программа со всеми положительными и отрицательными условиями без использования библиотеки
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
.
Вы можете использовать любое из следующего:
Integer.parseInt(s)
Integer.parseInt(s, radix)
Integer.parseInt(s, beginIndex, endIndex, radix)
Integer.parseUnsignedInt(s)
Integer.parseUnsignedInt(s, radix)
Integer.parseUnsignedInt(s, beginIndex, endIndex, radix)
Integer.valueOf(s)
Integer.valueOf(s, radix)
Integer.decode(s)
NumberUtils.toInt(s)
NumberUtils.toInt(s, defaultValue)
Используйте 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);
}
}
Это можно сделать семью способами:
import com.google.common.primitives.Ints;
import org.apache.commons.lang.math.NumberUtils;
String number = "999";
Ints.tryParse
:int result = Ints.tryParse (число);
NumberUtils.createInteger
:Целочисленный результат = NumberUtils.createInteger (число);
NumberUtils.toInt
:int result = NumberUtils.toInt (число);
Integer.valueOf
:Целочисленный результат = Integer.valueOf (число);
Integer.parseInt
:int result = Integer.parseInt (число);
Integer.decode
:int result = Integer.decode (число);
Integer.parseUnsignedInt
:int result = Integer.parseUnsignedInt (число);
int foo = Integer.parseInt("1234");
Убедитесь, что в строке нет нечисловых данных.
Один из методов - 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);
Вот так
String str = "1234";
int number = Integer.parseInt(str);
print number; // 1234
Просто вы можете попробовать это:
- Используйте
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
В соревнованиях по программированию, когда вы уверены, что число всегда будет действительным целым числом, вы можете написать свой собственный метод для анализа ввода. Это пропустит весь код, связанный с проверкой (поскольку он вам не нужен), и будет немного более эффективным.
Для действительного положительного целого числа:
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()
перед дальнейшей обработкой.
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/
Похожие вопросы
Новые вопросы
java
Java — это высокоуровневый объектно-ориентированный язык программирования. Используйте этот тег, если у вас возникли проблемы с использованием или пониманием самого языка. Этот тег часто используется вместе с другими тегами для библиотек и/или фреймворков, используемых разработчиками Java.