מבוא ל-Java Operators: לוגי, אריתמטי, Bitwise

בוא נדבר על פעולות בג'אווה: מספרית, לוגית, סיבית. זהו בסיס תיאורטי שבהחלט נחוץ כדי ללמוד כיצד לתכנת.

• מהם סוגי האופרטורים ב-Java?
• מפעילי Java בקורס JavaRush
• פעולות מספר ב-Java
• פעולות לוגיות ב-Java
• פעולות Bitwise ב-Java
• עדיפות של פעולות ב-Java
• דוגמאות שימושיות לשימוש

מהם סוגי האופרטורים ב-Java?

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

• מַפעִיל;
• אופרנד.

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

מפעילי Java בקורס JavaRush

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

פעולות מספר ב-Java

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

int a = 1;
int b = 2;
int c = 3;

יש גם פעולות חשבון. הם מבוצעים באמצעות אופרטורים אריתמטיים בינאריים: טבלה 1. אופרטורים אריתמטיים בינאריים ארבעת האופרטורים הראשונים לא צריכים להעלות שאלות: הכל אותו דבר כמו במתמטיקה. המפעיל האחרון, שאר החלוקה, גם לא עושה שום דבר מסובך מדי. לדוגמה, אם נחלק את 24 ב-7, נקבל 3 מספרים שלמים והשאר 3. את השאר המפעיל הזה יחזיר:

System.out.println(24 % 7); // prints 3

להלן דוגמאות מאתר התיעוד הרשמי של אורקל: תוכנית זו תוציא את הפרטים הבאים: 1 + 2 = 3 3 - 1 = 2 2 * 2 = 4 4 / 2 = 2 2 + 8 = 10 10 % 7 = 3 Java מאפשרת לך לשלב: למשל, הקצאות אופרטורים ואופרטורים אריתמטיים. בואו נסתכל על דוגמה:

int x = 0;
x = x + 1; // x = 0 + 1 => x = 1
x = x + 1; // x = 1 + 1 => x = 2
x = x + 1; // x = 2 + 1 => x = 3

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

int x = 0;
x += 1; // x = 0 + 1 => x = 1
x += 1; // x = 1 + 1 => x = 2
x += 1; // x = 2 + 1 => x = 3

אתה יכול לשלב את אופרטור ההקצאה עם כל אופרטור אריתמטי:

int x = 0;
x += 10; // x = 0 + 10 => x = 10
x -= 5; // x = 10 - 5 => x = 5
x *= 5; // x = 5 * 5 => x = 25
x /= 5; // x = 25 / 5 => x = 5
x %= 3; // x = 5 % 3 => x = 2;

בואו נדגים איך הדוגמה האחרונה עובדת: בנוסף לאופרטורים בינאריים, ל-Java יש אופרטורים אריתמטיים אונריים. טבלה 2. אופרטורים אריתמטיים אונריים: דוגמה של פלוס ומינוס אחדים:

int x = 0;
x = (+5) + (+15); // Parentheses for clarity, it is possible without them
System.out.println("x = " + x);

int y = -x;
System.out.println("y = " + y);

פעולות ההגדלה וההפחתה הן פשוטות בעצם. במקרה הראשון, המשתנה גדל ב-1, במקרה השני, המשתנה מופחת ב-1. הדוגמה להלן:

int x = 9;
x++;
System.out.println(x); // 10

int y = 21;
y--;
System.out.println(y); // 20

ישנם שני סוגים של פעולות אלו - postfix ו-prefix. במקרה הראשון, האופרטור נכתב אחרי המשתנה, במקרה השני, לפני המשתנה. ההבדל היחיד הוא כאשר מתבצעת פעולת ההגדלה או ההפחתה. דוגמה ותיאור בטבלה למטה. נניח שיש לנו משתנה:

int a = 2;

לאחר מכן: טבלה 3. אופרטורים הגדלה-ירידה: הפגנה: בנוסף לאריתמטיקה, ישנן פעולות השוואה (של שני מספרים). התוצאה תמיד תהיה אמת או שקר ( true / false ). טבלה 4. אופרטורים להשוואה דוגמאות:

int a = 1;
int b = 2;

boolean comparisonResult = a == b;
System.out.println("a == b :" + comparisonResult);

comparisonResult = a != b;
System.out.println("a != b :" + comparisonResult);

comparisonResult = a > b;
System.out.println("a >  b :" + comparisonResult);

comparisonResult = a >= b;
System.out.println("a >= b :" + comparisonResult);

comparisonResult = a < b;
System.out.println("a <  b :" + comparisonResult);

comparisonResult = a <= b;
System.out.println("a <= b :" + comparisonResult);

הפגנה:

פעולות לוגיות ב-Java

הבה נסתכל על הפעולות הלוגיות וטבלאות האמת של כל אחת מהן:

• פעולת שלילה ( NOT);
• פעולת צירוף, AND ( AND) לוגית;
• פעולת ניתוק, OR לוגי ( OR);
• פעולת הוספת מודולו, OR בלעדי ( XOR).

אופרטור השלילה הוא לא אופרנד חל על אופרנד בודד. כל שאר הפעולות הן בינאריות. בואו נבחן את טבלאות האמת של פעולות אלה. כאן 0 הוא המקבילה של false בג'אווה, ו -1 הוא המקבילה של true . טבלה 5. טבלת אמת אופרטור שלילה (לא) טבלה 6. טבלת האמת של אופרטור הצירוף (AND) טבלה 7. טבלת האמת של אופרטור הניתוק (OR) טבלה 8. טבלת האמת של אופרטור תוספת מודולו (XOR) ל-Java יש את אותן פעולות לוגיות:

• !- מפעיל שלילה;
• &&- אופרטור AND לוגי (קצר);
• ||- אופרטור OR לוגי (קצר);
• &- אופרטור AND בשיטת סיביות;
• |- אופרטור OR בשיטת סיביות;
• ^- אופרטור OR בלעדי מבחינה סיבית.

הבה נסתכל על ההבדל בין אופרטורים סיביים ואופרטורים קצרים למטה, בעוד בואו נמיר את כל טבלאות האמת לקוד Java:

public class LogicDemo {

   public static void main(String[] args) {
    notExample();
    andExample();
    orExample();
    xorExample();
   }

   public static void notExample() {
    System.out.println("NOT EXAMPLE:");
    System.out.println("NOT false = " + !false);
       System.out.println("NOT true  = " + !true);
    System.out.println();
   }

   public static void andExample() {
    System.out.println("AND EXAMPLE:");
    System.out.println("false AND false = " + (false & false));
    System.out.println("false AND true  = " + (false & true));
    System.out.println("true  AND false = " + (true & false));
    System.out.println("true  AND true  = " + (true & true));
    System.out.println();
   }

   public static void orExample() {
    System.out.println("OR EXAMPLE:");
    System.out.println("false OR false = " + (false | false));
    System.out.println("false OR true  = " + (false | true));
    System.out.println("true  OR false = " + (true | false));
     System.out.println("true  OR true  = " + (true | true));
    System.out.println();
   }

   public static void xorExample() {
    System.out.println("XOR EXAMPLE:");
    System.out.println("false XOR false = " + (false ^ false));
    System.out.println("false XOR true  = " + (false ^ true));
    System.out.println("true  XOR false = " + (true ^ false));
    System.out.println("true  XOR true  = " + (true ^ true));
    System.out.println();
   }
}

תוכנית זו תציג: לא דוגמה: לא שקר = נכון לא נכון = שקר ודוגמה: שקר ודוגמה = שקר שקר ואמיתי = שקר אמת ושקר = שקר אמיתי ואמיתי = נכון OR דוגמה: שקר או שקר = שקר שקר או אמת = true true OR false = true true OR true = true XOR דוגמה: false XOR false = false false XOR true = true true XOR false = true true XOR true = false אופרטורים לוגיים חלים רק על booleanמשתנים. במקרה שלנו, החלנו אותם ישירות על ערכים, אבל אתה יכול להשתמש בהם גם עם booleanמשתנים: ולביטויים boolean: כעת, יש לנו אופרטורים קצרים ( &&, ||) ואופרטורים סיביים דומים ( &, |). מה ההבדל ביניהם? ראשית, ניתן להחיל באופן סיבי על מספרים שלמים. נדבר על זה קצת מאוחר יותר. ושנית, חלקם מקוצרים, בעוד שאחרים לא. כדי להבין איך נראה קיצור, הבה נסתכל על הביטוי:

false AND x = ?
true OR x = ?

זה xיכול לקחת כל ערך בוליאני. ובכלל, לפי חוקי ההיגיון וטבלאות האמת, ללא קשר אם זה x נכון או לא נכון , התוצאה של הביטוי הראשון תהיה שקר , והתוצאה של השני תהיה נכונה . תראה. לפעמים ניתן לחשב את התוצאה של ביטוי מהאופרנד הראשון. זה מה שמבדיל בין האופרטורים המקוצרים &&ו ||. בביטויים דומים לאלה שתוארו לעיל, הם אינם מעריכים את הערך של האופרנד השני. הנה דוגמה קטנה: במקרה של אופרטורים קצרים, החלק השני של הביטוי אינו מוערך. אבל זה קורה רק כאשר תוצאת הביטוי ברורה כבר מהאופרנד הראשון.

פעולות Bitwise ב-Java

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

ייצוג מספרים במערכת המספרים הבינארית

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

לפי ויקיפדיה:

סיביות (מהספרה הבינארית האנגלית - מספר בינארי; גם משחק מילים: סיבית אנגלית - חתיכה, חלקיק) היא יחידת מדידה של כמות המידע. סיבית מידע אחת היא סמל או אות שיכולים לקבל שתי משמעויות: מופעל או כבוי, כן או לא, גבוה או נמוך, טעון או לא טעון; במערכת הבינארית הוא 1 (אחד) או 0 (אפס).

עם איזה סוג של נתונים עובדים אופרטורים בשיטת סיביות?

פעולות Bitwise ב-Java מבוצעות רק על מספרים שלמים. מספרים שלמים מאוחסנים בזיכרון המחשב כקבוצה של ביטים. אנו יכולים לומר שמחשב ממיר כל מידע למערכת מספרים בינארית (סט של ביטים) ורק אז מקיים איתה אינטראקציה. אבל איך פועלת מערכת המספרים הבינאריים? במערכת המספרים העשרונית יש לנו רק 10 סמלים: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. אנו משתמשים בסמלים אלה כדי לספור. אחרי 9 בא 10, אחרי 19 - 20, אחרי 99 - 100, אחרי 749 - 750. כלומר, אנו משתמשים בשילוב של 10 הסמלים הזמינים ונוכל להשתמש בהם כדי לספור "מאפס לארוחת צהריים". במערכת המספרים הבינארית, במקום עשרה סימנים, יש רק שניים - 0, 1. אבל על ידי שילוב של סמלים אלו על פי אותו עיקרון כמו במערכת העשרונית, נוכל לספור ללא הגבלה. בואו נדגים ספירה מ-0 עד 15 בעשרוניות ובבינאריות: כפי שאתה יכול לראות, הכל לא כל כך מסובך. בנוסף לביטים, ישנן יחידות מידע מוכרות נוספות - בתים , קילובייטים , מגה-בייט , ג'יגה-בייט וכו'. אתה בטח יודע שיש 8 ביטים ב-1 בייט . מה זה אומר? המשמעות היא ש-8 ביטים ברצף תופסים 1 בת. הנה דוגמאות למה שיכולים להיות בתים:

00000000 - 1 byte
10110010 - 1 byte
01011011 - 1 byte

מספר השילובים האפשריים שאינם חוזרים על סיביות בבייט אחד הוא 256 (2 ⁸ = 256). אבל בואו נחזור קרוב יותר לג'אווה. יש כזה סוג נתונים של מספר שלם - byte. סוג זה יכול לקחת ערכים מ-128 עד 127 ומספר אחד בזיכרון המחשב תופס בדיוק 8 ביטים, או 1 בייט. מספר אחד מסוג זה תופס בדיוק byteזיכרון מחשב אחד. וכאן השמות חופפים לא במקרה. כפי שאנו זוכרים, בית אחד יכול לאחסן 256 ערכים שונים. ומספר סוג אחד byteיכול לקבל 256 ערכים שונים (128 שליליים, 127 חיוביים ו-1 אפס). לכל ערך מספר byteיש קבוצה ייחודית של שמונה ביטים. זה המקרה לא רק עם סוג byte, אלא עם כל הסוגים האינטגרליים. הסוג byteניתן כדוגמה כקטן ביותר. הטבלה שלהלן מציגה את כל סוגי המספרים השלמים של Java ואת שטח הזיכרון שהם תופסים: שקול את הסוג int. הוא יכול לאחסן 2147483648 ערכים שליליים, 2147483647 ערכים חיוביים ואפס אחד. סה"כ:

2147483648 + 2147483647 + 1 = 4294967296.

סוג זה תופס 32 סיביות בזיכרון המחשב. מספר השילובים האפשריים מקבוצה של 32 אפסים ואחדים הוא:

232 = 4294967296.

זהה למספר הערכים שהטיפוס יכול להחזיק int. זוהי רק הדגמה של הקשר בין טווח הערכים של סוג נתונים וגודלו (מספר סיביות בזיכרון). ניתן להמיר כל מספר מכל סוג ב-Java לבינארי. בואו נראה באיזו קלות ניתן לעשות זאת באמצעות שפת Java. נלמד מהדוגמה של טיפוס int. לסוג זה יש מחלקת עטיפה משלו - Integer. ויש לו אחד toBinaryString, שיעשה לנו את כל העבודה: וואלה - זה לא כזה מסובך. אבל עדיין, צריך להבהיר משהו. intהמספר לוקח 32 סיביות. אך כאשר אנו מדפיסים את המספר 10 בדוגמה למעלה, אנו רואים בקונסולה 1010. הסיבה לכך היא שאפסים מובילים אינם מודפסים. אם הם היו מוצגים, במקום 1010 היינו רואים בקונסולה 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000. אבל כדי להקל על התפיסה, כל האפסים המובילים מושמטים. לא כל כך קשה עד שאתה שואל את עצמך: מה לגבי מספרים שליליים? הוא קולט מידע רק במערכת הבינארית. מסתבר שגם את סימן המינוס צריך לכתוב בקוד בינארי. ניתן לעשות זאת באמצעות קוד ישיר או משלים.

קוד ישיר

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

קוד נוסף

על ידי שימוש בקוד נוסף, אתה יכול למנוע את החסרונות של קוד ישיר. יש אלגוריתם פשוט להשיג את הקוד הנוסף של מספר. בואו ננסה להשיג את הקוד הנוסף למספר -5. הבה נציג את המספר הזה באמצעות הקוד המשלים של שני במערכת המספרים הבינארית. שלב 1. נקבל ייצוג של מספר שלילי באמצעות קוד ישיר. עבור -5 זה יהיה 10000101. שלב 2. הפוך את כל הספרות מלבד ספרת הסימן. בוא נחליף את כל האפסים באחדים, ואלה באפסים בכל מקום פרט לחלק השמאלי ביותר.

10000101 => 11111010

שלב 3. הוסף אחד לערך המתקבל:

11111010 + 1 = 11111011

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

סוגי פעולות סיביות

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

אופרטור אונירי ביטבי NOT ~

אופרטור זה מחליף את כל האפסים באחדים, ואת כל האפסים באפסים. נניח שיש לנו את המספר 10 בסימון עשרוני. בבינארי, המספר הזה הוא 1010. אם נחיל את אופרטור השלילה ה-bitwise unary על המספר הזה, נקבל משהו כזה: בואו נסתכל איך זה נראה בקוד Java:

public static void main(String[] args) {
   int a = 10;

   System.out.println(" a = " + a + "; binary string: " + Integer.toBinaryString(a));
   System.out.println("~a = " + ~a + "; binary string: " + Integer.toBinaryString(~a));
}

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

אופרטור AND Bitwise

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

אופרטור OR Bitwise

OR חל על שני מספרים. הוא מבצע פעולת OR בין הסיביות של כל מספר: עכשיו בואו נסתכל איך זה ייראה ב-IDEA:

פעולה סיבית, בלעדי OR (XOR)

בואו נסתכל על אותה דוגמה, אבל עם פעולה חדשה: קוד לדוגמה:

העבר שמאלה בצורה חלקית

אופרטור זה חל על שני אופרנדים, כלומר בפעולה x << y, הסיביות של המספר xיעברו yמיקומים שמאלה. מה זה אומר? נתבונן בדוגמה של הפעולה 10 << 1 תוצאת הפעולה תהיה המספר 20 במערכת העשרונית. כפי שניתן לראות מהדיאגרמה שלמעלה, כל הביטים מוזזים שמאלה ב-1. במהלך פעולה זו, הערך של הביט המשמעותי ביותר (הביט השמאלי ביותר) הולך לאיבוד. והביט הפחות משמעותי (הסיביות הכי ימנית) מלא באפס. מה אתה יכול להגיד על המבצע הזה?

1. על ידי הזזת הסיביות של מספר Xבסיביות Nשמאלה, נכפיל את המספר ב X-2 ^N.

   הנה דוגמה:

2. אבל! הסימן של המספר עשוי להשתנות אם הביט עם הערך 1 תופס את המיקום השמאלי ביותר.

3. אם תזוז שמאלה ללא הגבלת זמן, המספר פשוט יהפוך ל-0. בואו נדגים את נקודות 2 ו-3:

העבר ימינה באופן חלקי

אופרטור זה חל על שני אופרנדים. הָהֵן. בפעולה x >> y, הסיביות של המספר xיעברו yמיקומים ימינה. בואו נסתכל על דוגמה נוספת. הבה ננתח באופן סכמטי את הפעולה 10 >> 1. בואו נעביר את כל הביטים של המספר 10 עמדה אחת ימינה: במהלך פעולת ההסטה, אנו מאבדים את הביטים הנכונים. הם פשוט נעלמים. הסיביות השמאלית ביותר היא הסימן של המספר (0 הוא חיובי, 1 הוא שלילי). לכן, בערך הסופי הוא ממוקם כמו במספר המקורי. דוגמה עם מספר שלילי: הסיבית הכי ימנית אובדת, והסיבית השמאלית ביותר מועתקת מהמספר המקורי, כסימן כבוד למספר. איך עושים את כל זה ב-IDEA? באופן עקרוני, שום דבר מסובך, פשוט קח אותו והזיז אותו: עַכשָׁיו. מה אתה יכול לומר על המספרים המוזזים ימינה? הם מתחלקים ב-2. בכל פעם שנזז ביט אחד ימינה, נחלק את המספר המקורי ב-2. אם המספר אינו מתחלק ב-2, התוצאה תעוגל למינוס אינסוף (למטה). אבל זה עובד רק אם נעביר את הביטים ב-1 בדיוק. ואם ב-2 ביטים, חלקו ב-4. ב-3 ביטים, חלקו ב-8. ב-4 ביטים, חלקו ב-16. רואים? חזקות של 2... כאשר נעביר מספר Xימינה Nבסיביות, נחלק את המספר Xב-2 בחזקת 2 N. הפגנה:

public class BitOperationsDemo {

   public static void main(String[] args) {

    for (int i = 1; i <= 10; i++) {

        int shiftOperationResult = 2048 >> i;
        int devideOperationResult = 2048 / (int) Math.pow(2, i);


           System.out.println(shiftOperationResult + " - " + devideOperationResult);
    }

   }

}

מה קורה פה?

1. לולאה שבה המשתנה i מוגדל מ-1 ל-10.

2. בכל איטרציה אנו מחשבים 2 ערכים:

• אנו כותבים למשתנה shiftOperationResultאת התוצאה של הסטת המספר 2048 ב-i bits ימינה;

• devideOperationResultאנו כותבים את התוצאה של חלוקת המספר 2048 ב-2 בחזקת i לתוך המשתנה .

3. אנו מציגים את שני הערכים שהתקבלו בזוגות.

התוצאה של הפעלת התוכנית היא כדלקמן: 1024 - 1024 512 - 512 256 - 256 128 - 128 64 - 64 32 - 32 16 - 16 8 - 8 4 - 4 2 - 2

העברה ימינה באופן חלקי עם ריפוד אפס

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

עדיפות של פעולות ב-Java

בדומה למתמטיקה, לג'אווה יש עדיפות לפעולות. הטבלה שלהלן מציגה את העדיפות (מהגבוהה לנמוכה ביותר) של הפעולות ששקלנו.

דוגמאות שימושיות לשימוש

קביעת הזוגיות של מספר

מציאת האלמנט המקסימלי במערך

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