Тип данных integer

Методы преобразования

4.1. Преобразование Между Примитивными Типами

Простой способ преобразования примитивов, чтобы избежать преобразования с потерями,-это понижение; другими словами, приведение типа большего размера к типу меньшего размера. Следовательно, это также называется сужением примитивного преобразования.

Например, давайте преобразуем длинное число в короткое с помощью понижающей передачи

long longNum = 24;
short shortNum = (short) longNum;
assertEquals(24, shortNum);

Аналогично, давайте преобразуем double в int :

double doubleNum = 15.6;
int integerNum = (int) doubleNum;
assertEquals(15, integerNum);

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

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

long largeLongNum = 32768; 
short minShortNum = (short) largeLongNum;
assertEquals(-32768, minShortNum);

long smallLongNum = -32769;
short maxShortNum = (short) smallLongNum;
assertEquals(32767, maxShortNum);

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

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

Давайте разберемся в этом на примерах. Когда большое длинное число со значением 32768 преобразуется в короткое , значение короткое число 1 равно -32768 . Поскольку максимальное значение short равно 32767, поэтому Java переходит к следующему минимальному значению short.

Аналогично, когда маленькое длинное число преобразуется в короткое . Значение short Num2 равно 32767, поскольку Java переходит к следующему максимальному значению short .

Кроме того, давайте посмотрим, что произойдет, когда мы преобразуем максимальные и минимальные значения a long в int :

long maxLong = Long.MAX_VALUE; 
int minInt = (int) maxLong;
assertEquals(-1, minInt);

long minLong = Long.MIN_VALUE;
int maxInt = (int) minLong;
assertEquals(0, maxInt);

4.2. Преобразование между объектами-оболочками и примитивными типами

Чтобы напрямую преобразовать объект-оболочку в примитив, мы можем использовать различные методы в классах-оболочках, такие как int Value () , shortValue() и longValue() . Это называется распаковка .

Например, давайте преобразуем объект Float в объект long :

Float floatNum = 17.564f;
long longNum = floatNum.longValue();
assertEquals(17, longNum);

Кроме того, если мы посмотрим на реализацию long Value или аналогичных методов, мы найдем применение сужающего примитивного преобразования:

public long longValue() {
    return (long) value;
}

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

Double doubleNum = 15.9999;
long longNum = doubleNum.longValue();
assertEquals(15, longNum);

После преобразования значение long Num будет равно 15. Однако двойное число равно 15.9999, что очень близко к 16.

Вместо этого мы можем использовать Math.round() для преобразования в ближайшее целое число:

Double doubleNum = 15.9999;
long longNum = Math.round(doubleNum);

assertEquals(16, longNum);

4.3. Преобразование Между Объектами-Оболочками

Для этого давайте воспользуемся уже рассмотренными методами преобразования.

Сначала мы преобразуем объект-оболочку в примитивное значение, опустим его и преобразуем в другой объект-оболочку . Другими словами, мы будем выполнять техники распаковки, даункастинга и бокса.

Например, давайте преобразуем объект Double в объект Integer :

Double doubleNum = 10.3;
double dbl = doubleNum.doubleValue(); // unboxing
int intgr = (int) dbl; // downcasting
Integer intNum = Integer.valueOf(intgr);
assertEquals(Integer.valueOf(10), intNum);

Наконец, мы используем Integer . valueOf() для преобразования примитивного типа int в Целое число объект. Этот тип преобразования называется boxing .

Создайте функцию для преобразования числа в двоичное в JavaScript

Прежде чем перейти к коду, нам нужно знать процесс преобразования десятичного числа (основание 10) в двоичное число (основание 2). Для простоты в этой статье мы рассмотрим преобразование положительных целых чисел. Следовательно, изменение отрицательных целых чисел и чисел с плавающей запятой выходит за рамки этой статьи.

Понять процесс преобразования

Учитывая целое число (или число JavaScript), мы продолжаем делить число на два и фиксировать его остаток до тех пор, пока число не станет меньше 2. Например, если у нас есть число 25, продолжайте делить на , пока не получим частное меньше 2.

Делитель	Частное	Остаток	Биты
25⁄₂	12	1
12⁄₂	6	1
6⁄₂	3	2
3⁄₂	1	1	3
1⁄₂	1	4

Читаем цифры от старшего к младшему. Следовательно, двоичное значение числа 25 — 1101.

Мы используем следующий набор вычислений, чтобы убедиться, что двоичное значение представляет правильное десятичное число. Каждый бит, представленный в двоичном числе, умножается на , чтобы получить значение позиции бита (начиная с 0).

Код JavaScript для преобразования числа в двоичный формат

Мы создаем следующий код на основе описанного выше метода. Функция консоляет двоичный эквивалент десятичного числа, переданного в качестве параметра

Обратите внимание, что мы читаем результат задом наперед. Следовательно, код был создан с учетом всех вышеупомянутых факторов

Шаги

На каждой итерации мы делим число на , чтобы получить частное. Мы вычисляем модульность частного. Этот шаг генерирует двоичные биты, поскольку модульность числа с 2 генерирует двоичные биты или .
Как только число больше не делится на (проверено с условием (num / 2)> 1), итерация останавливается.

Использование рекурсии

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

Преобразование числа в двоичное с помощью функции

Функция хорошо знакома для преобразования числа в строку. Но мы также можем использовать его для преобразования числа в его двоичный формат. Обычно он используется с объектом для преобразования числа в двоичный формат. Функция javascript при использовании с числовым объектом возвращает двоичный эквивалент числового значения, как показано в примерах ниже. В качестве входных данных метод принимает значение системы счисления. Следовательно, мы можем использовать его для преобразования данного числа в другие базовые системы (например, основание 16 (шестнадцатеричное) и основание восьми (восьмеричное)).

Обратите внимание, что тип возврата метода остается строкой. Следовательно, он преобразует число в двоичный бит в строковом формате

Форматирование числа в JavaScript

17 ответов

Предполагая, что вы имеете в виду «встроенный»:

(У Long есть похожий метод, у BigInteger есть метод экземпляра, где вы можете указать основание.)

Здесь нет необходимости зависеть только от двоичного или любого другого формата . доступна одна гибкая встроенная функция, которая печатает любой формат, который вы хотите в вашей программе .. Integer.toString (int, presentation);

Мне нужно было что-то, чтобы красиво распечатать вещи и разделить биты каждый n-бит. Другими словами, отобразить начальные нули и показать что-то вроде этого:

Итак, вот что я написал:

Вызовите это так:

проверить эту логику можно преобразовать число в любую базу

ИЛИ ЖЕ

Это самый простой способ печати внутреннего двоичного представления целого числа. Например : если мы возьмем n как 17, то результат будет: 0000 0000 0000 0000 0000 0001 0001

Здесь уже есть хорошие ответы на этот вопрос. Но я попробовал именно так (и, может быть, это самая простая логика на основе → по модулю / делить / добавить ):

Вопрос сложен в Java (и, вероятно, также на другом языке).

Integer — это 32-разрядный тип данных со знаком, но Integer.toBinaryString () возвращает строковое представление целочисленного аргумента в виде целого числа без знака в базе 2.

Таким образом, Integer.parseInt (Integer.toBinaryString (X), 2) может генерировать исключение (со знаком или без знака).

Безопасный способ — использовать Integer.toString (X, 2); это создаст что-то менее элегантное:

Но это работает .

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

convertNumber (1) -> «0b1»

convertNumber (5) -> «0b101»

convertNumber (117) -> «0b1110101»

Как это работает: while-цикл перемещает число вправо (заменяя последний бит на второй-последний и т. Д.), Получает значение последнего бита и помещает его в StringBuilder, повторяет до тех пор, пока не останется ни одного бита (вот когда а = 0).

Site about Java

16 Четверг Янв 2014

Java из двоичной системы в десятичную и обратно

Раньше, чтобы переводить числа из одной системы счисления в другую я писал методы с циклами и т.п. Нужно делать так:

Вывод на консоль: 11101000 232

Также есть перевод в восьмиричную систему ( метод toOctalString) и шестнадцатиричную ( метод toHexString)

5 thoughts on “Java из двоичной системы в десятичную и обратно”

Duke Nukem said:

можно запулить одномерный динамичексий массив строковых двоичных типа: String massive[] = new значений и из него доставать так же как ты щас замутил через принт, ток массив(переменная со значением).

Duke Nukem said:

хотя чет я о своем, заработался. у тебя эффективнее с методом класса=)))

Кстати, классно что есть методы toOctalString — перевод в восьмиричную систему и toHexString (шетнадцатиричная) работа с которыми абсолютна аналогична.