streamalism.org

1. Bemutatkozás

A bináris számrendszer 0-kat és 1-et használ a számok ábrázolására. A számítógépek bináris számokat használnak az adatok tárolására és végrehajtására.

Ebben az oktatóanyagban megtanuljuk, hogyan lehet konvertálni a bináris tizedessé és fordítva. Ezenkívül összeadást és kivonást hajtunk végre rajtuk.

2. Bináris Literal

A Java 7 bevezette a bináris literált. Egyszerűsítette a bináris számhasználatot.

Használatához a számot 0B vagy 0b előtaggal kell ellátnunk:

@Test public void given_binaryLiteral_thenReturnDecimalValue () {öt bájt = 0b101; assertEquals ((bájt) 5, öt); rövid három = 0b11; assertEquals ((rövid) 3, három); int kilenc = 0B1001; assertEquals (9, kilenc); hosszú húszNine = 0B11101; assertEquals (29, húszkilenc); int mínusz harminchét = -0B100101; assertEquals (-37, mínusz harminchét); }

3. Bináris számátalakítás

Ebben a szakaszban megtudhatjuk, hogyan lehet bináris számot tizedes formátumúra konvertálni, és fordítva. Itt először egy beépített Java függvényt fogunk használni az átalakításhoz, majd megírjuk az egyedi módszereket.

3.1. Tizedesjegy bináris számra

Egész szám nevű függvénye van toBinaryString hogy egy tizedes számot bináris karakterláncává alakítson:

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

Most megpróbálhatjuk megírni a saját logikánkat ehhez az átalakításhoz. A kód megírása előtt először meg kell értenünk, hogyan lehet egy tizedes számot binárisra konvertálni.

Tizedes szám konvertálása n bináris formátumába:

1. Feloszt n 2-vel, megjegyezve a hányadost q a maradék pedig r
2. Feloszt q 2-vel, megjegyezve annak hányadost és maradékot
3. Ismételje meg a 2. lépést, amíg 0-t kapunk hányadosként
4. Az összes maradék fordított sorrendben összefűzhető

Lássunk egy példát a 6 konvertálására bináris formátumú egyenértékűvé:

1. Először osszuk el a 6-ot 2-vel: a 3. hányadost, a maradékot 0
2. Ezután ossza el a 3-at 2-vel: az 1. hányados, az 1. maradék
3. És végül osszuk el az 1-et 2-vel: 0 hányados, az 1. maradék
4. 110

Most valósítsuk meg a fenti algoritmust:

public Integer convertDecimalToBinary (Integer decimalNumber) {if (decimalNumber == 0) {return decimalNumber; } StringBuilder binaryNumber = új StringBuilder (); Egész szám hányados = decimális szám; míg (hányados> 0) {int maradék =% 2 hányados; binaryNumber.append (maradék); hányados / = 2; } bináris szám = bináris szám.reverse (); return Integer.valueOf (binaryNumber.toString ()); }

3.2. Bináris tizedesjegyig

A bináris karakterlánc elemzéséhez a Egész szám osztály biztosítja a parseInt funkció:

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

Itt a parseInt függvény két paramétert vesz be bemenetként:

1. Konvertálandó bináris karakterlánc
2. Radix vagy annak a számrendszernek az alapja, amelyben a bemeneti karakterláncot át kell alakítani

Most próbáljuk meg megírni a saját logikánkat, hogy bináris számot tizedessé alakítsunk:

1. Kezdje a jobb szélső számjeggyel
2. Szorozzon meg minden számjegyet az adott számjegy 2 ^ {pozíciójával} - itt a jobb szélső számjegy nulla, és növekszik, amikor a bal oldalra lépünk
3. Adja hozzá az összes szorzás eredményét, hogy megkapja a végső tízes számot

Ismét lássuk a módszerünket:

1. Először 101011 = (1 * 2 ^ 5) + (0 * 2 ^ 4) + (1 * 2 ^ 3) + (0 * 2 ^ 2) + (1 * 2 ^ 1) + (1 * 2 ^ 0 )
2. Ezután 101011 = (1 * 32) + (0 * 16) + (1 * 8) + (0 * 4) + (1 * 2) + (1 * 1)
3. Ezután 101011 = 32 + 0 + 8 + 0 + 2 + 1
4. És végül 101011 = 43

Végül kódoljuk a fenti lépéseket:

public Integer convertBinaryToDecimal (Integer bináris szám) {Integer decimalNumber = 0; Egész bázis = 1; while (bináris szám> 0) {int lastDigit = bináris szám% 10; bináris szám = bináris szám / 10; decimalNumber + = lastDigit * alap; alap = alap * 2; } return decimalNumber; }

4. Számtani műveletek

Ebben a szakaszban a bináris számok számtani műveleteire fogunk koncentrálni.

4.1. Kiegészítés

Csakúgy, mint a tizedes szám hozzáadása, a számokat is a jobb szélső számjegytől kezdjük hozzáadni.

Két bináris számjegy hozzáadása közben emlékeznünk kell a következő szabályokra:

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

Ezeket a szabályokat a következőképpen lehet megvalósítani:

public Integer addBinaryNumber (Integer firstNum, Integer secondNum) {StringBuilder output = new StringBuilder (); int hordoz = 0; int temp; míg (firstNum! = 0 || secondNum! = 0) {temp = (firstNum% 10 + secondNum% 10 + carry)% 2; output.append (temp); hord = (elsőNum% 10 + másodpercNum% 10 + hordozás) / 2; firstNum = firstNum / 10; secondNum = secondNum / 10; } if (carry! = 0) {output.append (carry); } return Integer.valueOf (output.reverse (). toString ()); }

4.2. Kivonás

A bináris számok kivonásának számos módja van. Ebben a szakaszban megtanuljuk az ember komplement módszerét a kivonás elvégzésére.

Először értsük meg, mi a kiegészítése egy számnak.

Egy szám kiegészítése az a szám, amelyet az kapott a bináris szám minden számjegyének tagadása. Ez azt jelenti, hogy az 1-et csak 0-val, a 0-t pedig 1-gyel cserélje le:

public Integer getOnesComplement (Egész szám) {StringBuilder onesComplement = új StringBuilder (); while (num> 0) {int lastDigit = szám% 10; if (lastDigit == 0) {onesComplement.append (1); } else {onesComplement.append (0); } num = num / 10; } return Integer.valueOf (onesComplement.reverse (). toString ()); }

Két bináris szám kivonásához egy komplementer használatával:

1. Számítsa ki az altalaj kiegészítését! s
2. Hozzáadás s és a minuend
3. Ha a 2. lépésben hordozódik, akkor adja hozzá ezt a 2. lépés eredményéhez, hogy megkapja a végső választ.
4. Ha a 2. lépésben nem hoz létre hordozást, akkor a 2. lépés eredményének kiegészítése a végső válasz. De ebben az esetben a válasz nemleges

Végezzük el a fenti lépéseket:

public Integer subtractBinaryNumber (Integer firstNum, Integer secondNum) {int onesComplement = Integer.valueOf (getOnesComplement (secondNum)); StringBuilder kimenet = new StringBuilder (); int hordoz = 0; int temp; while (firstNum! = 0 || onesComplement! = 0) {temp = (firstNum% 10 + onesComplement% 10 + carry)% 2; output.append (temp); carry = (elsőNum% 10 + oneComplement% 10 + carry) / 2; firstNum = firstNum / 10; onesComplement = onesComplement / 10; } String hozzáadásaOfFirstNumAndOnesComplement = output.reverse (). ToString (); if (carry == 1) {return addBinaryNumber (Integer.valueOf (lisaksOfFirstNumAndOnesComplement), carry); } else {return getOnesComplement (Integer.valueOf (lisaksOfFirstNumAndOnesComplement)); }}

5. Következtetés

Ebben a cikkben megtanultuk, hogyan lehet bináris számokat tizedessé alakítani, és fordítva. Ezután számtani műveleteket hajtottunk végre, például összeadást és kivonást bináris számokon.

A cikkben használt teljes kód elérhető a GitHubon.