streamalism.org

1. Úvod

Binárny číselný systém používa na reprezentáciu čísel 0 a 1 s. Počítače používajú na ukladanie a vykonávanie operácií s ľubovoľnými údajmi binárne čísla.

V tomto tutoriále sa dozvieme, ako prevádzať binárne hodnoty na desatinné a naopak. Tiež na nich vykonáme sčítanie a odčítanie.

2. Binárne doslovné

Java 7 predstavila binárny literál. Zjednodušilo to využitie binárneho čísla.

Aby sme ho mohli použiť, musíme pred číslo vložiť 0B alebo 0b:

@Test public void given_binaryLiteral_thenReturnDecimalValue () {bajt päť = 0b101; assertEquals ((bajt) 5, päť); krátke tri = 0b11; assertEquals ((krátke) 3, tri); int deväť = 0B1001; assertEquals (9, deväť); dlhá dvadsaťdeväť = 0B11101; assertEquals (29, dvadsaťdeväť); int mínusThirtySeven = -0B100101; assertEquals (-37, mínusThirtySeven); }

3. Konverzia binárneho čísla

V tejto časti sa dozvieme, ako previesť binárne číslo na jeho desatinný formát a naopak. Tu najskôr použijeme na prevod zabudovanú funkciu Java a potom napíšeme vlastné metódy pre rovnaké.

3.1. Desatinné miesto na binárne číslo

Celé číslo má funkciu pomenovanú toBinaryString previesť desatinné číslo na jeho binárny reťazec:

@Test public void given_decimalNumber_then_convertToBinaryNumber () {assertEquals ("1000", Integer.toBinaryString (8)); assertEquals ("10100", Integer.toBinaryString (20)); }

Teraz sa môžeme pokúsiť napísať vlastnú logiku pre túto konverziu. Pred napísaním kódu si najskôr uvedomme, ako previesť desatinné číslo na binárne.

Ak chcete previesť desatinné číslo n do jeho binárneho formátu, musíme:

1. Rozdeľte sa n o 2, berúc do úvahy kvocient q a zvyšok r
2. Rozdeľte sa q o 2, pričom treba uviesť jeho kvocient a zvyšok
3. Opakujte krok 2, kým nezískame 0 ako kvocient
4. Zreťazte v opačnom poradí všetky zvyšky

Pozrime sa na príklad prevodu 6 na ekvivalent v binárnom formáte:

1. Najskôr vydeľte 6 dvoma: kvocient 3, zvyšok 0
2. Potom rozdeľte 3 na 2: kvocient 1, zvyšok 1
3. A nakoniec vydelíme 1: 2, kvocient 0, zvyšok 1
4. 110

Poďme teraz implementovať vyššie uvedený algoritmus:

public Integer convertDecimalToBinary (Integer decimalNumber) {if (decimalNumber == 0) {return decimalNumber; } StringBuilder binaryNumber = nový StringBuilder (); Celočíselný kvocient = decimalNumber; while (kvocient> 0) {int zvyšok = kvocient% 2; binaryNumber.append (zvyšok); kvocient / = 2; } binaryNumber = binaryNumber.reverse (); return Integer.valueOf (binaryNumber.toString ()); }

3.2. Binárne na desatinné číslo

Na analýzu binárneho reťazca slúži značka Celé číslo trieda poskytuje a parseInt funkcia:

@Test public void given_binaryNumber_then_ConvertToDecimalNumber () {assertEquals (8, Integer.parseInt ("1000", 2)); assertEquals (20, Integer.parseInt ("10100", 2)); }

Tu je parseInt funkcia berie ako vstup dva parametre:

1. Binárny reťazec, ktorý sa má previesť
2. Radix alebo základňa číselného systému, na ktorý sa má prevádzať vstupný reťazec

Teraz skúsme napísať vlastnú logiku na prevod binárneho čísla na desatinné miesto:

1. Začnite od číslice úplne vpravo
2. Vynásobte každú číslicu 2 ^ {pozíciou} tejto číslice - tu je pozícia číslice úplne vpravo nulová a zvyšuje sa s pohybom na ľavú stranu
3. Sčítaním výsledku všetkých násobení získate konečné desatinné číslo

Opäť sa pozrime na našu metódu v akcii:

1. Najskôr 101011 = (1 * 2 ^ 5) + (0 * 2 ^ 4) + (1 * 2 ^ 3) + (0 * 2 ^ 2) + (1 * 2 ^ 1) + (1 * 2 ^ 0) )
2. Ďalej 101011 = (1 * 32) + (0 * 16) + (1 * 8) + (0 * 4) + (1 * 2) + (1 * 1)
3. Potom 101011 = 32 + 0 + 8 + 0 + 2 + 1
4. A nakoniec 101011 = 43

Napíšeme si konečne vyššie uvedené kroky:

public Integer convertBinaryToDecimal (Integer binaryNumber) {Integer decimalNumber = 0; Celé číslo základňa = 1; while (binaryNumber> 0) {int lastDigit = binaryNumber% 10; binaryNumber = binaryNumber / 10; decimalNumber + = lastDigit * base; základňa = základňa * 2; } vratit desatinne cislo; }

4. Aritmetické operácie

V tejto časti sa zameriame na vykonávanie aritmetických operácií s binárnymi číslami.

4.1. Dodatok

Rovnako ako sčítanie desatinných čísel začneme pridávať čísla od číslice úplne vpravo.

Pri pridávaní dvoch binárnych číslic si musíme pamätať nasledujúce pravidlá:

• 0 + 0 = 0
• 0 + 1 = 1
• 1 + 1 = 10
• 1 + 1 + 1 = 11

Tieto pravidlá možno implementovať ako:

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); } návrat Integer.valueOf (output.reverse (). toString ()); }

4.2. Odčítanie

Existuje mnoho spôsobov, ako odčítať binárne čísla. V tejto časti sa naučíme metódu komplementu človeka na odčítanie.

Poďme si najskôr uvedomiť, čo je niečím doplnkom čísla.

Doplnkom čísla je číslo získané negácia každej číslice binárneho čísla. To znamená, že stačí nahradiť 1 za 0 a 0 za 1:

verejné celé číslo getOnesComplement (celé číslo) {StringBuilder onesComplement = nový StringBuilder (); while (num> 0) {int lastDigit = num% 10; if (lastDigit == 0) {onesComplement.append (1); } else {onesComplement.append (0); } počet = počet / 10; } návrat Integer.valueOf (onesComplement.reverse (). toString ()); }

Ak chcete pomocou jedného doplnku odčítať dve binárne čísla, musíme:

1. Vypočítajte doplnok subtrahendu s
2. Pridať s a minulosť
3. Ak sa prenos vygeneruje v kroku 2, pridajte tento prenos do výsledku kroku 2 a získate konečnú odpoveď.
4. Ak prenos nie je vygenerovaný v kroku 2, je konečnou odpoveďou doplnok výsledku kroku 2. Ale v tomto prípade je odpoveď negatívna

Implementujme vyššie uvedené kroky:

public Integer substractBinaryNumber (Integer firstNum, Integer secondNum) {int onesComplement = Integer.valueOf (getOnesComplement (secondNum)); Výstup StringBuilder = nový 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; } Reťazec additionOfFirstNumAndOnesComplement = output.reverse (). ToString (); if (carry == 1) {return addBinaryNumber (Integer.valueOf (additionOfFirstNumAndOnesComplement), carry); } else {return getOnesComplement (Integer.valueOf (additionOfFirstNumAndOnesComplement)); }}

5. Záver

V tomto článku sme sa naučili, ako prevádzať binárne čísla na desatinné a naopak. Potom sme vykonali aritmetické operácie ako sčítanie a odčítanie na binárnych číslach.

Celý kód použitý v tomto článku je k dispozícii na GitHub.