Binärzahlen in Java

1. Einleitung

Das Binärzahlensystem verwendet Nullen und Einsen, um Zahlen darzustellen. Computer verwenden Binärzahlen, um Daten zu speichern und auszuführen.

In diesem Tutorial erfahren Sie, wie Sie Binärdateien in Dezimalzahlen konvertieren und umgekehrt. Außerdem werden wir sie addieren und subtrahieren.

2. Binäres Literal

Java 7 führte das binäre Literal ein. Es vereinfachte die Verwendung von Binärzahlen.

Um es zu verwenden, müssen wir der Zahl 0B oder 0b voranstellen:

@Test public void given_binaryLiteral_thenReturnDecimalValue() { byte five = 0b101; assertEquals((byte) 5, five); short three = 0b11; assertEquals((short) 3, three); int nine = 0B1001; assertEquals(9, nine); long twentyNine = 0B11101; assertEquals(29, twentyNine); int minusThirtySeven = -0B100101; assertEquals(-37, minusThirtySeven); }

3. Konvertierung von Binärzahlen

In diesem Abschnitt erfahren Sie, wie Sie eine Binärzahl in ihr Dezimalformat konvertieren und umgekehrt. Hier verwenden wir zuerst eine integrierte Java-Funktion für die Konvertierung und schreiben dann unsere benutzerdefinierten Methoden für dieselbe.

3.1. Dezimal zu einer Binärzahl

Integer hat eine Funktion namens toBinaryString , um eine Dezimalzahl in ihre Binärzeichenfolge umzuwandeln:

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

Jetzt können wir versuchen, unsere eigene Logik für diese Konvertierung zu schreiben. Bevor wir den Code schreiben, wollen wir zunächst verstehen, wie eine Dezimalzahl in eine Binärzahl umgewandelt wird.

Um eine Dezimalzahl n in ihr Binärformat umzuwandeln, müssen wir:

  1. Teilen Sie n durch 2 und notieren Sie den Quotienten q und den Rest r
  2. Teilen Sie q durch 2 und notieren Sie den Quotienten und den Rest
  3. Wiederholen Sie Schritt 2, bis wir 0 als Quotienten erhalten
  4. Alle Reste in umgekehrter Reihenfolge verketten

Sehen wir uns ein Beispiel für die Konvertierung von 6 in das entsprechende Binärformat an:

  1. Teilen Sie zuerst 6 durch 2: Quotient 3, Rest 0
  2. Teilen Sie dann 3 durch 2: Quotient 1, Rest 1
  3. Und schließlich teilen Sie 1 durch 2: Quotient 0, Rest 1
  4. 110

Lassen Sie uns nun den obigen Algorithmus implementieren:

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. Binär zu einer Dezimalzahl

Um eine Binärzeichenfolge zu analysieren, bietet die Integer- Klasse eine parseInt- Funktion:

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

Hier verwendet die Funktion parseInt zwei Parameter als Eingabe:

  1. Zu konvertierende Binärzeichenfolge
  2. Radix oder Basis des Zahlensystems, in das die Eingabezeichenfolge konvertiert werden muss

Versuchen wir nun, unsere eigene Logik zu schreiben, um eine Binärzahl in eine Dezimalzahl umzuwandeln:

  1. Beginnen Sie mit der Ziffer ganz rechts
  2. Multiplizieren Sie jede Ziffer mit 2 ^ {Position} dieser Ziffer - hier ist die Position der Ziffer ganz rechts Null und nimmt zu, wenn wir uns zur linken Seite bewegen
  3. Addieren Sie das Ergebnis aller Multiplikationen, um die endgültige Dezimalzahl zu erhalten

Lassen Sie uns noch einmal unsere Methode in Aktion sehen:

  1. Erstens ist 101011 = (1 * 2 ^ 5) + (0 * 2 ^ 4) + (1 * 2 ^ 3) + (0 * 2 ^ 2) + (1 * 2 ^ 1) + (1 * 2 ^ 0) )
  2. Als nächstes ist 101011 = (1 · 32) + (0 · 16) + (1 · 8) + (0 · 4) + (1 · 2) + (1 · 1)
  3. Dann ist 101011 = 32 + 0 + 8 + 0 + 2 + 1
  4. Und schließlich 101011 = 43

Lassen Sie uns zum Schluss die obigen Schritte codieren:

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. Arithmetische Operationen

In diesem Abschnitt konzentrieren wir uns auf die Ausführung der arithmetischen Operationen für Binärzahlen.

4.1. Zusatz

Genau wie beim Hinzufügen von Dezimalzahlen beginnen wir mit dem Hinzufügen der Zahlen von der am weitesten rechts stehenden Ziffer.

Beim Hinzufügen von zwei Binärziffern müssen die folgenden Regeln beachtet werden:

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

Diese Regeln können wie folgt implementiert werden:

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

Es gibt viele Möglichkeiten, Binärzahlen zu subtrahieren. In diesem Abschnitt lernen wir die Komplementmethode für die Subtraktion.

Lassen Sie uns zunächst verstehen, was die Ergänzung einer Zahl ist.

One's complement of a number is a number obtained by negating each digit of the binary number. That means just replace 1 by 0 and 0 by 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()); }

To do subtraction of two binary numbers using one's complement, we need to:

  1. Calculate the one's complement of the subtrahend s
  2. Add s and the minuend
  3. If a carry gets generated in step 2, then add that carry to step 2's result to get the final answer.
  4. If a carry is not generated in step 2, then the one's complement of step 2's result is the final answer. But in this case, the answer is negative

Let's implement the above steps:

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

In diesem Artikel haben wir gelernt, wie man Binärzahlen in Dezimalzahlen umwandelt und umgekehrt. Dann führten wir arithmetische Operationen wie Addition und Subtraktion von Binärzahlen durch.

Der vollständige Code, der in diesem Artikel verwendet wird, ist auf GitHub verfügbar.