[Java ์ดํดํ๊ธฐ] 4. ์๋ฐ์ ์ฐ์ฐ์
๐ฉท 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
์ฐ์ฐ์๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ๋ฐ์ดํฐ๋ฅผ ์กฐ์ํ๊ณ
ํ๋ก๊ทธ๋จ์ ํ๋ฆ์ ์ ์ดํ๋ ๋ฐ ํ์์ ์ธ ์์์ ๋๋ค!