โ˜•Java

[Java ์ดํ•ดํ•˜๊ธฐ] 4. ์ž๋ฐ”์˜ ์—ฐ์‚ฐ์ž

Luvbit 2024. 4. 26. 19:03


 

 

๐Ÿฉท Java์˜ ์—ฐ์‚ฐ์ž๋ž€?

Java์—์„œ์˜ ์—ฐ์‚ฐ์ž(Operators)๋Š” ํŠน์ •ํ•œ ์—ฐ์‚ฐ์„ ์ˆ˜ํ–‰ํ•˜๋„๋ก ์„ค๊ณ„๋œ ๊ธฐํ˜ธ์ž…๋‹ˆ๋‹ค.
์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋ณ€์ˆ˜์™€ ๊ฐ’์— ๋‹ค์–‘ํ•œ ์ข…๋ฅ˜์˜ ์—ฐ์‚ฐ์„ ์ ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

 

 

 

 

 

 

๐Ÿ’› ์—ฐ์‚ฐ์ž์˜ ์ข…๋ฅ˜ 

 


1๏ธโƒฃ์‚ฐ์ˆ  ์—ฐ์‚ฐ์ž

์‚ฐ์ˆ  ์—ฐ์‚ฐ์ž๋Š” ํ”ํžˆ๋“ค ์•Œ๊ณ  ๊ณ„์‹œ๋Š” ๋ฐ”์™€ ๊ฐ™์ด ์‚ฌ์น™์—ฐ์‚ฐ ๊ฐ™์€ ๋”ํ•˜๊ธฐ , ๋นผ๊ธฐ ๋“ฑ์ด ์ด์— ํ•ด๋‹น๋ฉ๋‹ˆ๋‹ค. ์ž๋ฐ”์˜ ์—ฐ์‚ฐ์ž๋Š” ์กฐ๊ธˆ ๋” ์ข…๋ฅ˜๊ฐ€ ๋‹ค์–‘ํ•œ๋ฐ, ์—ฐ์‚ฐ์ž์˜ ์ข…๋ฅ˜๋ฅผ ์ƒ์„ธํ•˜๊ฒŒ ์„ค๋ช…๋“œ๋ฆฌ๊ฒ ์Šต๋‹ˆ๋‹ค.

 

1. ๋ง์…ˆ ์—ฐ์‚ฐ์ž ( + )

  • ๋‘ ๊ฐœ์˜ ํ”ผ์—ฐ์‚ฐ์ž๋ฅผ ๋”ํ•ฉ๋‹ˆ๋‹ค.
  • ์ˆ˜์น˜ํ˜• ๋ฐ์ดํ„ฐ๋ฟ๋งŒ ์•„๋‹ˆ๋ผ, ๋ฌธ์ž์—ด ์—ฐ๊ฒฐ์—๋„ ์‚ฌ์šฉ๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
int a = 1;
int b = 2;
int c = a + b;  // c์˜ ๊ฐ’์€ 3

String hello = "Hello, ";
String rabbit = "Rabbit!";
String greeting = hello + rabbit;  // greeting์˜ ๊ฐ’์€ "Hello, Rabbit!"

 

2. ๋บ„์…ˆ ์—ฐ์‚ฐ์ž  ( - )

  • ์™ผ์ชฝ ํ”ผ์—ฐ์‚ฐ์ž์—์„œ ์˜ค๋ฅธ์ชฝ ํ”ผ์—ฐ์‚ฐ์ž๋ฅผ ๋บ๋‹ˆ๋‹ค.
int a = 5;
int b = 3;
int c = a - b;  // c์˜ ๊ฐ’์€ 2

 

3. ๊ณฑ์…ˆ ์—ฐ์‚ฐ์ž  ( * )

  • ๋‘ ๊ฐœ์˜ ํ”ผ์—ฐ์‚ฐ์ž๋ฅผ ๊ณฑํ•ฉ๋‹ˆ๋‹ค.
int a = 2;
int b = 3;
int c = a * b;  // c์˜ ๊ฐ’์€ 6

 

4. ๋‚˜๋ˆ—์…ˆ ์—ฐ์‚ฐ์ž  ( / )

 

  • ์™ผ์ชฝ ํ”ผ์—ฐ์‚ฐ์ž๋ฅผ ์˜ค๋ฅธ์ชฝ ํ”ผ์—ฐ์‚ฐ์ž๋กœ ๋‚˜๋ˆ•๋‹ˆ๋‹ค.
  • ์ •์ˆ˜ ๋‚˜๋ˆ—์…ˆ์˜ ๊ฒฝ์šฐ, ๊ฒฐ๊ณผ๋Š” ์ •์ˆ˜๋กœ์„œ ๋‚˜๋จธ์ง€๋ฅผ ๋ฒ„๋ฆฌ๊ณ  ๋ชซ๋งŒ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค
  • . ๋ถ€๋™ ์†Œ์ˆ˜์  ๋‚˜๋ˆ—์…ˆ์˜ ๊ฒฝ์šฐ, ์ •ํ™•ํ•œ ์†Œ์ˆ˜ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
int a = 10;
int b = 3;
int c = a / b;  // c์˜ ๊ฐ’์€ 3 (์ •์ˆ˜ ๋‚˜๋ˆ—์…ˆ)

double x = 10.0;
double y = 3.0;
double z = x / y;  // z์˜ ๊ฐ’์€ 3.33... (๋ถ€๋™ ์†Œ์ˆ˜์  ๋‚˜๋ˆ—์…ˆ)

 

5. ๋‚˜๋จธ์ง€ ์—ฐ์‚ฐ์ž  ( % ) 

  • ์™ผ์ชฝ ํ”ผ์—ฐ์‚ฐ์ž๋ฅผ ์˜ค๋ฅธ์ชฝ ํ”ผ์—ฐ์‚ฐ์ž๋กœ ๋‚˜๋ˆ„๊ณ  ๋‚œ ๋‚˜๋จธ์ง€๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
  • ์ด ์—ฐ์‚ฐ์ž๋Š” ๋‚˜๋ˆ—์…ˆ์˜ ๋‚˜๋จธ์ง€๋ฅผ ๊ตฌํ•  ๋•Œ ์œ ์šฉํ•˜๋ฉฐ, ์ˆซ์ž๊ฐ€ ์–ด๋–ค ๊ฐ’์œผ๋กœ ๋‚˜๋ˆ„์–ด ๋–จ์–ด์ง€๋Š”์ง€ ํ™•์ธํ•  ๋•Œ ์ž์ฃผ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค.
int a = 10;
int b = 3;
int c = a % b;  // c์˜ ๊ฐ’์€ 1

int d = 4;
int e = 2;
int f = d % e;  // f์˜ ๊ฐ’์€ 0

 


2๏ธโƒฃ๋น„๊ต ์—ฐ์‚ฐ์ž

๋น„๊ต ์—ฐ์‚ฐ์ž๋Š” ๋‘ ๊ฐ’์„ ๋น„๊ตํ•˜๊ณ  ๊ทธ ๊ฒฐ๊ณผ๋กœ ๋…ผ๋ฆฌ์ ์ธ ๊ฐ’์ธ true ๋˜๋Š” false๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

 

1. ๋™๋“ฑ ์—ฐ์‚ฐ์ž ( '==' )

  • ๋‘ ํ”ผ์—ฐ์‚ฐ์ž์˜ ๊ฐ’์ด ๊ฐ™์€์ง€ ๋น„๊ตํ•ฉ๋‹ˆ๋‹ค.
  • ๊ฐ™์œผ๋ฉด true, ๋‹ค๋ฅด๋ฉด false๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
int a = 10;
int b = 20;
boolean result = (a == b)  // true

 

  •  

2. ๋ถ€๋“ฑ ์—ฐ์‚ฐ์ž ( '!=' )

  • ๋‘ ํ”ผ์—ฐ์‚ฐ์ž์˜ ๊ฐ’์ด ๊ฐ™์€์ง€ ๋น„๊ตํ•ฉ๋‹ˆ๋‹ค.
  • ๊ฐ™์œผ๋ฉด true, ๋‹ค๋ฅด๋ฉด false๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
int a = 10;
int b = 20;
boolean result = (a != b);  // true

 

3. ํฌ๋‹ค ์—ฐ์‚ฐ์ž ( '>' )

  • ๋‘ ํ”ผ์—ฐ์‚ฐ์ž์˜ ๊ฐ’์ด ๊ฐ™์€์ง€ ๋น„๊ตํ•ฉ๋‹ˆ๋‹ค.
  • ๊ฐ™์œผ๋ฉด true, ๋‹ค๋ฅด๋ฉด false๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
int a = 15;
int b = 10;
boolean result = (a > b);  // true

 

4. ์ž‘๋‹ค ์—ฐ์‚ฐ์ž ( '<' )

  • ๋‘ ํ”ผ์—ฐ์‚ฐ์ž์˜ ๊ฐ’์ด ๊ฐ™์€์ง€ ๋น„๊ตํ•ฉ๋‹ˆ๋‹ค.
  • ๊ฐ™์œผ๋ฉด true, ๋‹ค๋ฅด๋ฉด false๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
int a = 10;
int b = 15;
boolean result = (a < b);  // true

 

5. ํฌ๊ฑฐ๋‚˜ ์ž‘๋‹ค ์—ฐ์‚ฐ์ž ( '>=' )

  • ๋‘ ํ”ผ์—ฐ์‚ฐ์ž์˜ ๊ฐ’์ด ๊ฐ™์€์ง€ ๋น„๊ตํ•ฉ๋‹ˆ๋‹ค.
  • ๊ฐ™์œผ๋ฉด true, ๋‹ค๋ฅด๋ฉด false๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
int a = 15;
int b = 15;
boolean result = (a >= b);  // true

 

6. ์ž‘๊ฑฐ๋‚˜ ๊ฐ™๋‹ค ์—ฐ์‚ฐ์ž ( '<=' )

  • ๋‘ ํ”ผ์—ฐ์‚ฐ์ž์˜ ๊ฐ’์ด ๊ฐ™์€์ง€ ๋น„๊ตํ•ฉ๋‹ˆ๋‹ค.
  • ๊ฐ™์œผ๋ฉด true, ๋‹ค๋ฅด๋ฉด false๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
int a = 10;
int b = 15;
boolean result = (a <= b);  // true

 


3๏ธโƒฃ๋…ผ๋ฆฌ ์—ฐ์‚ฐ์ž

๋…ผ๋ฆฌ ์—ฐ์‚ฐ์ž๋Š” ์ฃผ๋กœ ๋…ผ๋ฆฌ์ ์ธ ์กฐ๊ฑด์„ ํ‰๊ฐ€ํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค.

 

 

 1. AND ์—ฐ์‚ฐ์ž  ( '&&' )

  • ๋‘ ์กฐ๊ฑด ๋ชจ๋‘ true์ผ ๋•Œ๋งŒ ๊ฒฐ๊ณผ๊ฐ€ true๊ฐ€ ๋ฉ๋‹ˆ๋‹ค. 
  • ์ฒซ ๋ฒˆ์งธ ์กฐ๊ฑด์ด false์ด๋ฉด, ๋‘ ๋ฒˆ์งธ ์กฐ๊ฑด์€ ๊ฒ€์ฆํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.
boolean a = true;
boolean b = false;
boolean c = true;
boolean result = a && b;  // false
boolean result2 = a && c; // true

 

 2. OR ์—ฐ์‚ฐ์ž ( ' || ' )

  • ๋‘ ์กฐ๊ฑด ์ค‘ ํ•˜๋‚˜๋ผ๋„ 'true'์ด๋ฉด ๊ฒฐ๊ณผ๊ฐ€ 'true'๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.
  • ์ฒซ ๋ฒˆ์งธ ์กฐ๊ฑด์ด true์ด๋ฉด, ๋‘ ๋ฒˆ์งธ ์กฐ๊ฑด์€ ๊ฒ€์ฆํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.
boolean a = true;
boolean b = false;
boolean result = a || b;  // true
boolean result2 = b || b; // false

 

 3. NOT ์—ฐ์‚ฐ์ž ( ' ! ' )

  • ๋‹จ์ผ ์กฐ๊ฑด์˜ ๋…ผ๋ฆฌ ๊ฐ’์„ ๋ฐ˜์ „์‹œํ‚ต๋‹ˆ๋‹ค.
  • 'true'๋Š” 'false'๋กœ, 'false'๋Š” 'true'๋กœ ๋ณ€ํ™˜๋ฉ๋‹ˆ๋‹ค.
boolean a = true;
boolean result = !a;  // false

 

4๏ธโƒฃํ• ๋‹น ์—ฐ์‚ฐ์ž

ํ• ๋‹น ์—ฐ์‚ฐ์ž๋Š” ๋ณ€์ˆ˜์— ๊ฐ’์„ ํ• ๋‹นํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋˜๋Š” ์—ฐ์‚ฐ์ž์ž…๋‹ˆ๋‹ค

 

 

 1. ๊ธฐ๋ณธ ํ• ๋‹น ์—ฐ์‚ฐ์ž ( ' = ' )

  • ๊ฐ€์žฅ ๊ธฐ๋ณธ์ ์ธ ํ• ๋‹น ์—ฐ์‚ฐ์ž๋กœ, ์˜ค๋ฅธ์ชฝ ํ”ผ์—ฐ์‚ฐ์ž์˜ ๊ฐ’์„ ์™ผ์ชฝ ํ”ผ์—ฐ์‚ฐ์ž(๋ณ€์ˆ˜)์— ์ €์žฅํ•ฉ๋‹ˆ๋‹ค.
int a = 10;  // a ๋ณ€์ˆ˜์— 10์„ ํ• ๋‹น

 

 2. ๋ง์…ˆ ํ• ๋‹น ์—ฐ์‚ฐ์ž ( ' += ' )

  • ์™ผ์ชฝ ๋ณ€์ˆ˜์— ์˜ค๋ฅธ์ชฝ ๊ฐ’์„ ๋”ํ•˜๊ณ  ๊ฒฐ๊ณผ๋ฅผ ์™ผ์ชฝ ๋ณ€์ˆ˜์— ์ €์žฅํ•ฉ๋‹ˆ๋‹ค.
int a = 5;
a += 3;  // a = a + 3๊ณผ ๋™์ผ, a๋Š” ์ด์ œ 8

 

 

 3. ๋บ„์…ˆ ํ• ๋‹น ์—ฐ์‚ฐ์ž ( ' -= ' )

  • ์™ผ์ชฝ ๋ณ€์ˆ˜์—์„œ ์˜ค๋ฅธ์ชฝ ๊ฐ’์„ ๋นผ๊ณ  ๊ฒฐ๊ณผ๋ฅผ ์™ผ์ชฝ ๋ณ€์ˆ˜์— ์ €์žฅํ•ฉ๋‹ˆ๋‹ค.
int a = 5;
a -= 2;  // a = a - 2์™€ ๋™์ผ, a๋Š” ์ด์ œ 3

 

 4. ๊ณฑ์…ˆ ํ• ๋‹น ์—ฐ์‚ฐ์ž ( ' *= ' )

  • ์™ผ์ชฝ ๋ณ€์ˆ˜์— ์˜ค๋ฅธ์ชฝ ๊ฐ’์„ ๊ณฑํ•˜๊ณ  ๊ฒฐ๊ณผ๋ฅผ ์™ผ์ชฝ ๋ณ€์ˆ˜์— ์ €์žฅํ•ฉ๋‹ˆ๋‹ค.
int a = 5;
a *= 2;  // a = a * 2์™€ ๋™์ผ, a๋Š” ์ด์ œ 10

 

 5. ๋‚˜๋ˆ—์…ˆ ํ• ๋‹น ์—ฐ์‚ฐ์ž ( ' /= ' )

  • ์™ผ์ชฝ ๋ณ€์ˆ˜๋ฅผ ์˜ค๋ฅธ์ชฝ ๊ฐ’์œผ๋กœ ๋‚˜๋ˆ„๊ณ  ๊ฒฐ๊ณผ๋ฅผ ์™ผ์ชฝ ๋ณ€์ˆ˜์— ์ €์žฅํ•ฉ๋‹ˆ๋‹ค.
int a = 10;
a /= 2;  // a = a / 2์™€ ๋™์ผ, a๋Š” ์ด์ œ 5

 


 

 

5๏ธโƒฃ๋น„ํŠธ ์—ฐ์‚ฐ์ž

Java์—์„œ ๋น„ํŠธ ์—ฐ์‚ฐ์ž๋Š” ์ •์ˆ˜ ํƒ€์ž…์˜ ๋ฐ์ดํ„ฐ์— ๋Œ€ํ•ด ๋น„ํŠธ ๋‹จ์œ„๋กœ ์—ฐ์‚ฐ์„ ์ˆ˜ํ–‰ํ•˜๋Š” ์—ฐ์‚ฐ์ž

 

AND
์—ฐ์‚ฐ์ž (&)
๋‘ ํ”ผ์—ฐ์‚ฐ์ž์˜ ๋น„ํŠธ๋ฅผ ๋น„๊ตํ•˜์—ฌ ๋‘˜ ๋‹ค 1์ด๋ฉด ๊ฒฐ๊ณผ์˜ ํ•ด๋‹น ๋น„ํŠธ๋ฅผ 1๋กœ, ํ•˜๋‚˜๋ผ๋„ 0์ด๋ฉด 0์œผ๋กœ ์„ค์ •ํ•ฉ๋‹ˆ๋‹ค. 5 & 3 (์ด์ง„์ˆ˜๋กœ 0101 & 0011)์˜ ๊ฒฐ๊ณผ๋Š” 0001์ด๋ฏ€๋กœ, ๊ฒฐ๊ณผ๋Š” 1์ž…๋‹ˆ๋‹ค.
OR
์—ฐ์‚ฐ์ž
( | )
๋‘ ํ”ผ์—ฐ์‚ฐ์ž์˜ ๋น„ํŠธ๋ฅผ ๋น„๊ตํ•˜์—ฌ ํ•˜๋‚˜๋ผ๋„ 1์ด๋ฉด ๊ฒฐ๊ณผ์˜ ํ•ด๋‹น ๋น„ํŠธ๋ฅผ 1๋กœ, ๋‘˜ ๋‹ค 0์ด๋ฉด 0์œผ๋กœ ์„ค์ •ํ•ฉ๋‹ˆ๋‹ค. 5 | 3 (์ด์ง„์ˆ˜๋กœ 0101 | 0011)์˜ ๊ฒฐ๊ณผ๋Š” 0111์ด๋ฏ€๋กœ, ๊ฒฐ๊ณผ๋Š” 7์ž…๋‹ˆ๋‹ค.
XOR
์—ฐ์‚ฐ์ž (^)
๋‘ ํ”ผ์—ฐ์‚ฐ์ž์˜ ๋น„ํŠธ๋ฅผ ๋น„๊ตํ•˜์—ฌ ๋น„ํŠธ๊ฐ€ ์„œ๋กœ ๋‹ค๋ฅด๋ฉด ๊ฒฐ๊ณผ์˜ ํ•ด๋‹น ๋น„ํŠธ๋ฅผ 1๋กœ, ๊ฐ™์œผ๋ฉด 0์œผ๋กœ ์„ค์ •ํ•ฉ๋‹ˆ๋‹ค. ์ด ์—ฐ์‚ฐ์€ ๋‘ ๊ฐ’์˜ ์ฐจ์ด๋ฅผ ๊ฒ€์ถœํ•˜๋Š” ๋ฐ ์œ ์šฉํ•ฉ๋‹ˆ๋‹ค. 5 ^ 3 (์ด์ง„์ˆ˜๋กœ 0101 ^ 0011)์˜ ๊ฒฐ๊ณผ๋Š” 0110์ด๋ฏ€๋กœ, ๊ฒฐ๊ณผ๋Š” 6์ž…๋‹ˆ๋‹ค.
NOT
์—ฐ์‚ฐ์ž (~)
๋‹จ์ผ ํ”ผ์—ฐ์‚ฐ์ž์˜ ๋ชจ๋“  ๋น„ํŠธ๋ฅผ ๋ฐ˜์ „์‹œํ‚ต๋‹ˆ๋‹ค. 1์€ 0์œผ๋กœ, 0์€ 1๋กœ ๋ฐ”๋€๋‹ˆ๋‹ค. ์ด ์—ฐ์‚ฐ์ž๋Š” ๋ณด์ˆ˜๋ฅผ ๊ตฌํ•  ๋•Œ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ~5 (์ด์ง„์ˆ˜๋กœ ~0101)์˜ ๊ฒฐ๊ณผ๋Š” 1010 (2์˜ ๋ณด์ˆ˜ ํ‘œํ˜„์—์„œ๋Š” -6)์ž…๋‹ˆ๋‹ค. ์‹ค์ œ ๊ฒฐ๊ณผ๋Š” ๋ชจ๋“  ๋น„ํŠธ๊ฐ€ ๋ฐ˜์ „๋˜๊ณ , ์ถ”๊ฐ€ ๋น„ํŠธ๋“ค๋„ ๋ฐ˜์ „๋˜์–ด ์Œ์ˆ˜ ๊ฐ’์ด ๋ฉ๋‹ˆ๋‹ค.
Left
Shift (<<)
ํ”ผ์—ฐ์‚ฐ์ž์˜ ๋ชจ๋“  ๋น„ํŠธ๋ฅผ ์ง€์ •๋œ ์ˆ˜๋งŒํผ ์™ผ์ชฝ์œผ๋กœ ์ด๋™์‹œํ‚ต๋‹ˆ๋‹ค. ์ƒˆ๋กœ ์ƒ๊ธฐ๋Š” ๋น„ํŠธ๋Š” 0์œผ๋กœ ์ฑ„์›Œ์ง‘๋‹ˆ๋‹ค. ์ด ์—ฐ์‚ฐ์€ ์ฃผ๋กœ ๊ฐ’์„ ๋น ๋ฅด๊ฒŒ ๊ณฑํ•˜๊ธฐ ์œ„ํ•ด ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. 5 << 1์€ 0101์„ ์™ผ์ชฝ์œผ๋กœ ํ•œ ๋น„ํŠธ ์ด๋™์‹œํ‚ต๋‹ˆ๋‹ค. ๊ฒฐ๊ณผ๋Š” 1010, ์ฆ‰ 10์ž…๋‹ˆ๋‹ค.
Right
Shift (>>)
ํ”ผ์—ฐ์‚ฐ์ž์˜ ๋ชจ๋“  ๋น„ํŠธ๋ฅผ ์ง€์ •๋œ ์ˆ˜๋งŒํผ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ์ด๋™์‹œํ‚ต๋‹ˆ๋‹ค. ์ƒˆ๋กœ ์ƒ๊ธฐ๋Š” ๋น„ํŠธ๋Š” ํ”ผ์—ฐ์‚ฐ์ž์˜ ์ตœ์ƒ์œ„ ๋น„ํŠธ(๋ถ€ํ˜ธ ๋น„ํŠธ)์™€ ๊ฐ™์€ ๊ฐ’์œผ๋กœ ์ฑ„์›Œ์ง‘๋‹ˆ๋‹ค (์ด๋Š” ๋ถ€ํ˜ธ ์žˆ๋Š” ์˜ค๋ฅธ์ชฝ ์‹œํ”„ํŠธ๋กœ, ๋ถ€ํ˜ธ๋ฅผ ์œ ์ง€ํ•ฉ๋‹ˆ๋‹ค). -10 >> 2๋Š” -10 (์ด์ง„์ˆ˜๋กœ 11110110์—์„œ 2๊ฐœ์˜ ์˜ค๋ฅธ์ชฝ ์‹œํ”„ํŠธ)์„ ๊ณ„์‚ฐํ•ฉ๋‹ˆ๋‹ค. ๊ฒฐ๊ณผ๋Š” -3์ž…๋‹ˆ๋‹ค.
Unsigned Right Shift (>>>) ํ”ผ์—ฐ์‚ฐ์ž์˜ ๋ชจ๋“  ๋น„ํŠธ๋ฅผ ์ง€์ •๋œ ์ˆ˜๋งŒํผ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ์ด๋™์‹œํ‚ค๋ฉฐ, ์ตœ์ƒ์œ„ ๋น„ํŠธ๋Š” 0์œผ๋กœ ์ฑ„์›Œ์ง‘๋‹ˆ๋‹ค. ์ด ์—ฐ์‚ฐ์€ ๋ถ€ํ˜ธ๋ฅผ ๊ณ ๋ คํ•˜์ง€ ์•Š๋Š” ์˜ค๋ฅธ์ชฝ ์‹œํ”„ํŠธ์ž…๋‹ˆ๋‹ค. -10 >>> 2๋Š” -10์„ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ๋‘ ๋น„ํŠธ ์ด๋™์‹œํ‚ค๊ณ , ์ƒ์œ„ ๋น„ํŠธ๋Š” 0์œผ๋กœ ์ฑ„์›Œ์ง‘๋‹ˆ๋‹ค. ๊ฒฐ๊ณผ๋Š” ํฐ ์–‘์ˆ˜ ๊ฐ’์ด ๋ฉ๋‹ˆ๋‹ค.

 

ex ) ๋น„ํŠธ ์—ฐ์‚ฐ์ž ์˜ˆ์‹œ

int a = 12; // 12์˜ ์ด์ง„ ํ‘œํ˜„: 1100
int b = 9;  //  9์˜ ์ด์ง„ ํ‘œํ˜„: 1001
int result = a & b; // ๊ฒฐ๊ณผ: 1000, ์ด์ง„์ˆ˜๋กœ 8

System.out.println(result); // ์ถœ๋ ฅ: 8

 

 


6๏ธโƒฃ์ฆ๊ฐ ์—ฐ์‚ฐ

 1. ์ „์œ„ ์ฆ๊ฐ ์—ฐ์‚ฐ์ž  (Pre-Increment/Pre-Decrement)

 ์ „์œ„ ์ฆ๊ฐ ์—ฐ์‚ฐ์ž๋Š” ๋ณ€์ˆ˜์˜ ๊ฐ’์„ ๋จผ์ € ์ฆ๊ฐ€์‹œํ‚ค๊ฑฐ๋‚˜ ๊ฐ์†Œ์‹œํ‚จ ํ›„, ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์—ฐ์‚ฐ์ž๋Š” ๋ณ€์ˆ˜ ์•ž 

 ์—  ์œ„์น˜ํ•ฉ๋‹ˆ๋‹ค.

  • ++๋ณ€์ˆ˜ (Pre-Increment): ๋ณ€์ˆ˜์˜ ๊ฐ’์„ 1 ์ฆ๊ฐ€์‹œํ‚จ ํ›„, ์ฆ๊ฐ€๋œ ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
  • -๋ณ€์ˆ˜ (Pre-Decrement): ๋ณ€์ˆ˜์˜ ๊ฐ’์„ 1 ๊ฐ์†Œ์‹œํ‚จ ํ›„, ๊ฐ์†Œ๋œ ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
int a = 5;
int result = ++a;  // a์˜ ๊ฐ’์„ ๋จผ์ € 1 ์ฆ๊ฐ€์‹œํ‚ค๊ณ , ๊ทธ ํ›„ result์— a์˜ ๊ฐ’์„ ํ• ๋‹นํ•ฉ๋‹ˆ๋‹ค.
// a์™€ result ๋ชจ๋‘ 6์ด ๋ฉ๋‹ˆ๋‹ค.

 

 

2. ํ›„์œ„ ์ฆ๊ฐ ์—ฐ์‚ฐ์ž  (Post-Increment/Post-Decrement)

ํ›„์œ„ ์ฆ๊ฐ ์—ฐ์‚ฐ์ž๋Š” ๋ณ€์ˆ˜์˜ ํ˜„์žฌ ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•œ ํ›„, ๋ณ€์ˆ˜์˜ ๊ฐ’์„ 1 ์ฆ๊ฐ€์‹œํ‚ค๊ฑฐ๋‚˜ ๊ฐ์†Œ์‹œํ‚ต๋‹ˆ๋‹ค. ์—ฐ์‚ฐ์ž๋Š” ๋ณ€์ˆ˜ ๋’ค์— ์œ„์น˜ํ•ฉ๋‹ˆ๋‹ค.

  • ๋ณ€์ˆ˜++ (Post-Increment): ๋ณ€์ˆ˜์˜ ํ˜„์žฌ ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•œ ํ›„, ๊ทธ ๊ฐ’์„ 1 ์ฆ๊ฐ€์‹œํ‚ต๋‹ˆ๋‹ค.
  • ๋ณ€์ˆ˜-- (Post-Decrement): ๋ณ€์ˆ˜์˜ ํ˜„์žฌ ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•œ ํ›„, ๊ทธ ๊ฐ’์„ 1 ๊ฐ์†Œ์‹œํ‚ต๋‹ˆ๋‹ค.
int a = 5;
int result = a++;  // a์˜ ํ˜„์žฌ ๊ฐ’์„ result์— ํ• ๋‹นํ•˜๊ณ , ๊ทธ ํ›„ a์˜ ๊ฐ’์„ 1 ์ฆ๊ฐ€์‹œํ‚ต๋‹ˆ๋‹ค.
// result๋Š” 5, a๋Š” 6์ด ๋ฉ๋‹ˆ๋‹ค.

 

 

7๏ธโƒฃ๊ทธ ์™ธ

1. ์‚ผํ•ญ  ์—ฐ์‚ฐ์ž  

Java์—์„œ ์‚ผํ•ญ ์—ฐ์‚ฐ์ž๋Š” ์กฐ๊ฑด ์—ฐ์‚ฐ์ž๋ผ๊ณ ๋„ ๋ถˆ๋ฆฌ๋ฉฐ, ๊ฐ„๋‹จํ•œ ์กฐ๊ฑด๋ฌธ์„ ๊ฐ„๊ฒฐํ•˜๊ฒŒ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•ด ์ค๋‹ˆ๋‹ค.

 

์กฐ๊ฑด ? ํ‘œํ˜„์‹1 : ํ‘œํ˜„์‹2

 

์กฐ๊ฑด์„ ํ‰๊ฐ€ํ•ฉ๋‹ˆ๋‹ค. ์กฐ๊ฑด์ด true์ผ ๊ฒฝ์šฐ, ํ‘œํ˜„์‹ 1์„ ์‹คํ–‰ํ•˜๊ณ  ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. 

์กฐ๊ฑด์ด false์ผ ๊ฒฝ์šฐ, ํ‘œํ˜„์‹ 2๋ฅผ ์‹คํ–‰ํ•˜๊ณ  ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

 

 

ex ) ์ตœ๋Œ“๊ฐ’ ์ฐพ๊ธฐ

int a = 5;
int b = 10;
int max = a > b ? a : b;
System.out.println("Max: " + max); // ์ถœ๋ ฅ: Max: 10

 

 

 

 

 

 

 


์—ฐ์‚ฐ์ž๋Š” ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ์กฐ์ž‘ํ•˜๊ณ 
ํ”„๋กœ๊ทธ๋žจ์˜ ํ๋ฆ„์„ ์ œ์–ดํ•˜๋Š” ๋ฐ ํ•„์ˆ˜์ ์ธ ์š”์†Œ์ž…๋‹ˆ๋‹ค!