Java: ביטים ובייטים

מבוא

אם אנשים סופרים במערכת המספרים העשרונית, אז מחשבים סופרים במערכת הבינארית. ומתכנת חייב להבין איך לדבר גם עם אנשים וגם עם מחשבים. סקירה זו אמורה לסייע בעניין זה. לפעמים מסתתר עולם שלם מאחורי המובן מאליו. אני מציע לדבר על העולם הזה. לדוגמה, יש 7 ימים בשבוע. כעת, בואו נענה על השאלה: מהו המספר "7"? ) ראשית, זהו מספר טבעי שלם (חיובי). זה גם מספר עשרוני. מספר עשרוני הוא מספר במערכת העשרונית. כשאומרים "מערכת מספרים עשרוניים", זה אומר שלמערכת המספרים יש בסיס של 10 . הרדיוס מראה כמה ספרות ניתן להשתמש במערכת מספרים נתונה כדי לייצג מספר. הספירה לאחור היא מאפס. בהתאם לכך, כדי לייצג מספרים במערכת המספרים העשרונית, אנו משתמשים במספרים מ-0 עד 9. זה טוב, אבל אנחנו צריכים לספור לא רק עד 9, אלא גם מעבר. איך להיות? לדוגמה, המספר 10. כדי לכתוב את המספר הזה, אנו משתמשים עד 2 ספרות. המיקום של כל ספרה במערכת העשרונית נקרא מקום עשרוני. הספרות נספרות מימין לשמאל: בנוסף, ניתן להרחיב את המספר העשרוני באופן הבא: 103 = 1*10^2 + 0*10^1 + 3*10^0 המספר בעצם גדל מימין לשמאל. כלומר, בהתחלה זה היה 7, ואז זה הפך ל-10. לכן, הספרות נספרים מימין, החל מאפס. בשביל מה כל זה? זה בגלל שאנחנו לא מחשבים. ובעוד שאנחנו סופרים בעשרוניות (כלומר, בסיס 10), מחשבים סופרים בבינארי (כלומר, בסיס 2). אבל הכללים החלים במערכות המספרים הללו זהים.

מערכת בינארית

השיטה הבינארית דומה מאוד לשיטה העשרונית, כשההבדל היחיד הוא שהגבול כאן הוא לא 10, אלא 2. נשווה עם דוגמה. איך נציג 11 בבינארי? זה פשוט מאוד: אתה רק צריך לחלק את המספר העשרוני בבסיס 2, כלומר לספור 11/2 בעמודה. דוגמא: או הנה דוגמה מ-WikiHow: מעניין לציין שנוכל לייצג מספר בבינארי באותו אופן כמו בעשרוני: 111 בבינארי = 1*2^2 + 1*2^1 + 1*2^0 = 4 + 2 + 1 דוגמה להמרה מבינארי לעשרוני ניתן לראות במחשבון המקוון . אם כבר מדברים על העובדה שכללי הפעולה במערכות המספרים זהים, בואו נסתכל על חיבור במערכת הבינארית: כפי שאתה יכול לראות, אנו מעבירים ספרות במהלך החיבור באותו אופן כמו במערכת העשרונית. ניתוח של תוספת ניתן לראות, למשל, כאן:

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

אגב, איזו מילה "הפרשה" מוזכרת מעת לעת. ומה זה? המקום הוא רק "אלמנט מבני" של ייצוג מספר. כלומר, המספר 10 מורכב משתי ספרות: אנחנו צריכים 2 ספרות, 2 מקומות, 2 אלמנטים כדי לכתוב את המספר הזה. חשוב לנו להבין זאת מכיוון שבמערכת המספרים הבינארית, ספרה היא מעט . המילה Bit מגיעה מהאנגלית "ספרה בינארית" , כלומר מספר בינארי. זה יכול להיות 0 או 1. אבל כמו שאנחנו קוראים מספרים ומילים כמכלול, ולא אות אחר אות, מחשבים לא קוראים ביט אחד בכל פעם. עבור ה"חתיכה" המינימלית של מידע מעובד ב-RAM (מה שנקרא יחידת המידע הניתנת להתייחסות הקטנה ביותר), נקרא רצף של 8 סיביות . מכיוון שיש 8 מהם, זה נקרא "אוקטט". וגם - המילה הידועה יותר Byte . כדי לזכור את התמנון, אפשר לזכור שהמילה תמנון (שמונה רגליים) מתורגמת לאנגלית בתור תמנון. כלומר, הנה בדיוק אותו "אוקטו" בכותרת: בואו נחשוב מהו המספר המקסימלי שנוכל לייצג כ-8 סיביות? וכאן נשאלת השאלה: מה לגבי מספרים שליליים? כדי להבין זאת, בואו נדבר על איך בייטים מיוצגים בג'אווה

Java ובייט

איך זה שאנחנו יכולים להשתמש במספרים שליליים ב-Java? זה נעשה בפשטות. ב-Java, בייטים חתומים. הספרה/סיבית השמאלית ביותר (נקראת גם "הסיבית המשמעותית ביותר") נעשית מעין "סמן" שעונה על השאלה: "האם המספר הזה שלילי?" אם התשובה היא כן, אז לסמן יש את הערך 1. אחרת, הוא 0. בואו נסתכל על דוגמה כיצד להפוך את המספר 5 למספר שלילי 5: בהתבסס על תמונה זו, אתה יכול להבין את הגבולות שבהם נמצא ערך Byte: ברור גם ש:

• אם נוסיף אחד ל-127, נקבל -128.
• אם נחסר אחד מ-128, נקבל 127.

לפיכך, Byte ב-Java יכול לקבל ערך מ-128 עד 127. כזכור, בייט הוא אוקטט. ולספרה המקסימלית/הביט המשמעותי ביותר יש מספר סידורי של 7, מכיוון שאנו סופרים מאפס. במקרה זה, קל לזכור שבייט שווה ל-2 בחזקת 7 (גבול תחתון) ל-2 בחזקת 7 מינוס 1 (גבול עליון). העבודה עם סוג הנתונים עצמו היא פשוטה. אנו משתמשים במהדר Java המקוון "repl.it" כ"ארגז חול" עבור מאמר זה. https://repl.it/languages/java. לדוגמה, הבה נריץ את הקוד שייצג משתנה בתים בצורה בינארית כמחרוזת:

class Main {
  public static void main(String[] args) {
    byte octet = 5;
    String bin = String.format("%8s", Integer.toBinaryString(octet)).replace(' ', '0');
    System.out.println(bin);
  }
}

עבודה עם בתים משמשת באופן פעיל בעת עבודה עם זרמי I/O. אתה יכול לקרוא עוד במדריך של אורקל: " I/O Streams ". בנוסף, ב-Java אתה יכול להשתמש במילולי מיוחד כדי לציין את הערך כסיביות:

class Main {
  public static void main(String[] args) {
    byte data = 0b101;
    System.out.println(data);
  }
}

מניפולציה של ביט

נגיעה בביטים וביטים, אי אפשר שלא להזכיר מניפולציות שונות של סיביות. ככל הנראה הפעולה הנפוצה ביותר היא תזוזה (הזזה סיבית או המרת סיביות). והכל בגלל שלתוצאה שלהם יש יתרונות מעשיים ברורים. מה השימוש? הזזה שמאלה ב-N מיקומים שווה ערך להכפלת המספר ב-2N. והסטה ימינה דומה לאותה חלוקה לפיכך, 5<<2 == 5*Math.pow(2,2) וכדי להבין מדוע זה כך, נתבונן בדוגמה זו ביתר פירוט: השלילה ה-bitwise NOT (Unary bitwise), המיוצגת על ידי טילדה, הופכת את הביטים. זה כתוב כטילדה, למשל ~5.

public static void main(String[] args) {
	System.out.println(~5); //-6
 	System.out.println(~-5);//4
}

זה שוב מראה שכאשר ג'אווה משנה את הסימן של מספר, בנוסף להיפוך ערכי הסיביות ממש בסוף, אנו מבצעים +1. ובלי זה, כפי שאנו רואים, מספר 5 שלנו משתנה. וכדי שזה יישאר אותו מספר כמו לפני החלפת השלט, אתה צריך לעשות 1+. Bitwise AND מאפשר לך להשאיר שני מספרים שונים עם הערך 1 עבור ביט רק אם לכל הסיביות יש ערך של אחד. מה שמעניין בזה יכול להיות שיש לזה כמה יתרונות יישום:

int x=4;
System.out.println((x&1) != 1);

קוד זה בודק את המספר x עבור זוגיות. בואו נסתכל על דוגמה: על ידי שימוש ב-Bitwise AND וב-Bitwise OR ביחד, אתה יכול להשתמש במסכות:

public static void main(String[] args) {
    byte optionA=0b0100;
    byte optionB=0b0010;
    byte optionC=0b0001;
    byte value = (byte)(optionB | optionC);
    // Check for optionB
    if ((optionC & value) != 0b0000) {
      System.out.println("Yes");
    } else {
      System.out.println("No");
    }
  }

ראה " אפשרויות מיסוך עם אופרטורים סיביים ב-Java " לפרטים נוספים. מניפולציה של סיביות היא נושא מעניין שנכתבו עליו ביקורות, מאמרים וספרים נפרדים. ומכאן מתחילה הדרך הארוכה להצפנה. כחלק מסקירה זו, כדאי להבין מדוע זה עובד וכיצד. למידע נוסף על פעולות סיביות, אני ממליץ לקרוא את הסקירה של tproger: " על פעולות סיביות ."

טיפוסים פרימיטיביים

אז, בייט הוא אוקטט, כלומר 8 סיביות. קל לזכור שבג'אווה יש גם 8 טיפוסים פרימיטיביים, במקרה. טיפוס פרימיטיבי הוא סוג נתונים המובנה בשפת תכנות, כלומר זמין כברירת מחדל. byte הוא סוג הנתונים הפרימיטיבי הקטן ביותר מבחינת טביעת הרגל של הזיכרון שאיתו Java יכולה לעבוד. כפי שאמרנו קודם, בית תופס 8 ביטים. לכן, הספרה המשמעותית ביותר היא מספר 7. לכן, בייט מכיל את הערכים מ -2 עד 7 עד 2 עד 7 מינוס 1 של התוצאה. אילו עוד טיפוסים פרימיטיביים קיימים: כפי שאנו יכולים לראות מהטבלה, סוגי הנתונים במונחים של כמות הנתונים התפוסים מכפילים את עצמם. כלומר, קצר = 2 * בייט, ו-int = 2 * קצר. למעשה קל לזכור. זכור כי בייט = 8 סיביות. גם העובדה שזה לא יכול להיות פחות נזכרת. באנגלית, מספר שלם נקרא שלם. הטיפוס הפרימיטיבי ממנו נקרא הקיצור int. יש מספר שלם רגיל - int. יש גרסה קצרה, קצרה, וגרסה ארוכה, ארוכה. בהתאם לכך, int תופסת 32 ביטים (4 בתים). הגרסה הקצרה קטנה פי 2 - 16 ביטים (2 בתים), והגרסה הארוכה גדולה פי שניים, כלומר. 64 סיביות (8 בתים). אז int יכול לכל היותר לאחסן מספר של כ-2 מיליארד ומאה מיליון. וארוך יכול לאחסן מקסימום בערך 9 קוודריליון (מילה יפה). כשזוכרים את הבדיחה הישנה על איך מתכנת מתחיל חושב שיש 1000 בייטים בקילו-בייט, ומתכנת שלם מאמין שיש 1024 גרם בק"ג, אנחנו יכולים להבין:

1 mb = 1024 Kbyte = 1024 * 1024 = 1048576 bytes
1 int = 4 bytes
1 mb = 262144 int

אגב, קורא קשוב אולי שם לב שיש רק 7 סוגים בתמונה. סוג 8 פרימיטיבי הוא בוליאני. boolean הוא סוג נתונים בוליאני שיש לו רק שני ערכים: true ו-false. אבל נשאלת השאלה - מה הגודל? מפרט ה-Java Virtual Machine וסעיף " 2.3.4. ה-Boolian Type " יענו לנו: כלומר, רק בוליאן ייקח את אותה כמות כמו int. אם נכריז על מערך של בוליאנית, אז כל רכיב של המערך יתפוס 1 בת. אלו ניסים כאלה :)

סיכום

אני מציע לך להכיר עוד כמה חומרים לאיחוד:

• " Hackerrank: Bit Manipulation "
• " Hackerrank: פתרו את 'מספר שלם בודד' באמצעות מניפולציה של סיביות "
• " מניפולציה של סיביות 01: מבוא "
• " אתגר קידוד מס' 120: העברת סיביות "

#ויאצ'סלב