Nombres binaires en Java

1. Introduction

Le système de nombres binaires utilise des 0 et des 1 pour représenter les nombres. Les ordinateurs utilisent des nombres binaires pour stocker et effectuer des opérations sur toutes les données.

Dans ce didacticiel, nous allons apprendre à convertir un binaire en décimal et vice versa. Nous effectuerons également des additions et des soustractions sur eux.

2. Littéral binaire

Java 7 a introduit le littéral binaire. Il a simplifié l'utilisation des nombres binaires.

Pour l'utiliser, nous devons préfixer le nombre avec 0B ou 0b:

@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. Conversion de nombres binaires

Dans cette section, nous allons apprendre à convertir un nombre binaire en son format décimal et vice versa. Ici, nous allons d'abord utiliser une fonction Java intégrée pour la conversion, puis nous écrirons nos méthodes personnalisées pour la même chose.

3.1. Décimal à un nombre binaire

Integer a une fonction nommée toBinaryString pour convertir un nombre décimal en sa chaîne binaire:

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

Maintenant, nous pouvons essayer d'écrire notre propre logique pour cette conversion. Avant d'écrire le code, comprenons d'abord comment convertir un nombre décimal en un nombre binaire.

Pour convertir un nombre décimal n dans son format binaire, nous devons:

  1. Divisez n par 2, en notant le quotient q et le reste r
  2. Divisez q par 2, en notant son quotient et le reste
  3. Répétez l'étape 2 jusqu'à ce que nous obtenions 0 comme quotient
  4. Concaténer dans l'ordre inverse tous les restes

Voyons un exemple de conversion de 6 en son équivalent au format binaire:

  1. Tout d'abord, divisez 6 par 2: quotient 3, reste 0
  2. Ensuite, divisez 3 par 2: quotient 1, reste 1
  3. Et enfin, divisez 1 par 2: quotient 0, reste 1
  4. 110

Implémentons maintenant l'algorithme ci-dessus:

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. Binaire à un nombre décimal

Pour analyser une chaîne binaire, la classe Integer fournit une fonction parseInt :

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

Ici, la fonction parseInt prend deux paramètres en entrée:

  1. Chaîne binaire à convertir
  2. Radix ou base du système numérique dans lequel la chaîne d'entrée doit être convertie

Maintenant, essayons d'écrire notre propre logique pour convertir un nombre binaire en nombre décimal:

  1. Commencez par le chiffre le plus à droite
  2. Multipliez chaque chiffre par 2 ^ {position} de ce chiffre - ici, la position du chiffre le plus à droite est zéro et elle augmente à mesure que nous nous déplaçons vers le côté gauche
  3. Ajoutez le résultat de toutes les multiplications pour obtenir le nombre décimal final

Encore une fois, voyons notre méthode en action:

  1. Premièrement, 101011 = (1 * 2 ^ 5) + (0 * 2 ^ 4) + (1 * 2 ^ 3) + (0 * 2 ^ 2) + (1 * 2 ^ 1) + (1 * 2 ^ 0 )
  2. Ensuite, 101011 = (1 * 32) + (0 * 16) + (1 * 8) + (0 * 4) + (1 * 2) + (1 * 1)
  3. Ensuite, 101011 = 32 + 0 + 8 + 0 + 2 + 1
  4. Et enfin, 101011 = 43

Codons enfin les étapes ci-dessus:

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. Opérations arithmétiques

Dans cette section, nous allons nous concentrer sur l'exécution des opérations arithmétiques sur les nombres binaires.

4.1. Une addition

Tout comme l'addition de nombres décimaux, nous commençons à ajouter les nombres à partir du chiffre le plus à droite.

Lors de l'ajout de deux chiffres binaires, nous devons nous souvenir des règles suivantes:

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

Ces règles peuvent être implémentées comme:

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

Il existe de nombreuses façons de soustraire des nombres binaires. Dans cette section, nous allons apprendre une méthode de complément à un pour faire une soustraction.

Comprenons d'abord quel est le complément d'un nombre.

Le complément à un d'un nombre est un nombre obtenu en annulant chaque chiffre du nombre binaire. Cela signifie simplement remplacer 1 par 0 et 0 par 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()); }

Pour faire la soustraction de deux nombres binaires en utilisant son complément, nous devons:

  1. Calculer le complément à un des sous-nombres s
  2. Ajouter s et le minuend
  3. Si une retenue est générée à l'étape 2, ajoutez cette retenue au résultat de l'étape 2 pour obtenir la réponse finale.
  4. Si une retenue n'est pas générée à l'étape 2, alors le complément à un du résultat de l'étape 2 est la réponse finale. Mais dans ce cas, la réponse est négative

Implémentons les étapes ci-dessus:

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

Dans cet article, nous avons appris à convertir des nombres binaires en nombres décimaux et vice versa. Ensuite, nous avons effectué des opérations arithmétiques telles que l'addition et la soustraction sur des nombres binaires.

Le code complet utilisé dans cet article est disponible à l'adresse over sur GitHub.