הבנת הערך & 0xff ב- Java

1. סקירה כללית

0xffהוא מספר המיוצג ב-מערכת ספרות הקסדצימליות (בסיס 16). זה מורכב משניים F מספרים בהקס. כידוע, F ב- hex שווה ערך ל- 1111 במערכת הספרות הבינארית. כך, 0xff בינארי הוא 11111111.

במאמר זה נגלה כיצד להשתמש ב- 0xff ערך. בנוסף נראה כיצד לייצג אותו באמצעות סוגי נתונים מרובים וכיצד להשתמש בו עם ה- & מַפעִיל. לבסוף נסקור כמה מהיתרונות הכרוכים בשימוש בו.

2. ייצוג 0xff עם סוגי נתונים שונים

ג'אווה מאפשרת לנו להגדיר מספרים המתפרשים כהקס (בסיס 16) באמצעות ה- 0x קידומת, ואחריה מספר שלם מילולי.

הערך 0xff שווה ערך ל 255 בעשרון לא חתום, -127 בעשרון חתום, ו- 11111111 בינארי.

אז אם נגדיר int משתנה עם הערך של 0xff, מאז Java מייצגת מספרים שלמים באמצעות 32 ביט, הערך של 0xff הוא 255:

int x = 0xff; assertEquals (255, x);

עם זאת, אם נגדיר א בתים משתנה עם הערך 0xff, מכיוון שג'אווה מייצגת בתים המשתמשת ב 8 ביטים ומכיוון שבייט הוא סוג נתונים חתום, הערך של 0xff הוא -1:

בתים y = (בתים) 0xff; assertEquals (-1, y);

כפי שאנו רואים, כאשר אנו מגדירים א בתים משתנה עם 0xff ערך, אנחנו צריכים להוריד אותו ל a בתים כי הטווח של בתים סוג הנתונים הוא מ -128 עד 127.

3. שימוש נפוץ ב & 0xff מבצע

ה & המפעיל מבצע פעולת AND ובינונית. הפלט של AND bitwise הוא 1 אם הסיביות המקבילות לשני אופרנדים הן 1. מצד שני, אם סיבית אחת מהאופרות היא 0, התוצאה של הסיבית המקבילה מוערכת ל- 0.

מאז 0xff יש שמונה כאלה ב -8 הביטים האחרונים, זה הופך את זה ל- אלמנט זהות לפעולה AND bit bit. אז אם אנו מיישמים את x & 0xff מבצע, זה ייתן לנו את 8 הסיביות הנמוכות ביותר מ איקס. שימו לב, אם המספר איקס הוא פחות מ 255, זה עדיין יהיה זהה. אחרת, זה יהיה 8 הביטים הנמוכים ביותר מ איקס.

באופן כללי, ה & 0xff הפעולה מספקת לנו דרך פשוטה לחלץ את 8 הסיביות הנמוכות ביותר ממספר. אנו יכולים להשתמש בה כדי לחלץ 8 ביטים שאנחנו זקוקים להם מכיוון שנוכל להזיז ימינה מכל 8 הביטים שאנחנו רוצים להיות הביטים הנמוכים ביותר. לאחר מכן נוכל לחלץ אותם על ידי יישום ה- & 0xff מבצע.

בואו נראה דוגמה להסבר על כמה מהיתרונות שבשימוש & 0xff בפירוט רב יותר.

4. חילוץ קואורדינטות צבע RGBA באמצעות & 0xff

נניח שיש לנו מספר שלם איקס, המאוחסן ב- 32 ביטים, המייצג צבע במערכת RGBA, כלומר יש לו 8 ביטים לכל פרמטר (R, G, B ו- A):

  • R = 16 (00010000 בבינארי)
  • G = 57 (00111001 בינארי)
  • B = 168 (10101000 בינארי)
  • A = 7 (00000111 בינארי)

כך, איקס בינארי יוצג כ 00010000 00111001 10101000 00000111 - שזה שווה ערך ל 272214023 בעשרוני.

עכשיו, יש לנו את שלנו איקס ערך בעשרוני, ואנחנו רוצים לחלץ את הערך עבור כל פרמטר.

כידוע, הפעולה >> מעבירה ביטים ימינה. לכן, כאשר אנו עושים זאת (10000000 00000000 >> 8), זה נותן לנו 10000000. כתוצאה מכך, אנו יכולים לחלץ את הערך של כל פרמטר:

int rgba = 272214023; int r = rgba >> 24 & 0xff; assertEquals (16, r); int g = rgba >> 16 & 0xff; assertEquals (57, g); int b = rgba >> 8 & 0xff; assertEquals (168, b); int a = rgba & 0xff; assertEquals (7, a);

5. מסקנה

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

כמו תמיד, הקוד המוצג במאמר זה זמין באתר GitHub.