Java число в строку — конвертировать, преобразовать, пример
В Java число в строку перевести можно несколькими способами:
1) классика:
int aInt = 1; String aString = Integer.toString(aInt);
2) своеобразный «хак»:
String a= 5+"";
3) Универсальный метод, который приведёт к строке и double и float и int:
String s = String.valueOf(123);
Key Words for FKN + antitotal forum (CS VSU):
- математический факультет ВГУ
- матфак ВГУ
- фкн вгу
- сообщество программистов
- Воронеж
- программирование Воронеж
- математика
- сайт о программировании
Как преобразовать строку в число java
Для преобразования строки в число в Java вы можете использовать методы parseInt() или parseDouble() из класса Integer и Double соответственно.
Для преобразования строки в целое число используйте метод parseInt():
String str = "123"; int num = Integer.parseInt(str); В этом примере мы создаем строковую переменную str , содержащую значение «123», а затем преобразуем ее в целое число, используя метод parseInt() . Результат присваиваем переменной num
Для преобразования строки в число с плавающей точкой используйте метод parseDouble() :
String str = "3.14"; double num = Double.parseDouble(str); В этом примере мы создаем строковую переменную str , содержащую значение «3.14», а затем преобразуем ее в число с плавающей точкой, используя метод parseDouble() . Результат присваиваем переменной num
Оба метода могут выбрасывать исключение NumberFormatException , если строка не может быть преобразована в число. Поэтому, при использовании этих методов следует обрабатывать возможное исключение.
Преобразование числа в строку Java [закрыт]
Закрыт. Этот вопрос необходимо уточнить или дополнить подробностями. Ответы на него в данный момент не принимаются.
Хотите улучшить этот вопрос? Добавьте больше подробностей и уточните проблему, отредактировав это сообщение.
Закрыт 1 год назад .
char * utoa_builtin_div(uint32_t value, char *buffer) < buffer += 11; // 11 байт достаточно для десятичного представления 32-х байтного числа // и завершающего нуля *--buffer = 0; do < *--buffer = value % 10 + '0'; value /= 10; >while (value != 0); return buffer; > Прошерстил сайты и не особо понял, как этот алгоритм реализовать вручную на java. Вот нашел более менее простой способ через деление на 10.Но он не для java. Тут используются побитовые сдвиги. Как мне его написать на java?
Преобразуем строки в числа в разных системах счисления
Одной из частых рутин на работе является преобразование и извлечение чисел из строк текста. Самый наивный и простой подход в языке Java при преобразовании строки в число, это использовать Double.parseDouble(String num) . Проблема этого метода в том, что он имеет баги в различных SDK, например в Android. Кроме того, данному методу не передаётся информация об основании системы счисления. Можно, конечно, использовать классы оболочки, передавая им в конструктор основание системы, но хотелось бы извлекать данную информацию из самой строки автоматически.
Исходная задача
Дана произвольная строка. Выяснить, составляет ли она какое-либо (действительное) число в определённых системах счисления. Вычислить знак числа. Выделить в строке мантиссу и экспоненту, обработать их отдельно, и перемножить друг на друга. Для простоты рассмотрим четыре системы счисления: десятичную, двоичную, восьмеричную и шестнадцатиричную.
Для каждой системы счисления, кроме десятичной определим соответствующий префикс:
У числа может быть задана экспонента. Определим три вида экспоненты, имеющие следующие префиксы:
- ‘H’ | ‘h’ : десятичная экспонента для 16-ричных чисел, поскольку буква E уже занята (является цифрой 14 в данной системе).
- ‘E’ | ‘e’ : десятичная экспонента для остальных чисел, чьё основание системы ниже 14.
- ‘P’ | ‘p’ : двоичная экспонента для всех представленных чисел.
Пишем код
Так напишем же простой метод для преобразования строки в число из соответствующей системы счисления (указанной в строке) в десятичную. Данный метод должен корректно отделять целую часть от той, что следует после запятой (точки). Обработка знака и экспоненты будет дана ниже.
public class ProcessNumber < private static final String digits = "0123456789ABCDEF"; /* Преобразует строку num в десятичное число типа double из указанного основания base Может вызвать переполнение (выход за пределы диапазона целых чисел)! */ private static double parseNumber(String num, int base)< num = num.toUpperCase(); // digits are in UPPER_CASE double val = 0; int i = 0; while(i < num.length()) // пока не кончилась строка < char c = num.charAt(i); if(c == '.') < // нашли точку '.' i++; // Переместить на следующий символ и выйти из цикла. break; >int d = digits.indexOf(c); // Индексы совпадают с числами из [0..15] if(d == -1 || d >= base) return Double.NaN; val = base * val + d; i++; > int power = 1; // вычислить лишний порядок. while(i < num.length()) < char c = num.charAt(i); int d = digits.indexOf(c); if(d == -1 || d >= base) return Double.NaN; power *= base; // увеличиваем степень порядка на единицу val = base * val + d; i++; > return val / power; > >Сейчас метод parseNumber() выполняет ровно одну задачу. Он пытается преобразовать строку num в число типа double, начиная с указанного основания base. Если обнаружен недопустимый символ в строке num, то метод вернёт специальную константу класса Double не-число (NaN — Not a Number).
Самому методу нужно передавать строку без экспоненты, знака, и префикса основания системы счисления. Их предстоит вычислить заранее. Если есть знак минус ( ‘-‘ ) то число просто умножается на минус единицу ( -1 ). Если есть экспонента, то число дополнительно умножается на неё. Прежде чем приступить к их вычислению, допустим, что нам уже известны данные компоненты. Напишем метод, который делает выбор на основе полученной информации, и выполняет соответствующее умножение преобразованного числа из заданного основания на полученную экспоненту и минус единицу, если необходимо.
public class ProcessNumber < // . parseNumber(String str, int base) < . >/* num - Число e - экспонента et - тип экспоненты base - основание системы счисления sign - знак числа (num > 0 => positive, num < 0 =>negative). esign - знак экспоненты. */ public static double parse(String num, String e, char et, int base, int sign, int esign) < if(num == null || num.length() == 0 || base < 1) // null значения =>NaN. return Double.NaN; double exp = 1; // Экспонента // Двоичная экспонента (по основанию 2) if((et == 'P' || et == 'p') && e != null && e.length() > 0) exp = Math.pow(2.0, parseNumber(e, 10)); // Десятичная экспонента (по основанию 10) else if( (et == 'E' || et == 'e' || et == 'H' || et == 'h') && e != null && e.length() > 0) exp = Math.pow(10.0, parseNumber(e, 10)); //e == null or e.length() == 0. // Указан тип экспоненты, но сама она отсутствует else if(et == 'E' || et == 'e' || et == 'H' || et == 'h' || et == 'P' || et == 'p') < return Double.NaN; >else // et is not [PpEeHh] => ignore exponent (exp == 1) (Нет экспоненты) exp = 1; if(esign < 0) exp = 1 / exp; double result = parseNumber(num, base); // Преобразовать численную часть. result = (result == Double.NaN) ? result : result * exp; if(sign < 0) result = 0 - result; //make number negative (include minus sign) return result; >>Методу parse() уже передаются вычисленные компоненты числа, а именно: само число num, его экспонента e, основание экспоненты et, основание системы самого числа base и знак числа sign. В данном методе уже предусмотрена защита от противоречивых данных (например, когда экспонента равна null, но указан её тип, или когда основание системы счисления не является натуральным числом (меньше единицы)). В простом случае, если строка равна null, то данный метод вернёт не-число (NaN). Метод выполняет простую задачу, он просто вычисляет множители итогового выражения result, и выполняет умножение преобразованных строк (экспоненты и самого числа без неё) на переменную знака sign. А вызываемый метод processNumber() переводит строку компонента в число.
Теперь остаётся написать последний метод, который вычисляет знак, экспоненту и основание системы. Ниже дан его код.
public class ProcessNumber < . // parseNumber(String num, int base) < . >// parse(String num, String exp, char etype, int base, int sign) < . >/* В отличие от parseNumber(String num, int base) автоматически вычисляет основание base, экспоненту e, и её тип, а также знак числа sign. В случае успешного вычисления, передаёт вычисленные элементы методу parse(), который делает выбор (условный переход) множителей и преобразование строковых компонент уже через parseNumber(num, base). */ public static double parseNumber(String str) < if(str == null || str.length() == 0) //null is NaN. return Double.NaN; int sign = 1; // знак числа. int esign = 1; // знак экспоненты. int base = 10; // по умолчанию основание равно 10. int i = 0; if(str.charAt(0) == '-') < // Минус ->sign < 0. sign = -1; i = 1; // перейти к следующему знаку. >if(i > 0 && i == str.length()) //str is '-' (строка состоит только из '-') return Double.NaN; // suffix '0x' => 16 (hex) if(str.charAt(i) == '0' && (i + 1 != str.length()) && str.charAt(i + 1) == 'x') < base = 16; i += 2; >//suffix '0b' => 2 (binary) else if(str.charAt(i) == '0' && (i + 1 != str.length()) && str.charAt(i + 1) == 'b') < base = 2; i += 2; >//suffix '0c' => 8 (octal) else if(str.charAt(i) == '0' && (i + 1 != str.length()) && str.charAt(i + 1) == 'c') < base = 8; i += 2; >if(i == str.length())// строки вида (-0x -0b -0c 0x 0b 0c) return Double.NaN; //Вычислить экспоненту. int idx = str.indexOf('H'); idx = (idx == -1) ? str.indexOf('h') : idx; idx = (idx == -1) ? str.indexOf('P') : idx; idx = (idx == -1) ? str.indexOf('p') : idx; idx = (idx == -1 && base != 16) ? str.indexOf('E') : idx; idx = (idx == -1 && base != 16) ? str.indexOf('e') : idx; char etype = (idx == -1) ? 'N' : str.charAt(idx); //Когда нет экспоненты (idx + 1) == 0. if(idx + 1 == str.length())// no more digits after exponent letter ('12E' or 'FFP') return Double.NaN; String exp = null; //Отрицательная экспонента, но нет цифр 'E-' or 'P-' or 'h-' if(str.charAt(idx + 1) == '-' && idx != -1 && idx + 2 == str.length()) return Double.NaN; //Отрицательная экспонента. 'E-2' or 'p-10' if(str.charAt(idx + 1) == '-' && idx != -1) < exp = str.substring(idx + 2); esign = -1; >else exp = str.substring(idx + 1); //Положительная экспонента (после idx следует цифра) idx = (idx == -1) ? str.length() : idx; //if no exponent then idx >Данный метод начинает со стандартной проверки на null-значения. Далее, если строка не null и имеет символы, то проверяется её самый первый символ. Если он имеет знак минуса ( ‘-‘ ) то множитель sign становится равен (-1). Иначе он остаётся равен 1. После вычисления знака идёт вычисление основания системы счисления по префиксу строки. После обработки префикса, снова проверяется наличие оставшейся части символов в строке. Если больше символов нет, то опять возвращается не-число (NaN). Если префикс основания отсутствует, то основание base считается равным 10. Затем вычисляется экспонента exp числа и индекс idx её начала для её последующего отделения от исходной строки. После вычисления всех компонентов, управление передаётся методу parse().
Заключение
Метод достаточно хорош, но ещё не идеален. При выходе из диапазона значений стандартных типов, можно получить неверный результат (а именно, отрицательные числа, когда как строка представляет положительное число, и наоборот). Он минует исключение NumberFormatException, возвращая не-число NaN когда обнаруживает недопустимый символ (не принадлежащий диапазону цифр в основании) а также NullPointerException, так как есть проверки на null (сводящиеся к замене null на NaN).
Следует также отметить, что самая последняя процедура processNumber(String num) имеет место уже с готовой лексемой num, лишённой лишних пробельных символов. При дублировании знака числа (минуса), результат будет снова NaN. Также, если сама экспонента NaN то и итоговое значение будет NaN. Однако процедура допускает наличие лидирующих нулей вначале числа.
Данную утилиту можно использовать только уже с коллекцией строк (цепочек), заранее выделенных из входного потока.