מספרים בינאריים בג'אווה

1. הקדמה

מערכת המספרים הבינאריים משתמשת ב- 0 ו- 1 כדי לייצג מספרים. מחשבים משתמשים במספרים בינאריים כדי לאחסן ולבצע פעולות על כל נתונים.

במדריך זה נלמד כיצד להמיר בינארי לעשרוני ולהיפך. כמו כן, נבצע עליהם חיבור וחיסור.

2. מילולי בינארי

ג'אווה 7 הציגה את המילולי הבינארי. זה פשט את השימוש במספרים בינאריים.

כדי להשתמש בו, עלינו להקדים את המספר עם 0B או 0b:

@Test הציבור בטל given_binaryLiteral_thenReturnDecimalValue () {בת חמש = 0b101; assertEquals ((בתים) 5, חמש); שלוש קצר = 0b11; assertEquals ((קצר) 3, three); int תשע = 0B1001; assertEquals (9, תשעה); ארוך עשרים ותשע = 0B11101; assertEquals (29, עשרים ותשע); int minusThirtySeven = -0B100101; assertEquals (-37, minusThirtySeven); }

3. המרת מספר בינארי

בחלק זה נלמד כיצד להמיר מספר בינארי לפורמט העשרוני שלו ולהיפך. כאן נשתמש תחילה בפונקציית Java מובנית לצורך המרה, ואז נכתוב את השיטות המותאמות אישית שלנו עבור אותה.

3.1. עשרוני למספר בינארי

מספר שלם יש פונקציה בשם toBinaryString להמיר מספר עשרוני למחרוזת הבינארית שלו:

@ מבחן ציבורי בטל given_decimalNumber_then_convertToBinaryNumber () {assertEquals ("1000", Integer.toBinaryString (8)); assertEquals ("10100", Integer.toBinaryString (20)); }

כעת נוכל לכתוב את ההיגיון שלנו להמרה זו. לפני כתיבת הקוד, בואו נבין תחילה כיצד להמיר מספר עשרוני למספר בינארי.

להמרת מספר עשרוני נ לפורמט הבינארי שלו, עלינו:

  1. לחלק נ לפי 2, תוך ציון המנה ש והשאר ר
  2. לחלק ש לפי 2, תוך ציון המרכיב והשאר
  3. חזור על שלב 2 עד שנקבל 0 כמנה
  4. לשרשר בסדר הפוך את כל השאר

בואו נראה דוגמה להמרת 6 לשווה ערך לפורמט הבינארי שלה:

  1. ראשית, חלקו 6 ב -2: מנה 3, שארית 0
  2. לאחר מכן, חלקו 3 ב -2: מנה 1, שארית 1
  3. ולסיום, חלקו 1 ל -2: המנה 0, השאר 1
  4. 110

בואו וניישם כעת את האלגוריתם שלעיל:

מספר שלם ציבורי convertDecimalToBinary (מספר שלם עשרוני מספר) {אם (מספר עשרוני == 0) {החזר עשרוני מספר; } StringBuilder binaryNumber = StringBuilder חדש (); מספר שלם = מספר עשרוני; בעוד (מנה> 0) {int שארית = אחוז% 2; binaryNumber.append (שארית); מנה / = 2; } binaryNumber = binaryNumber.reverse (); להחזיר Integer.valueOf (binaryNumber.toString ()); }

3.2. בינארי למספר עשרוני

כדי לנתח מחרוזת בינארית, ה- מספר שלם הכיתה מספקת א מזויף פוּנקצִיָה:

@Test הציבור בטל given_binaryNumber_then_ConvertToDecimalNumber () {assertEquals (8, Integer.parseInt ("1000", 2)); assertEquals (20, Integer.parseInt ("10100", 2)); }

הנה ה מזויף פונקציה לוקחת שני פרמטרים כקלט:

  1. מחרוזת בינארית להמרה
  2. רדיקס או בסיס מערכת המספרים בה יש להמיר מחרוזת קלט

עכשיו, בואו ננסה לכתוב את ההיגיון שלנו כדי להמיר מספר בינארי לעשרוני:

  1. התחל מהספרה הימנית ביותר
  2. הכפל כל ספרה עם 2 ^ {מיקום} מאותה ספרה - כאן, המיקום של הספרה הימנית ביותר הוא אפס והיא גדלה ככל שאנו עוברים לצד שמאל
  3. הוסף את התוצאה של כל הכפל כדי לקבל את המספר העשרוני הסופי

שוב, בואו נראה את השיטה שלנו בפעולה:

  1. ראשית, 101011 = (1 * 2 ^ 5) + (0 * 2 ^ 4) + (1 * 2 ^ 3) + (0 * 2 ^ 2) + (1 * 2 ^ 1) + (1 * 2 ^ 0 )
  2. לאחר מכן, 101011 = (1 * 32) + (0 * 16) + (1 * 8) + (0 * 4) + (1 * 2) + (1 * 1)
  3. לאחר מכן, 101011 = 32 + 0 + 8 + 0 + 2 + 1
  4. ולבסוף, 101011 = 43

בואו סוף סוף נקודד את השלבים שלעיל:

public Integer convertBinaryToDecimal (Integer binaryNumber) {Integer decimalNumber = 0; בסיס שלם = 1; בעוד (binaryNumber> 0) {int lastDigit = binaryNumber% 10; binaryNumber = binaryNumber / 10; decimalNumber + = lastDigit * בסיס; בסיס = בסיס * 2; } להחזיר עשרוני מספר; }

4. פעולות חשבון

בחלק זה נתמקד בביצוע פעולות החשבון במספרים בינאריים.

4.1. חיבור

בדיוק כמו תוספת המספר העשרוני, אנו מתחילים להוסיף את המספרים מהספרה הימנית ביותר.

בעת הוספת שתי ספרות בינאריות, עלינו לזכור את הכללים הבאים:

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

ניתן ליישם כללים אלה כ:

public Integer addBinaryNumber (Integer firstNum, Integer secondNum) {פלט StringBuilder = StringBuilder חדש (); int carry = 0; temp temp; בעוד (firstNum! = 0 || secondNum! = 0) {temp = (firstNum% 10 + secondNum% 10 + + carry)% 2; output.append (temp); לשאת = (firstNum% 10 + secondNum% 10 + carry) / 2; firstNum = firstNum / 10; secondNum = secondNum / 10; } אם (carry! = 0) {output.append (carry); } להחזיר את Integer.valueOf (output.reverse (). toString ()); }

4.2. חִסוּר

ישנן דרכים רבות להפחית מספרים בינאריים. בחלק זה נלמד את שיטת ההשלמה של האדם לבצע חיסור.

בואו נבין תחילה מהו המשלים של המספר.

השלמת המספר של האדם היא מספר שהושג על ידי שלילת כל ספרה של המספר הבינארי. כלומר פשוט החלף 1 ב -0 ו -0 ב -1:

שלם ציבורי getOnesComplement (מספר שלם) {StringBuilder onesComplement = StringBuilder חדש (); בעוד (num> 0) {int lastDigit = num% 10; אם (lastDigit == 0) {onesComplement.append (1); } אחר {onesComplement.append (0); } מספר = מספר / 10; } להחזיר את Integer.valueOf (onesComplement.reverse (). toString ()); }

כדי לבצע חיסור של שני מספרים בינאריים באמצעות המשלים של אחד, עלינו:

  1. חשב את השלמתו של אחד הסובטראנדים ס
  2. לְהוֹסִיף ס והמינואנד
  3. אם נשא נוצר בשלב 2, הוסף אותו לשאת לתוצאה של שלב 2 כדי לקבל את התשובה הסופית.
  4. אם לא נוצר נשיאה בשלב 2, אז השלמת התוצאה של שלב 2 היא התשובה הסופית. אך במקרה זה, התשובה היא שלילית

בוא נבצע את השלבים שלעיל:

ציבורי שלם שלם שלם שלם - BinaryNumber (מספר שלם ראשון, מספר שלם שני) {int onesComplement = Integer.valueOf (getOnesComplement (secondNum)); פלט StringBuilder = StringBuilder חדש (); int carry = 0; temp temp; בעוד (firstNum! = 0 || onesComplement! = 0) {temp = (firstNum% 10 + onesComplement% 10 + carry)% 2; output.append (temp); לשאת = (firstNum% 10 + אלהשלם% 10 + carry) / 2; firstNum = firstNum / 10; onesComplement = onesComplement / 10; } מחרוזת additionOfFirstNumAndOnesComplement = output.reverse (). ToString (); אם (carry == 1) {return addBinaryNumber (Integer.valueOf (additionOfFirstNumAndOnesComplement), carry); } אחר {return getOnesComplement (Integer.valueOf (additionOfFirstNumAndOnesComplement)); }}

5. מסקנה

במאמר זה למדנו כיצד להמיר מספרים בינאריים למספרים עשרוניים ולהיפך. לאחר מכן, ביצענו פעולות חשבון כגון חיבור וחיסור על מספרים בינאריים.

הקוד השלם המשמש במאמר זה זמין באתר GitHub.