مقدمه ای بر عملگرهای جاوا: منطقی، حسابی، بیتی

بیایید در مورد عملیات در جاوا صحبت کنیم: عددی، منطقی، بیتی. این یک مبنای نظری است که قطعا برای یادگیری نحوه برنامه نویسی مورد نیاز است.

• انواع اپراتورها در جاوا چیست؟
• اپراتورهای جاوا در دوره JavaRush
• عملیات اعداد در جاوا
• عملیات منطقی در جاوا
• عملیات بیتی در جاوا
• تقدم عملیات در جاوا
• نمونه های مفید استفاده

انواع اپراتورها در جاوا چیست؟

برای هر عملیاتی حداقل به دو چیز نیاز داریم:

• اپراتور؛
• عملوند

یک مثال از یک عملگر می تواند یک مثبت ساده در عملیات جمع دو عدد باشد. و اعداد اضافه شده به یکدیگر در این حالت عملوند خواهند بود. بنابراین، با کمک عملگرها، عملیات را روی یک یا چند عملوند انجام می دهیم. عملگرهایی که روی دو عملوند عملیات انجام می دهند باینری می گویند. به عنوان مثال، جمع کردن دو عدد. عملگرهایی که روی یک عملوند منفرد عملیات انجام می دهند Unary نامیده می شوند. به عنوان مثال، منهای یکپارچه.

اپراتورهای جاوا در دوره JavaRush

چندین سخنرانی به عملگرهای جاوا در سطح چهارم اولین کوئست - Java Syntax اختصاص داده شده است. به طور خاص، عملگرهای شرطی مانند boolean . این دوره شامل 22 وظیفه است که به شما در درک کار عملگرهای مقایسه، عملگرهای شرطی و عملگرهای منطقی کمک می کند.

عملیات اعداد در جاوا

رایج ترین عملیاتی که برنامه نویسان بر روی اعداد انجام می دهند، تخصیص یک مقدار عددی به یک متغیر است. او، مانند اپراتور، =برای شما آشنا است:

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

عملیات حسابی نیز وجود دارد. آنها با استفاده از عملگرهای حسابی باینری انجام می شوند: جدول 1. عملگرهای حسابی باینری چهار عملگر اول نباید هیچ سوالی را مطرح کنند: همه چیز مانند ریاضیات است. اپراتور آخر، باقیمانده تقسیم، نیز کار خیلی پیچیده ای را انجام نمی دهد. به عنوان مثال، اگر 24 را بر 7 تقسیم کنیم، 3 عدد صحیح و 3 عدد باقیمانده به دست می آید. باقی مانده است که این اپراتور باز خواهد گشت:

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

در اینجا نمونه هایی از سایت اسناد رسمی Oracle آورده شده است: این برنامه موارد زیر را خروجی می دهد: 1 + 2 = 3 3 - 1 = 2 2 * 2 = 4 4 / 2 = 2 2 + 8 = 10 10 % 7 = 3 جاوا به شما اجازه می دهد برای ترکیب کردن: به عنوان مثال، انتساب عملگرها و عملگرهای حسابی. بیایید به یک مثال نگاه کنیم:

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;

بیایید نشان دهیم که آخرین مثال چگونه کار می کند: جاوا علاوه بر عملگرهای باینری، عملگرهای محاسباتی تکی نیز دارد. جدول 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

دو نوع از این عملیات وجود دارد - پسوند و پیشوند. در حالت اول عملگر بعد از متغیر و در حالت دوم قبل از متغیر نوشته می شود. تنها تفاوت زمانی است که عملیات افزایش یا کاهش انجام می شود. مثال و توضیحات در جدول زیر. فرض کنید یک متغیر داریم:

int a = 2;

سپس: جدول 3. عملگرهای افزایش-کاهش: تظاهرات: علاوه بر حساب، عملیات مقایسه (دو عددی) نیز وجود دارد. نتیجه همیشه درست یا نادرست ( درست / نادرست ) خواهد بود. جدول 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);

تظاهرات:

عملیات منطقی در جاوا

بیایید به عملیات منطقی و جداول صدق هر یک از آنها نگاه کنیم:

• عملیات نفی ( NOT);
• عملیات ربط، منطقی و ( AND);
• عملیات تفکیک، منطقی OR ( OR);
• عملیات اضافه کردن مدول، OR انحصاری ( XOR).

عملگر نفی یک واحد است و برای یک عملوند منفرد اعمال می شود. تمام عملیات های دیگر باینری هستند. بیایید جداول حقیقت این عملیات را در نظر بگیریم. در اینجا 0 معادل false در جاوا و 1 معادل true است . جدول 5. جدول حقیقت عملگر نفی (NOT) جدول 6. جدول حقیقت عملگر ربط (AND) جدول 7. جدول حقیقت عملگر تفکیک (OR) جدول 8. جدول حقیقت عملگر جمع مدول (XOR) جاوا عملیات منطقی مشابهی دارد:

• !- عملگر نفی
• &&- عملگر AND منطقی (کوتاه)؛
• ||- عملگر OR منطقی (کوتاه)؛
• &- عملگر بیتی AND؛
• |- عملگر بیتی OR؛
• ^- عملگر OR انحصاری بیتی.

بیایید تفاوت بین عملگرهای بیتی و کوتاه را کمی بیشتر در زیر بررسی کنیم، در حالی که بیایید تمام جداول حقیقت را به کد جاوا تبدیل کنیم:

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();
   }
}

این برنامه نمایش می دهد: NOT EXAMPLE: NOT false = true NOT true = false AND EXAMPLE: false AND false = false false AND true = false true AND false = false true AND true = true OR EXAMPLE: false OR false = false false OR true = 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 درست یا نادرست بودن آن ، نتیجه عبارت اول نادرست و نتیجه دوم صادق خواهد بود . نگاه کن گاهی اوقات نتیجه یک عبارت را می توان از عملوند اول محاسبه کرد. این چیزی است که عملگرهای مخفف &&و ||. در عبارات مشابه آنچه در بالا توضیح داده شد، آنها مقدار عملوند دوم را ارزیابی نمی کنند. در اینجا یک مثال کوچک وجود دارد: در مورد عملگرهای مختصر، قسمت دوم عبارت ارزیابی نمی شود. اما این فقط زمانی اتفاق می افتد که نتیجه عبارت از قبل از عملوند اول آشکار باشد.

عملیات بیتی در جاوا

خب، در اینجا به جالب ترین قسمت می رسیم: عملیات بیتی. همانطور که از نام آن پیداست، اینها عملیاتی هستند که روی بیت ها انجام می شوند. اما قبل از اینکه به این موضوع بپردازیم، ارزش آن را دارد که در مورد حوزه های مرتبط صحبت کنیم.

نمایش اعداد در سیستم اعداد باینری

اعداد، مانند هر اطلاعات دیگری در یک برنامه، در حافظه کامپیوتر به صورت کد باینری ذخیره می شوند. کد باینری مجموعه ای از صفر و یک است. هر صفر یا یک نشان دهنده واحدی از اطلاعات به نام بیت است.

طبق ویکی پدیا:

بیت (از رقم باینری انگلیسی - عدد باینری؛ همچنین بازی با کلمات: بیت انگلیسی - قطعه، ذره) واحد اندازه گیری مقدار اطلاعات است. 1 بیت اطلاعات نماد یا سیگنالی است که می تواند به دو معنا باشد: روشن یا خاموش، بله یا خیر، زیاد یا کم، شارژ یا بدون شارژ. در سیستم باینری 1 (یک) یا 0 (صفر) است.

عملگرهای بیتی با چه نوع داده ای کار می کنند؟

عملیات بیتی در جاوا فقط روی اعداد صحیح انجام می شود. اعداد صحیح به صورت مجموعه ای از بیت ها در حافظه کامپیوتر ذخیره می شوند. می توان گفت که یک کامپیوتر هر اطلاعاتی را به یک سیستم اعداد باینری (مجموعه ای از بیت ها) تبدیل می کند و تنها پس از آن با آن تعامل می کند. اما سیستم اعداد باینری چگونه کار می کند؟ در سیستم اعداد اعشاری فقط 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یک عدد از این نوع دقیقا 1 حافظه کامپیوتر را اشغال می کند . و در اینجا نام ها تصادفی نیست. همانطور که به یاد داریم، 1 بایت می تواند 256 مقدار مختلف را ذخیره کند. و یک عدد نوع byteمی تواند 256 مقدار مختلف (128 منفی، 127 مثبت و 1 صفر) به خود بگیرد. هر مقدار عدد byteدارای یک مجموعه منحصر به فرد از هشت بیت است. این مورد نه تنها در مورد نوع byte، بلکه در مورد همه انواع انتگرال است. نوع byteبه عنوان نمونه به عنوان کوچکترین آورده شده است. جدول زیر تمام انواع عدد صحیح جاوا و فضای حافظه اشغال شده را نشان می دهد: نوع را در نظر بگیرید int. می تواند 2147483648 مقدار منفی، 2147483647 مقدار مثبت و یک صفر را ذخیره کند. جمع:

2147483648 + 2147483647 + 1 = 4294967296.

این نوع 32 بیت در حافظه کامپیوتر اشغال می کند. تعداد ترکیب های ممکن از یک مجموعه 32 صفر و یک برابر است با:

232 = 4294967296.

همان تعداد مقادیری که نوع می تواند نگه دارد int. این فقط نمایشی از رابطه بین محدوده مقادیر یک نوع داده و اندازه آن (تعداد بیت در حافظه) است. هر تعداد از هر نوع در جاوا را می توان به باینری تبدیل کرد. بیایید ببینیم با استفاده از زبان جاوا چقدر راحت می توان این کار را انجام داد. ما از مثال نوع یاد خواهیم گرفت int. این نوع دارای کلاس wrapper خاص خود است - Integer. و او یکی دارد toBinaryStringکه همه کارها را برای ما انجام می دهد: Voila - آنقدرها هم پیچیده نیست. اما باز هم چیزی باید روشن شود. intعدد 32 بیت طول می کشد. اما وقتی عدد 10 را در مثال بالا چاپ می کنیم، عدد 1010 را در کنسول می بینیم این به این دلیل است که صفرهای ابتدایی چاپ نمی شوند. اگر نمایش داده می شد، به جای 1010، در کنسول 0000000000000000000000000000000000000000000000000000000000000010 را مشاهده می کردیم. اما برای سهولت درک، تمام صفرهای ابتدایی حذف شده اند. تا زمانی که از خود بپرسید: اعداد منفی چطور؟ اطلاعات را فقط در سیستم باینری درک می کند. به نظر می رسد که علامت منفی نیز باید در کد باینری نوشته شود. این کار را می توان با استفاده از کد مستقیم یا مکمل انجام داد.

کد مستقیم

روشی برای نمایش اعداد در سیستم اعداد باینری که در آن مهم ترین بیت (سمت چپ ترین بیت) به علامت عدد اختصاص می یابد. اگر عدد مثبت باشد، سمت چپ ترین بیت 0 و اگر منفی - 1 نوشته می شود. بیایید با استفاده از یک عدد 8 بیتی به عنوان مثال به این موضوع نگاه کنیم: رویکرد ساده و در اصل قابل درک است. با این حال، دارای معایبی است: مشکلات در انجام عملیات ریاضی. مثلاً با جمع اعداد منفی و مثبت. آنها را نمی توان تا کرد مگر اینکه دستکاری های اضافی انجام شود.

کد اضافی

با استفاده از کد اضافی می توانید از معایب کد مستقیم جلوگیری کنید. یک الگوریتم ساده برای به دست آوردن کد اضافی یک عدد وجود دارد. بیایید سعی کنیم کد اضافی را برای عدد -5 دریافت کنیم. بیایید این عدد را با استفاده از کد مکمل دو در سیستم اعداد باینری نمایش دهیم. مرحله 1. با استفاده از کد مستقیم، نمایشی از یک عدد منفی به دست می آوریم. برای -5 10000101 خواهد بود. مرحله 2. همه ارقام به جز رقم علامت را معکوس کنید. بیایید همه صفرها را با یک، و یک ها را با صفر در همه جا به جز بیت سمت چپ جایگزین کنیم.

10000101 => 11111010

مرحله 3. یکی را به مقدار حاصل اضافه کنید:

11111010 + 1 = 11111011

آماده. ما مقدار -5 را در سیستم اعداد باینری با استفاده از کد مکمل دو به دست آوردیم. این برای درک مطالب زیر مهم است، زیرا جاوا از کد مکمل دو برای ذخیره اعداد منفی در بیت استفاده می کند.

انواع عملیات بیتی

اکنون که به تمام مقدمه ها پرداختیم، بیایید در مورد عملیات بیتی در جاوا صحبت کنیم. یک عملیات بیتی روی اعداد صحیح انجام می شود و نتیجه آن یک عدد صحیح است. در این فرآیند، عدد به باینری تبدیل می‌شود، عملیاتی روی هر بیت انجام می‌شود و نتیجه به اعشار تبدیل می‌شود. لیست عملیات در جدول زیر آمده است: همانطور که قبلا متوجه شدیم، اعداد را می توان به صورت مجموعه ای از بیت ها نشان داد. عملیات بیتی دقیقاً روی هر بیت از چنین نمایشی عملیات انجام می دهد. بیایید NOT،،،، . AND_ _ به یاد بیاورید که ما اخیراً به جداول صدق فقط برای عملوندهای منطقی نگاه کردیم. در این حالت، عملیات یکسانی برای هر بیت از عدد صحیح اعمال می شود. ORXOR

عملگر واحد بیتی NOT ~

این عملگر همه صفرها را با یک و همه یکها را با صفر جایگزین می کند. فرض کنید عدد 10 را در نماد اعشاری داریم. در باینری، این عدد 1010 است. اگر عملگر نفی بیتی تک واحدی را به این عدد اعمال کنیم، چیزی شبیه به این به دست می‌آید: بیایید نگاهی بیندازیم که در کد جاوا چه شکلی است:

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

این عملگر برای دو عدد اعمال می شود. ANDبین بیت های هر عدد عملیاتی را انجام می دهد . بیایید به یک مثال نگاه کنیم: این عملیات روی دو عدد انجام می شود. مثال در کد جاوا:

عملگر بیتی OR

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 به سمت راست را در متغیر می نویسیم.

• 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

تغییر بیتی به راست با لایه صفر

در حالی که یک شیفت بیت معمولی به راست علامت عدد را حفظ می کند (مهمترین بیت ارزش خود را حفظ می کند)، یک شیفت به راست پر از صفر این کار را نمی کند. و مهم ترین بیت با صفر پر می شود. بیایید ببینیم چگونه به نظر می رسد:

تقدم عملیات در جاوا

جاوا مانند ریاضیات دارای اولویت عملیات است. جدول زیر اولویت (از بالاترین به پایین ترین) عملیاتی که در نظر گرفتیم را نشان می دهد.

نمونه های مفید استفاده

تعیین برابری یک عدد

یافتن حداکثر عنصر در یک آرایه

برای یافتن حداقل عنصر، به سادگی علامت مقایسه را در جای مناسب تغییر دهید.