Бинарное представление чисел java

Двоичные числа в Java

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

1. введение

Двоичная система счисления использует 0 и 1 для представления чисел. Компьютеры используют двоичные числа для хранения и выполнения операций с любыми данными.

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

2. Двоичный литерал

Java 7 представила двоичный литерал. Это упростило использование двоичных чисел.

Чтобы использовать его, нам нужно поставить перед номером префикс 0B или 0b:

@Test public void given_binaryLiteral_thenReturnDecimalValue()

3. Преобразование Двоичных Чисел

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

3.1. Десятичное или двоичное число

Целое число имеет функцию с именем в двоичную строку для преобразования десятичного числа в его двоичную строку:

@Test public void given_decimalNumber_then_convertToBinaryNumber()

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

Чтобы преобразовать десятичное число n в двоичный формат, нам нужно:

1. Разделите n на 2, отметив частное q и остаток r
2. Разделите q на 2, отметив его частное и остаток
3. Повторяйте шаг 2, пока мы не получим 0 в качестве частного
4. Объедините в обратном порядке все остатки

Давайте рассмотрим пример преобразования 6 в эквивалент двоичного формата:

1. Сначала разделите 6 на 2: частное 3, остаток 0
2. Затем разделите 3 на 2: частное 1, остаток 1
3. И, наконец, разделите 1 на 2: частное 0, остаток 1
4. 110

Давайте теперь реализуем приведенный выше алгоритм:

public Integer convertDecimalToBinary(Integer decimalNumber) < if (decimalNumber == 0) < return decimalNumber; >StringBuilder binaryNumber = new StringBuilder(); Integer quotient = decimalNumber; while (quotient > 0) < int remainder = quotient % 2; binaryNumber.append(remainder); quotient /= 2; >binaryNumber = binaryNumber.reverse(); return Integer.valueOf(binaryNumber.toString()); >

3.2. Двоичное или десятичное число

Для анализа двоичной строки класс Integer предоставляет функцию parseInt :

@Test public void given_binaryNumber_then_ConvertToDecimalNumber()

Здесь функция parseInt принимает в качестве входных данных два параметра:

1. Двоичная строка, подлежащая преобразованию
2. Основание или основание системы счисления, в которой должна быть преобразована входная строка

Теперь давайте попробуем написать вашу собственную логику преобразования двоичного числа в десятичное:

1. Начните с крайней правой цифры
2. Умножьте каждую цифру на 2^ этой цифры – здесь положение самой правой цифры равно нулю, и оно увеличивается по мере того, как мы перемещаемся в левую сторону
3. Добавьте результат всех умножений, чтобы получить конечное десятичное число

Еще раз, давайте посмотрим на наш метод в действии:

1. Первый, 101011 = (1*2^5) + (0*2^4) + (1*2^3) + (0*2^2) + (1*2^1) + (1*2^0)
2. Следующий, 101011 = (1*32) + (0*16) + (1*8) + (0*4) + (1*2) + (1*1)
3. Тогда, + 0 + 8 + 0 + 2 + 1
4. И, наконец,,

Давайте, наконец, закодируем описанные выше шаги:

public Integer convertBinaryToDecimal(Integer binaryNumber) < Integer decimalNumber = 0; Integer base = 1; while (binaryNumber >0) < int lastDigit = binaryNumber % 10; binaryNumber = binaryNumber / 10; decimalNumber += lastDigit * base; base = base * 2; >return decimalNumber; >

4. Арифметические операции

В этом разделе мы сосредоточимся на выполнении арифметических операций с двоичными числами.

4.1. Дополнение

Точно так же, как при сложении десятичных чисел, мы начинаем добавлять числа с самой правой цифры.

При добавлении двух двоичных цифр нам нужно помнить следующие правила:

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

public Integer addBinaryNumber(Integer firstNum, Integer secondNum) < StringBuilder output = new StringBuilder(); int carry = 0; int temp; while (firstNum != 0 || secondNum != 0) < temp = (firstNum % 10 + secondNum % 10 + carry) % 2; output.append(temp); carry = (firstNum % 10 + secondNum % 10 + carry) / 2; firstNum = firstNum / 10; secondNum = secondNum / 10; >if (carry != 0) < output.append(carry); >return Integer.valueOf(output.reverse().toString()); >

4.2. Вычитание

Существует множество способов вычитания двоичных чисел. В этом разделе мы изучим метод дополнения для выполнения вычитания.

Давайте сначала поймем, что является дополнением к числу.

Чье-либо дополнение к числу-это число, полученное путем отрицания каждой цифры двоичного числа. Это означает, что просто замените 1 на 0 и 0 на 1 :

public Integer getOnesComplement(Integer num) < StringBuilder onesComplement = new StringBuilder(); while (num >0) < int lastDigit = num % 10; if (lastDigit == 0) < onesComplement.append(1); >else < onesComplement.append(0); >num = num / 10; > return Integer.valueOf(onesComplement.reverse().toString()); >

Чтобы выполнить вычитание двух двоичных чисел с использованием дополнения, нам нужно:

1. Вычислите дополнение единицы к подзаголовку s
2. Добавить s и дополнить
3. Если перенос создается на шаге 2, добавьте этот перенос в результат шага 2, чтобы получить окончательный ответ.
4. Если перенос не генерируется на шаге 2, то дополнение к результату шага 2 является окончательным ответом. Но в данном случае ответ отрицательный

Давайте выполним описанные выше шаги:

public Integer substractBinaryNumber(Integer firstNum, Integer secondNum) < int onesComplement = Integer.valueOf(getOnesComplement(secondNum)); StringBuilder output = new StringBuilder(); int carry = 0; int temp; while (firstNum != 0 || onesComplement != 0) < temp = (firstNum % 10 + onesComplement % 10 + carry) % 2; output.append(temp); carry = (firstNum % 10 + onesComplement % 10 + carry) / 2; firstNum = firstNum / 10; onesComplement = onesComplement / 10; >String additionOfFirstNumAndOnesComplement = output.reverse().toString(); if (carry == 1) < return addBinaryNumber(Integer.valueOf(additionOfFirstNumAndOnesComplement), carry); >else < return getOnesComplement(Integer.valueOf(additionOfFirstNumAndOnesComplement)); >>

5. Заключение

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

Полный код, используемый в этой статье, доступен на GitHub .

Источник

Преобразовать число в двоичное в Java

В этом посте мы обсудим, как преобразовать число в двоичное в Java.

1. Использование встроенных методов

Стандартным решением для преобразования числа в двоичное в Java является использование Integer.toBinaryString() метод, который возвращает двоичное представление указанного целого числа в строковом формате.

результат:

1001011

Точно так же вы можете преобразовать длинное значение, используя Long.toBinaryString() метод.

результат:

1001011

В качестве альтернативы вы можете использовать toString(i, r) метод, который возвращает строковое представление i в основе r . Однако это не работает так, как предполагалось для отрицательных чисел.

результат:

1001011

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

2. Наивное решение

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

результат:

00000000000000000000000001001011

Вот рекурсивная версия приведенного выше кода:

результат:

00000000000000000000000001001011

Вот и все о преобразовании числа в двоичное в Java.

Средний рейтинг 4.5 /5. Подсчет голосов: 8

Голосов пока нет! Будьте первым, кто оценит этот пост.

Сожалеем, что этот пост не оказался для вас полезным!

Расскажите, как мы можем улучшить этот пост?

Спасибо за чтение.

Пожалуйста, используйте наш онлайн-компилятор размещать код в комментариях, используя C, C++, Java, Python, JavaScript, C#, PHP и многие другие популярные языки программирования.

Как мы? Порекомендуйте нас своим друзьям и помогите нам расти. Удачного кодирования 🙂

Этот веб-сайт использует файлы cookie. Используя этот сайт, вы соглашаетесь с использованием файлов cookie, нашей политикой, условиями авторского права и другими условиями. Читайте наши Политика конфиденциальности. Понятно

Источник

Binary Literals

In Java SE 7, the integral types ( byte , short , int , and long ) can also be expressed using the binary number system. To specify a binary literal, add the prefix 0b or 0B to the number. The following examples show binary literals:

// An 8-bit 'byte' value: byte aByte = (byte)0b00100001; // A 16-bit 'short' value: short aShort = (short)0b1010000101000101; // Some 32-bit 'int' values: int anInt1 = 0b10100001010001011010000101000101; int anInt2 = 0b101; int anInt3 = 0B101; // The B can be upper or lower case. // A 64-bit 'long' value. Note the "L" suffix: long aLong = 0b1010000101000101101000010100010110100001010001011010000101000101L;

Binary literals can make relationships among data more apparent than they would be in hexadecimal or octal. For example, each successive number in the following array is rotated by one bit:

public static final int[] phases =

In hexadecimal, the relationship among the numbers is not readily apparent:

public static final int[] phases =

You can use binary integral constants in code that you can verify against a specifications document, such as a simulator for a hypothetical 8-bit microprocessor:

public State decodeInstruction(int instruction, State state) < if ((instruction & 0b11100000) == 0b00000000) < final int register = instruction & 0b00001111; switch (instruction & 0b11110000) < case 0b00000000: return state.nop(); case 0b00010000: return state.copyAccumTo(register); case 0b00100000: return state.addToAccum(register); case 0b00110000: return state.subFromAccum(register); case 0b01000000: return state.multiplyAccumBy(register); case 0b01010000: return state.divideAccumBy(register); case 0b01100000: return state.setAccumFrom(register); case 0b01110000: return state.returnFromCall(); default: throw new IllegalArgumentException(); >> else < final int address = instruction & 0b00011111; switch (instruction & 0b11100000) < case 0b00100000: return state.jumpTo(address); case 0b01000000: return state.jumpIfAccumZeroTo(address); case 0b01000000: return state.jumpIfAccumNonzeroTo(address); case 0b01100000: return state.setAccumFromMemory(address); case 0b10100000: return state.writeAccumToMemory(address); case 0b11000000: return state.callTo(address); default: throw new IllegalArgumentException(); >> >

You can use binary literals to make a bitmap more readable:

public static final short[] HAPPY_FACE =

Источник