ข้อมูลเบื้องต้นเกี่ยวกับโอเปอเรเตอร์ Java: ตรรกะ, เลขคณิต, บิตไวส์

มาพูดถึงการดำเนินการใน Java: ตัวเลข, ตรรกะ, ระดับบิต นี่เป็นพื้นฐานทางทฤษฎีที่จำเป็นอย่างยิ่งในการเรียนรู้วิธีการเขียนโปรแกรม

• โอเปอเรเตอร์ประเภทใดบ้างใน Java?
• ตัวดำเนินการ Java ในหลักสูตร JavaRush
• การดำเนินการตัวเลขใน Java
• การดำเนินการเชิงตรรกะใน Java
• การดำเนินการ Bitwise ใน Java
• ลำดับความสำคัญของการดำเนินการใน Java
• ตัวอย่างการใช้งานที่เป็นประโยชน์

โอเปอเรเตอร์ประเภทใดบ้างใน Java?

สำหรับการดำเนินการใด ๆ เราต้องการอย่างน้อยสองสิ่ง:

• ผู้ประกอบการ;
• ตัวถูกดำเนินการ

ตัวอย่างของตัวดำเนินการจะเป็นข้อดีอย่างง่ายในการดำเนินการบวกตัวเลขสองตัว และตัวเลขที่บวกกันจะเป็นตัวถูกดำเนินการในกรณีนี้ ดังนั้นด้วยความช่วยเหลือจากโอเปอเรเตอร์ เราจึงดำเนินการกับโอเปอเรเตอร์ตั้งแต่หนึ่งตัวขึ้นไป ตัวดำเนินการที่ดำเนินการกับตัวถูกดำเนินการสองตัวเรียกว่าไบนารี เช่น การบวกเลขสองตัว ตัวดำเนินการที่ดำเนินการกับตัวถูกดำเนินการตัวเดียวเรียกว่าเอก ตัวอย่างเช่น ลบเอกนารี

ตัวดำเนินการ Java ในหลักสูตร JavaRush

การบรรยายหลายครั้งเน้นไปที่ตัวดำเนินการ Java ในระดับที่สี่ของภารกิจแรก - Java Syntax โดยเฉพาะอย่างยิ่ง ตัวดำเนินการ แบบมีเงื่อนไข เช่น boolean หลักสูตรประกอบด้วย 22 งานที่จะช่วยให้คุณเข้าใจงานของตัวดำเนินการเปรียบเทียบ ตัวดำเนินการตามเงื่อนไข และตัวดำเนินการเชิงตรรกะ

การดำเนินการตัวเลขใน Java

การดำเนินการทั่วไปที่โปรแกรมเมอร์ทำกับตัวเลขคือการกำหนดค่าตัวเลขให้กับตัวแปร เธอ=คุ้นเคยกับคุณเช่นเดียวกับผู้ดำเนินการ:

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 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. ตัวดำเนินการทางคณิตศาสตร์แบบ Unary: ตัวอย่างของเอกนารีบวกและลบ:

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);
• การดำเนินการแยกทางตรรกะหรือ ( OR);
• การดำเนินการเพิ่มเติมแบบโมดูโล พิเศษหรือ ( XOR)

ตัวดำเนินการปฏิเสธเป็นแบบเอกภาคและใช้กับตัวถูกดำเนินการตัวเดียว การดำเนินการอื่นๆ ทั้งหมดเป็นแบบไบนารี ลองพิจารณาตารางความจริงของการดำเนินการเหล่านี้ โดยที่0 เทียบเท่ากับfalseใน Java และ1เทียบเท่ากับtrue ตารางที่ 5. ตารางความจริงของตัวดำเนินการปฏิเสธ (NOT) ตารางที่ 6. ตารางความจริงของตัวดำเนินการร่วม (AND) ตารางที่ 7. ตารางความจริงของตัวดำเนินการแยก (OR) ตารางที่ 8. ตารางความจริงของตัวดำเนินการบวกแบบโมดูโล (XOR) Java มีการดำเนินการทางลอจิคัลเหมือนกัน:

• !— ตัวดำเนินการปฏิเสธ
• &&— ตรรกะและตัวดำเนินการ (สั้น);
• ||— ตรรกะหรือตัวดำเนินการ (สั้น);
• &— บิตและตัวดำเนินการ;
• |— ระดับบิตหรือตัวดำเนินการ;
• ^— ตัวดำเนินการหรือตัวดำเนินการพิเศษระดับบิต

ลองดูความแตกต่างระหว่างตัวดำเนินการระดับบิตและตัวดำเนินการชวเลขด้านล่างอีกเล็กน้อย ขณะที่แปลงตารางความจริงทั้งหมดเป็นโค้ด 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();
   }
}

โปรแกรมนี้จะแสดง: 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 หรือ 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 จริงหรือเท็จผลลัพธ์ของนิพจน์แรกจะเป็นเท็จและผลลัพธ์ของนิพจน์ที่สองจะเป็นจริง ดู. บางครั้งผลลัพธ์ของนิพจน์สามารถคำนวณได้จากตัวถูกดำเนินการตัวแรก นี่คือสิ่งที่ทำให้ตัวดำเนินการแบบย่อ&&และ ||ในนิพจน์ที่คล้ายกับที่อธิบายไว้ข้างต้น จะไม่ประเมินค่าของตัวถูกดำเนินการที่สอง นี่เป็นตัวอย่างเล็กๆ น้อยๆ: ในกรณีของตัวดำเนินการชวเลข ส่วนที่สองของนิพจน์จะไม่ได้รับการประเมิน แต่สิ่งนี้จะเกิดขึ้นก็ต่อเมื่อผลลัพธ์ของนิพจน์ชัดเจนตั้งแต่ตัวถูกดำเนินการตัวแรกแล้ว

การดำเนินการ Bitwise ใน Java

เรามาถึงส่วนที่น่าสนใจที่สุดแล้ว: การดำเนินการระดับบิต ตามชื่อที่แนะนำ สิ่งเหล่านี้คือการดำเนินการที่ดำเนินการกับบิต แต่ก่อนที่เราจะเจาะลึกหัวข้อนี้ เราควรพูดถึงประเด็นที่เกี่ยวข้องเสียก่อน

การแสดงตัวเลขในระบบเลขฐานสอง

ตัวเลขก็เหมือนกับข้อมูลอื่นๆ ในโปรแกรม ที่ถูกจัดเก็บไว้ในหน่วยความจำคอมพิวเตอร์ในรูปแบบรหัสไบนารี่ รหัสไบนารี่คือชุดของศูนย์และหน่วย แต่ละศูนย์หรือหนึ่งแทนหน่วยข้อมูลที่เรียกว่าบิต

ตามวิกิพีเดีย:

บิต (จากเลขฐานสองภาษาอังกฤษ - เลขฐานสองและการเล่นคำ: บิตภาษาอังกฤษ - ชิ้นอนุภาค) เป็นหน่วยวัดปริมาณข้อมูล ข้อมูล 1 บิตเป็นสัญลักษณ์หรือสัญญาณที่มีความหมายสองความหมาย: เปิดหรือปิด, ใช่หรือไม่ใช่, สูงหรือต่ำ, มีประจุหรือไม่มีประจุ; ในระบบไบนารี่คือ 1 (หนึ่ง) หรือ 0 (ศูนย์)

ตัวดำเนินการระดับบิตทำงานกับข้อมูลประเภทใด

การดำเนินการระดับบิตใน 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) แต่ขอกลับมาใกล้กับ Java อีกครั้ง มีประเภทข้อมูลจำนวนเต็ม - byte. ประเภทนี้สามารถรับค่าได้ตั้งแต่ -128 ถึง 127 และตัวเลขหนึ่งในหน่วยความจำคอมพิวเตอร์ใช้เวลาถึง 8 บิตหรือ 1 ไบต์พอดี หนึ่งในประเภทนี้ใช้byteหน่วยความจำคอมพิวเตอร์ 1 หน่วย และที่นี่ชื่อไม่ตรงกันโดยบังเอิญ อย่างที่เราจำได้ 1 ไบต์สามารถเก็บค่าที่แตกต่างกันได้ 256 ค่า และหมายเลขประเภทหนึ่งbyteสามารถรับค่าที่แตกต่างกันได้ 256 ค่า (ลบ 128 ค่าบวก 127 ค่าและศูนย์ 1 ค่า) ค่าตัวเลขแต่ละค่าbyteมีชุดแปดบิตที่ไม่ซ้ำกัน นี่เป็นกรณีนี้ไม่เพียงแต่กับ type เท่านั้นbyteแต่ยังรวมถึงประเภทอินทิกรัลทั้งหมดด้วย ประเภทbyteจะได้รับเป็นตัวอย่างที่เล็กที่สุด ตารางด้านล่างแสดงประเภทจำนวนเต็ม Java ทั้งหมดและพื้นที่หน่วยความจำที่ใช้: พิจารณาประเภท intสามารถเก็บค่าลบ 2147483648 ค่าบวก 2147483647 และศูนย์หนึ่งตัว ทั้งหมด:

2147483648 + 2147483647 + 1 = 4294967296.

ประเภทนี้ใช้หน่วยความจำคอมพิวเตอร์ถึง 32 บิต จำนวนชุดค่าผสมที่เป็นไปได้จากชุดศูนย์ 32 ตัวและหนึ่งชุดคือ:

232 = 4294967296.

ตัวเลขเดียวกันกับจำนวนค่าที่ประเภทสามารถเก็บintได้ นี่เป็นเพียงการสาธิตความสัมพันธ์ระหว่างช่วงของค่าของชนิดข้อมูลและขนาดของมัน (จำนวนบิตในหน่วยความจำ) Java ทุกประเภทสามารถแปลงเป็นไบนารี่ได้ มาดูกันว่าสามารถทำได้ง่ายแค่ไหนโดยใช้ภาษา Java เราจะเรียนรู้จากตัวอย่างintประเภท ประเภทนี้มีคลาส wrapper ของตัวเอง - Integer. และเขามีหนึ่งtoBinaryStringซึ่งจะทำงานทั้งหมดให้เรา: Voila - มันไม่ซับซ้อนขนาดนั้น แต่ถึงกระนั้นก็มีบางสิ่งที่ต้องชี้แจง intหมายเลขใช้เวลา 32 บิต แต่เมื่อเราพิมพ์เลข 10 ในตัวอย่างด้านบน เราจะเห็น 1010 ในคอนโซล เนื่องจากไม่ได้พิมพ์เลขศูนย์นำหน้า หากแสดงขึ้น แทนที่จะเป็น 1,010 เราจะเห็น 000000000000000000000000000001010 ในคอนโซล แต่เพื่อความสะดวกในการรับรู้ ระบบจะละเว้นศูนย์นำหน้าทั้งหมด ไม่ยากจนกว่าคุณจะถามตัวเองว่า แล้วจำนวนลบล่ะ? รับรู้ข้อมูลเฉพาะในระบบไบนารี่เท่านั้น ปรากฎว่าต้องเขียนเครื่องหมายลบด้วยรหัสไบนารี่ด้วย ซึ่งสามารถทำได้โดยใช้โค้ดโดยตรงหรือโค้ดเสริม

รหัสตรง

วิธีการแสดงตัวเลขในระบบเลขฐานสอง ซึ่งบิตที่มีนัยสำคัญที่สุด (บิตซ้ายสุด) จะถูกจัดสรรให้กับเครื่องหมายของตัวเลข ถ้าตัวเลขเป็นบวก บิตซ้ายสุดจะเขียนเป็น 0 ถ้าเป็นลบ - 1 ลองดูสิ่งนี้โดยใช้ตัวเลข 8 บิตเป็นตัวอย่าง: วิธีการนี้ง่ายและโดยหลักการแล้วสามารถเข้าใจได้ อย่างไรก็ตาม มีข้อเสียคือ มีความยากในการดำเนินการทางคณิตศาสตร์ เช่น การบวกจำนวนลบและจำนวนบวก ไม่สามารถพับเก็บได้เว้นแต่จะมีการดำเนินการเพิ่มเติม

รหัสเพิ่มเติม

โดยใช้โค้ดเพิ่มเติม คุณสามารถหลีกเลี่ยงข้อเสียของโค้ดโดยตรงได้ มีอัลกอริธึมง่ายๆ ในการรับรหัสเพิ่มเติมของตัวเลข ลองรับรหัสเพิ่มเติมสำหรับหมายเลข -5 เรามาแทนตัวเลขนี้โดยใช้โค้ดเสริมของสองตัวในระบบเลขฐานสองกัน ขั้นตอนที่ 1 เราได้รับการแสดงจำนวนลบโดยใช้โค้ดโดยตรง สำหรับ -5 จะเป็น 10000101 ขั้นตอนที่ 2 กลับตัวเลขทั้งหมดยกเว้นตัวเลขเครื่องหมาย ลองแทนที่ศูนย์ทั้งหมดด้วยศูนย์ และแทนที่ศูนย์ทุกจุดยกเว้นบิตซ้ายสุด

10000101 => 11111010

ขั้นตอนที่ 3 เพิ่มหนึ่งค่าลงในค่าผลลัพธ์:

11111010 + 1 = 11111011

พร้อม. เราได้ค่า -5 ในระบบเลขฐานสองโดยใช้โค้ดเสริมของ two นี่เป็นสิ่งสำคัญสำหรับการทำความเข้าใจเนื้อหาต่อไปนี้ เนื่องจาก Java ใช้โค้ดเสริมของ two เพื่อเก็บตัวเลขลบเป็นบิต

ประเภทของการดำเนินการระดับบิต

ตอนนี้เราได้จัดการกับการแนะนำทั้งหมดแล้ว เรามาพูดถึงการดำเนินการระดับบิตใน Java กันดีกว่า การดำเนินการระดับบิตจะดำเนินการกับจำนวนเต็มและผลลัพธ์จะเป็นจำนวนเต็ม ในกระบวนการนี้ ตัวเลขจะถูกแปลงเป็นไบนารี่ การดำเนินการจะดำเนินการกับแต่ละบิต และผลลัพธ์จะถูกแปลงกลับเป็นทศนิยม รายการการดำเนินการอยู่ในตารางด้านล่าง: ดังที่เราได้ทราบไปแล้ว ตัวเลขสามารถแสดงเป็นชุดของบิตได้ การดำเนินการระดับบิตจะดำเนินการกับแต่ละบิตของการเป็นตัวแทนดังกล่าว เอาล่ะNOT, AND, OR, XOR. จำได้ว่าเมื่อเร็ว ๆ นี้เราได้ดูตารางความจริงสำหรับตัวถูกดำเนินการเชิงตรรกะเท่านั้น ในกรณีนี้ การดำเนินการเดียวกันจะถูกนำไปใช้กับแต่ละบิตของจำนวนเต็ม

ตัวดำเนินการเอกภาค Bitwise ไม่ใช่ ~

โอเปอเรเตอร์นี้จะแทนที่ศูนย์ทั้งหมดด้วยศูนย์ และแทนที่ศูนย์ทั้งหมดด้วยศูนย์ สมมติว่าเรามีเลข 10 ในรูปแบบทศนิยม ในไบนารี่ ตัวเลขนี้คือ 1010 หากเราใช้ตัวดำเนินการปฏิเสธระดับบิตแบบเอกนารีกับตัวเลขนี้ เราจะได้ดังนี้: มาดูกันว่าโค้ด 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ระหว่างบิตของแต่ละตัวเลข ลองดูตัวอย่าง: การดำเนินการนี้ดำเนินการกับตัวเลขสองตัว ตัวอย่างในโค้ด Java:

ตัวดำเนินการ Bitwise หรือ

หรือใช้กับตัวเลขสองตัว โดยจะทำการดำเนินการ OR ระหว่างบิตของแต่ละตัวเลข มาดูกันว่า IDEA จะเป็นอย่างไร:

การดำเนินการระดับบิต เอกสิทธิ์หรือ (XOR)

ลองดูตัวอย่างเดียวกัน แต่มีการดำเนินการใหม่: โค้ดตัวอย่าง:

เลื่อนไปทางซ้ายเป็นบิต

โอเปอเรเตอร์นี้สามารถใช้ได้กับตัวถูกดำเนินการสองตัว กล่าวคือ ในการดำเนินการx << yบิตของตัวเลขxจะเลื่อนyตำแหน่งไปทางซ้าย มันหมายความว่าอะไร? มาดูตัวอย่างการดำเนินการกัน10 << 1 ผลลัพธ์ของการดำเนินการจะเป็นเลข 20 ในระบบทศนิยม ดังที่คุณเห็นจากแผนภาพด้านบน บิตทั้งหมดจะถูกเลื่อนไปทางซ้าย 1 ในระหว่างการดำเนินการนี้ ค่าของบิตที่สำคัญที่สุด (บิตซ้ายสุด) จะหายไป และบิตที่มีนัยสำคัญน้อยที่สุด (บิตขวาสุด) จะถูกเติมด้วยศูนย์ คุณจะพูดอะไรเกี่ยวกับการดำเนินการนี้?

1. โดยการเลื่อนบิตของตัวเลขXไปNทางซ้าย เราจะคูณตัวเลขด้วยX2 ^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 ยกกำลังN2 สาธิต:

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

เลื่อนไปทางขวาแบบ Bitwise โดยไม่มีช่องว่างภายในเป็นศูนย์

แม้ว่าการเลื่อนไปทางขวาแบบปกติจะรักษาเครื่องหมายของตัวเลขไว้ (บิตที่สำคัญที่สุดจะคงค่าไว้) แต่การเลื่อนไปทางขวาแบบเติมศูนย์จะไม่เป็นเช่นนั้น และบิตที่สำคัญที่สุดจะเต็มไปด้วยศูนย์ มาดูกันว่ามีลักษณะอย่างไร:

ลำดับความสำคัญของการดำเนินการใน Java

เช่นเดียวกับคณิตศาสตร์ Java มีความสำคัญเหนือกว่าการดำเนินการ ตารางด้านล่างแสดงลำดับความสำคัญ (จากสูงสุดไปต่ำสุด) ของการดำเนินการที่เราพิจารณา

ตัวอย่างการใช้งานที่เป็นประโยชน์

การกำหนดความเท่าเทียมกันของตัวเลข

การค้นหาองค์ประกอบสูงสุดในอาร์เรย์

หากต้องการค้นหาองค์ประกอบขั้นต่ำ เพียงเปลี่ยนเครื่องหมายเปรียบเทียบในตำแหน่งที่ถูกต้อง