Binaire getallen in Java

1. Inleiding

Het binaire getallensysteem gebruikt nullen en enen om getallen weer te geven. Computers gebruiken binaire getallen om gegevens op te slaan en uit te voeren.

In deze zelfstudie leren we hoe u binair naar decimaal converteert en vice versa. We zullen er ook optellen en aftrekken op uitvoeren.

2. Binair Letterlijk

Java 7 introduceerde de binaire letterlijke. Het vereenvoudigde het gebruik van binaire getallen.

Om het te gebruiken, moeten we het nummer voorvoegsel met 0B of 0b:

@Test openbare ongeldig gegeven_binaryLiteral_thenReturnDecimalValue () {byte vijf = 0b101; assertEquals ((byte) 5, vijf); korte drie = 0b11; assertEquals ((short) 3, three); int negen = 0B1001; assertEquals (9, negen); lange twintigNegen = 0B11101; assertEquals (29, twintigNegen); int minusThirtySeven = -0B100101; assertEquals (-37, minusThirtySeven); }

3. Conversie van binaire getallen

In dit gedeelte leren we hoe u een binair getal converteert naar het decimale formaat en vice versa. Hier gebruiken we eerst een ingebouwde Java-functie voor conversie, en daarna zullen we onze aangepaste methoden hiervoor schrijven.

3.1. Decimaal naar een binair getal

Geheel getal heeft een functie met de naam toBinaryString om een ​​decimaal getal om te zetten in zijn binaire reeks:

@Test openbare ongeldig gegeven_decimalNumber_then_convertToBinaryNumber () {assertEquals ("1000", Integer.toBinaryString (8)); assertEquals ("10100", Integer.toBinaryString (20)); }

Nu kunnen we proberen onze eigen logica voor deze conversie te schrijven. Laten we, voordat we de code schrijven, eerst begrijpen hoe we een decimaal getal naar een binair getal kunnen converteren.

Om een ​​decimaal getal te converteren n in het binaire formaat, moeten we:

  1. Verdelen n door 2, met vermelding van het quotiënt q en de rest r
  2. Verdelen q door 2, met vermelding van het quotiënt en de rest
  3. Herhaal stap 2 totdat we 0 als quotiënt krijgen
  4. Voeg alle restanten in omgekeerde volgorde samen

Laten we een voorbeeld bekijken van het converteren van 6 naar het equivalent in binaire indeling:

  1. Deel eerst 6 door 2: quotiënt 3, rest 0
  2. Verdeel vervolgens 3 door 2: quotiënt 1, rest 1
  3. En tot slot, deel 1 door 2: quotiënt 0, rest 1
  4. 110

Laten we nu het bovenstaande algoritme implementeren:

openbaar geheel getal convertDecimalToBinary (geheel getal decimalNumber) {if (decimalNumber == 0) {return decimalNumber; } StringBuilder binaryNumber = nieuwe StringBuilder (); Geheel getal quotiënt = decimaalGetal; while (quotiënt> 0) {int rest = quotiënt% 2; binaryNumber.append (rest); quotiënt / = 2; } binaryNumber = binaryNumber.reverse (); retourneer Integer.valueOf (binaryNumber.toString ()); }

3.2. Binair naar een decimaal getal

Om een ​​binaire string te ontleden, de Geheel getal klasse biedt een parseInt functie:

@Test openbare ongeldig gegeven_binaryNumber_then_ConvertToDecimalNumber () {assertEquals (8, Integer.parseInt ("1000", 2)); assertEquals (20, Integer.parseInt ("10100", 2)); }

Hier de parseInt functie heeft twee parameters als invoer:

  1. Binaire tekenreeks die moet worden geconverteerd
  2. Radix of basis van het getallensysteem waarin de invoerstring moet worden geconverteerd

Laten we nu proberen onze eigen logica te schrijven om een ​​binair getal in een decimaal getal om te zetten:

  1. Begin met het meest rechtse cijfer
  2. Vermenigvuldig elk cijfer met 2 ^ {positie} van dat cijfer - hier is de positie van het meest rechtse cijfer nul en wordt het groter naarmate we naar de linkerkant gaan
  3. Tel het resultaat van alle vermenigvuldigingen op om het laatste decimale getal te krijgen

Nogmaals, laten we onze methode in actie zien:

  1. Ten eerste 101011 = (1 * 2 ^ 5) + (0 * 2 ^ 4) + (1 * 2 ^ 3) + (0 * 2 ^ 2) + (1 * 2 ^ 1) + (1 * 2 ^ 0 )
  2. Vervolgens 101011 = (1 * 32) + (0 * 16) + (1 * 8) + (0 * 4) + (1 * 2) + (1 * 1)
  3. Dan is 101011 = 32 + 0 + 8 + 0 + 2 + 1
  4. En tot slot 101011 = 43

Laten we eindelijk de bovenstaande stappen coderen:

public Integer convertBinaryToDecimal (Integer binaryNumber) {Integer decimalNumber = 0; Geheel getal base = 1; while (binaryNumber> 0) {int lastDigit = binaryNumber% 10; binaryNumber = binaryNumber / 10; decimalNumber + = lastDigit * base; basis = basis * 2; } return decimalNumber; }

4. Rekenkundige bewerkingen

In dit gedeelte concentreren we ons op het uitvoeren van rekenkundige bewerkingen op binaire getallen.

4.1. Toevoeging

Net als bij het optellen van decimalen, beginnen we met het optellen van de getallen vanaf het meest rechtse cijfer.

Bij het toevoegen van twee binaire cijfers moeten we de volgende regels onthouden:

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

Deze regels kunnen worden geïmplementeerd als:

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. Aftrekken

Er zijn veel manieren om binaire getallen af ​​te trekken. In dit gedeelte zullen we de complementmethode van een persoon leren om aftrekken uit te voeren.

Laten we eerst begrijpen wat iemands aanvulling op een getal is.

Iemands complement van een getal is een getal verkregen door waarbij elk cijfer van het binaire getal wordt ontkend. Dat betekent dat je 1 vervangt door 0 en 0 door 1:

public Integer getOnesComplement (Integer num) {StringBuilder onesComplement = nieuwe StringBuilder (); while (num> 0) {int lastDigit = num% 10; if (lastDigit == 0) {onesComplement.append (1); } else {onesComplement.append (0); } num = num / 10; } retourneer Integer.valueOf (onesComplement.reverse (). toString ()); }

Om twee binaire getallen af ​​te trekken met een complement, moeten we:

  1. Bereken het eigen complement van de aftrekker s
  2. Toevoegen s en het menu
  3. Als er een carry wordt gegenereerd in stap 2, voegt u die carry toe aan het resultaat van stap 2 om het definitieve antwoord te krijgen.
  4. Als er in stap 2 geen carry wordt gegenereerd, is het complement van het resultaat van stap 2 het laatste antwoord. Maar in dit geval is het antwoord negatief

Laten we de bovenstaande stappen implementeren:

public Integer substractBinaryNumber (Integer firstNum, Integer secondNum) {int onesComplement = Integer.valueOf (getOnesComplement (secondNum)); StringBuilder output = nieuwe 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. Conclusie

In dit artikel hebben we geleerd hoe je binaire getallen omzet in decimalen en vice versa. Vervolgens hebben we rekenkundige bewerkingen uitgevoerd, zoals optellen en aftrekken op binaire getallen.

De volledige code die in dit artikel wordt gebruikt, is beschikbaar op GitHub.