์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | |||||
3 | 4 | 5 | 6 | 7 | 8 | 9 |
10 | 11 | 12 | 13 | 14 | 15 | 16 |
17 | 18 | 19 | 20 | 21 | 22 | 23 |
24 | 25 | 26 | 27 | 28 | 29 | 30 |
- ํฐ์คํ ๋ฆฌ์ฑ๋ฆฐ์ง
- ํ๋ก๊ทธ๋๋ฐ
- ์๋ฐ
- Java
- ๋ฆฌ์กํธ
- ์ํ
- ์ค๋ธ์
- database
- ๊น๋ฏธ๊ฒฝ์๋งํ์์
- ComputerScience
- K๋ฐฐํฐ๋ฆฌ๋ ๋ณผ๋ฃจ์
- ๋ง์ผ๋ด๊ฐ์ธ์์๋ค์์ฐ๋ค๋ฉด
- css
- ํ์ด์ฌ
- ์นํผ๋ธ๋ฆฌ์ฑ
- ๋ฐ์ํ
- ์ฑ
- K๋ฐฐํฐ๋ฆฌ
- ๋ฐ์ดํฐ๋ฒ ์ด์ค
- JavaScript
- ์๋ฐ์คํฌ๋ฆฝํธ
- ๋ ์
- Python
- html
- ๋ผํ๋ผ์ค์๋ง๋
- ๊ฐ๋ฐ
- ์ฝ๋ฉ
- ์ค๋ผํด
- ์นํ์ด์ง๋ง๋ค๊ธฐ
- ์ปดํจํฐ๊ณผํ
- Today
- Total
JiYoung Dev ๐ฅ
[JAVA] ์ฐ์ฐ์ (2023.03.22 ์์ ) ๋ณธ๋ฌธ
2023.03.22 ํ์ต๋ด์ฉ
๐ ๋์ ์ฐ์ฐ์(ํ ๋น์ฐ์ฐ์)
์ฐ์ฐ์ ๊ฒฐ๊ณผ๋ฅผ ๋ด์ ๋ ์ฌ์ฉํ๋ ์ฐ์ฐ์
๐ ๋์ (ํ ๋น)์ฐ์ฐ์
๊ธฐํธ : =
๋์ ์ฐ์ฐ์์ ์ค๋ฅธ์ชฝ๋ถํฐ ํ์ธ
์ฐ์ฐ์์ ์ค๋ฅธ์ชฝ ์์ ๊ฒฐ๊ณผ๋ฅผ ์ผ์ชฝ์ ์๋ ๋ณ์์ ๋์
a = b;
b๋ฅผ a์ ํ ๋นํ๋ค
a = b + 1;
b๋ฅผ 1๊ณผ ๋ํ ํ a์ ํ ๋นํ๋ค
์ฐ์ต๋ฌธ์
int x = 2;
int y = 10;
z = x++*2+--y-5+x*(y%2)
x++ → 2๋ฅผ ์ถ๋ ฅํ๊ณ x๋ 3์ด๋จ
x → 3
--y → 9๊ฐ ๋ ํ ์ถ๋ ฅ, y๋ 9๊ฐ ๋จ
z = 2 * 2 + 9 - 5 + 3 * (9 % 2)
= 4 + 9 - 5 + 3
= 11
๐ ๋ณตํฉ ๋์ ์ฐ์ฐ์
๊ธฐํธ : +=, -=, *=, /=, %=, &=, ^=, |=, ...
๋์ ์ฐ์ฌ์ ๊ธฐํธ ์์ ๋ค๋ฅธ ์ฐ์ฐ์๋ฅผ ํจ๊ป ์ฌ์ฉ
์ค์๋ง์ด๋ผ ์๊ฐํ๋ฉด ์ข์
๋ณตํฉ ๋์ ์ฐ์ฐ์ ์ค๋ฅธ์ชฝ๋ถํฐ ํ์ธ
a += b;
a = a + b๋ฅผ ์๋ฏธํจ
int a = 10;
int b = 3;
a += b;
→ a = a + b์ ๊ฐ์ → a = 10 + 3 → a์ 13๋ฅผ ํ ๋นํ๋ค
โป ๊ธฐํธ ์์ ์๋ ๊ฐ์ ๋ค์ ์๋ ๊ฐ์ ๋ํจ ๊ทธ๋ฆฌ๊ณ ๋์ ์์ ์๋ ๊ฐ์ ๋ค์ ์๋ ๊ฐ์ ํ ๋นํจ
int num = 29;
num -= 2 + 3 * 4
-> num = num - (2 + 3 * 4)
-> num = num - 14
๐ ์ฆ๊ฐ์ฐ์ฐ์
๋ณ์์ ์ ์ฅ๋ ๊ฐ์ 1์ฆ๊ฐ ํน์ 1๊ฐ์ ํด์ฃผ๋ ์ฐ์ฐ์ (๋ง์ด ์ฌ์ฉ)
์ฆ๊ฐ์ฐ์ฐ์ ++
๊ฐ์์ฐ์ฐ์ --
๋ณ์๊ฐ ์ฆ๊ฐ์ฐ์ฐ์ ์์ ์๋ ๊ฒฝ์ฐ (๋ณ์ ++ / ๋ณ์ --)
→ ๋ณ์๊ฐ ๊ฐ์ง๊ณ ์๋ ๊ฐ์ ๋จผ์ ์ฌ์ฉํ ํ 1์ฆ๊ฐ ํน์ 1๊ฐ์์ํด
๋ณ์๊ฐ ์ฆ๊ฐ์ฐ์ฐ์ ๋ค์ ์๋ ๊ฒฝ์ฐ ( ++ ๋ณ์ / -- ๋ณ์)
→ ๋ณ์์ ์ผ๋จ ๋ฌด์กฐ๊ฑด 1์ฆ๊ฐ ํน์ 1๊ฐ์ ํ ๋ณ์ ์ฌ์ฉ
int i = 3;
System.out.println(++i); -> i๋ 4 (1์ฆ๊ฐ ํ ์ถ๋ ฅ)
System.out.println(i++); -> i๋ 4 (์ถ๋ ฅ ํ 1์ฆ๊ฐ)
System.out.println(i); -> i๋ 5
๐ ๋น๊ต์ฐ์ฐ์
๋ ๊ฐ์ ํผ์ฐ์ฐ์๋ฅผ ๋น๊ตํ์ฌ TRUE ๋๋ FALSE์ ๋ ผ๋ฆฌ ๊ฐ์ ๋ด๋ ์ฐ์ฐ์
์ง๋ฌธ์ผ๋ก ์๊ฐ
๊ฒฐ๊ณผ๊ฐ Boolean(true or false) ์ฐธ๊ณผ ๊ฑฐ์ง์ผ๋ก ๋์ด
1) <, <=, >, >=
2) ==(๊ฐ๋ค) , !=(๊ฐ์ง ์๋ค)
! : NOT ์ฐ์ฐ์
๐ ๋ ผ๋ฆฌ์ฐ์ฐ์
๋ ผ๋ฆฌ ๊ฐ์ ๋์์ผ๋ก AND, OR, XOR, NOT์ ๋ ผ๋ฆฌ ์ฐ์ฐ์ ํ์ฌ ๋ ผ๋ฆฌ ๊ฐ์ ๋ด๋ ์ฐ์ฐ์
ํผ์ฐ์ฌ์๋ boolean์ด๊ณ ๊ฒฐ๊ณผ๊ฐ๋ boolean์. ๋ฐ๋ผ์ ํผ์ฐ์ฐ์๋ก ๋น๊ต์ฐ์ฐ์๋ฅผ ๋ง์ด ์ฌ์ฉ
โ ๊ผญ ๊ธฐ์ตํ๊ธฐ
A | B | A && B | A || B | !A |
TRUE | TRUE | TRUE | TRUE | FALSE |
TRUE | FALSE | FALSE | TRUE | FALSE |
FALSE | TRUE | FALSE | TRUE | TRUE |
FALSE | FALSE | FLASE | FALSE | TRUE |
1) ! (NOT) - ๋จํญ์ฐ์ฐ์
2) && (AND), || (OR) - ์ดํญ์ฐ์ฐ์
๋น๊ต์ฐ์ฐ์๊ฐ ๋ ผ๋ฆฌ์ฐ์ฐ์๋ณด๋ค ์ฐ์
๋น๊ต์ฐ์ฐ์์ ๊ฒฐ๊ณผ๊ฐ์ ๊ฐ์ง๊ณ ๋ ผ๋ฆฌ์ฐ์ฐ์ ์ค์ํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์
๐ ์ผํญ(ternary) ์ฐ์ฐ์ = ์กฐ๊ฑด์ฐ์ฐ์
(์กฐ๊ฑด๋ฌธ) ? (์คํ๋ฌธ1) : (์คํ๋ฌธ2)
์กฐ๊ฑด๋ฌธ์ true, false ๋ก๋ง ๊ฒฐ๊ณผ๊ฐ์ด ๋์ฌ ์ ์์ด์ผ ํจ
์กฐ๊ฑด๋ฌธ์ ๊ฐ๋จํ๊ฒ ์ธ ๋ ์ฌ์ฉํ๊ธฐ ์ข์
์กฐ๊ฑด๋ฌธ์ด ์ฐธ์ด๋ฉด ์คํ๋ฌธ1์ ์คํํ๊ณ ๊ฑฐ์ง์ด๋ฉด ์คํ๋ฌธ2๋ฅผ ์คํ
์กฐ๊ฑด์์๋ ๋น๊ต์ฐ์ฐ ํน์ ๋ ผ๋ฆฌ์ฐ์ฐ์ด ๋ง์ด์ด. ์๋ํ๋ฉด ๊ฒฐ๊ณผ๊ฐ์ด boolean์ด ๋์ค๊ธฐ ๋๋ฌธ
๋ ๊ฐ์ ์ ์๋ฅผ ์ ๋ ฅ ๋ฐ์ ํฐ ์์์ ์์ ์๋ฅผ ๋บ ๊ฒฐ๊ณผ๊ฐ์ ์ถ๋ ฅ
๋๊ตฌ๊ณต์ ๋ด๊ธฐ ์ํด ํ์ํ ์์์ ๊ฐ์ ๊ตฌํ๊ธฐ
์์ ํ๋์๋ ๋๊ตฌ๊ณต์ด 5๊ฐ ๋ค์ด๊ฐ ์ ์์
์๊ธ๊ณ์ฐ๊ธฐ
๊ธฐ๋ณธ ์๊ธ์ 9,000์์ด๊ณ 8์๊ฐ์ด ๋์ ๊ฒฝ์ฐ ์ด๊ณผ ์๊ธ์ ์๊ธ์ 1.5๋ฐฐ๋ฅผ ์ฑ ์
๐ ์ฐ์ฐ์ ์ฐ์ ์์ (๊ธฐ์ตํด์ผ ํจ)
๐ ๋นํธ์ฐ์ฐ
๋นํธ ์ฐ์ฐ์ ๋นํธ๋ผ๋ฆฌ AND, OR, XOR, NOT ์ฐ์ฐ์ ํ๋ ๋นํธ ๋ ผ๋ฆฌ ์ฐ์ฐ๊ณผ ๋นํธ๋ฅผ ์ค๋ฅธ์ชฝ์ด๋ ์ผ์ชฝ์ผ๋ก ์ด๋์ํค๋ ๋นํธ ์ํํธ ์ฐ์ฐ์ด ์์
โ ๋นํธ ๊ฐ๋
์ปดํจํฐ์ ๋ชจ๋ ์ ๋ณด๋ 0๊ณผ 1 ๊ฐ๋ง ๊ฐ์ง๋ 2์ง์๋ก ๋ค๋ฃจ์ด์ง๊ณ ์ ์ฅํจ
2์ง์์ ํ ์๋ฆฌ๋ฅผ ๋นํธ(bit)๋ผ๊ณ ๋ถ๋ฅด๋ฉฐ, 8๊ฐ์ ๋นํธ๋ฅผ ๋ฐ์ดํธ(byte)๋ผ๊ณ ํจ
โ ๋นํธ ๋ ผ๋ฆฌ ์ฐ์ฐ
๋นํธ ๋ ผ๋ฆฌ ์ฐ์ฐ์ ํผ์ฐ์ฐ์์ ๊ฐ ๋นํธ๋ค๋ผ๋ฆฌ ์ด๋ฃจ์ด์ง๋ AND, OR, XOR, NOT์ ๋ ผ๋ฆฌ ์ฐ์ฐ
b | 1 | 0 | 0 | 1 |
c | 1 | 0 | 1 | 1 |
b&c | 1 | 0 | 0 | 1 |
b|c | 1 | 0 | 1 | 1 |
b^c | 0 | 0 | 1 | 0 |
์ฐ์ฐ์ | ๋ณ์นญ | ๋ด์ฉ |
a & b | AND ์ฐ์ฐ | ๋ ๋นํธ ๋ชจ๋ 1์ด๋ฉด 1, ์๋๋ฉด 0 |
a | b | OR ์ฐ์ฐ | ๋ ๋นํธ ๋ชจ๋ 0์ด๋ฉด 0, ์๋๋ฉด 1 |
a ^ b | XOR ์ฐ์ฐ | ๋ ๋นํธ๊ฐ ๋ค๋ฅด๋ฉด 1, ๊ฐ์ผ๋ฉด 0 |
~ a | NOT ์ฐ์ฐ | 1์ 0์ผ๋ก, 0์ 1๋ก ๋ณํ |
โ ๋นํธ ์ํํธ ์ฐ์ฐ
์๋ก์ด ๋นํธ๋ฅผ ์ค๋ฅธ์ชฝ์ด๋ ์ผ์ชฝ ๋์ ์ฝ์ ํ๋ฉด์ ๋นํธ์ ์๋ฆฌ๋ฅผ ์ด๋์ํค๋ ์ฐ์ฐ
์ ์ฅ ๊ณต๊ฐ์ ํฌ๊ธฐ๊ฐ ์ ํด์ ธ ์์ผ๋ฏ๋ก ์ํํธ๋๋ ๋ฐฉํฅ์ ๋ฐ๋ผ ๋์ ์๋ ๋นํธ๋ ์ฌ๋ผ์ง
d | 0 | 1 | 1 | 0 |
~d | 1 | 0 | 0 | 1 |
~d(1์๋ณด์) | 0 | 1 | 1 | 0 |
1 | ||||
~d(1์ ๋ํ ํ - ์ฒ๋ฆฌ) | 0 | 1 | 1 | 1 |
2์ง์๋ ๋งจ ์์๋ฆฌ์๊ฐ ๋ถํธ๋ก ๋งจ ์์๋ฆฌ์๊ฐ 1์ด๋ฉด ์์๊ฐ ๋จ
์ํํธ ์ฐ์ฐ์ | ๋ด์ฉ |
a >> b | a์ ๊ฐ ๋นํธ๋ฅผ ์ค๋ฅธ์ชฝ์ผ๋ก b๋ฒ ์ํํธ ํ๋ค. ์ต์์ ๋นํธ์ ๋น์๋ฆฌ๋ ์ํํธ ์ ์ ์ต์์ ๋นํธ๋ก ๋ค์ ์ฑ์ด๋ค. ์ฐ์ ์ ์ค๋ฅธ์ชฝ ์ํํธ๋ผ๊ณ ํ๋ค. |
a >>> b | a์ ๊ฐ ๋นํธ๋ฅผ ์ค๋ฅธ์ชฝ์ผ๋ก b๋ฒ ์ํํธํ๋ค. ์ต์์ ๋นํธ์ ๋น์๋ฆฌ๋ ํญ์ 0์ผ๋ก ์ฑ์ด๋ค. ๋ ธ๋ฆฌ์ ์ค๋ฅธ์ชฝ ์ํํธ๋ผ๊ณ ํ๋ค. |
a << b | a์ ๊ฐ ๋นํธ๋ฅผ ์ผ์ชฝ์ผ๋ก b๋ฒ ์ํํธํ๋ค. ์ตํ์ ๋นํธ์ ๋น์๋ฆฌ๋ ํญ์ 0์ผ๋ก ์ฑ์ด๋ค. ์ฐ์ ์ ์ผ์ชฝ ์ํํธ๋ผ๊ณ ํ๋ค. |
์ต์์ ๋นํธ : ์ต๊ณ ๊ฐ์ ๊ฐ์ง๋ ๋นํธ ์์น
์ํํธ ์ฐ์ฐ์ ํผ์ฐ์ฐ์๋ byte, short, int, long, char ํ์ ๋ง ๊ฐ๋ฅํ๊ณ , float, double, boolean์ ์ฌ์ฉํ ์ ์์
๐ ์นํ
int a = 20;
int b = 10;
↓
a = 10; (b๊ฐ ๊ฐ์ง๊ณ ์๋ ๊ฐ)
b = 20; (a๊ฐ ๊ฐ์ง๊ณ ์๋ ๊ฐ)
๋ณ์๋ฅผ ์ ์ธํ๋ฉด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํจ
๋ฉ๋ชจ๋ฆฌ๋ ์ด์ ์ ๋ค๋ฅธ ์ฉ๋๋ก ์ฌ์ฉ๋์๋ ๊ณต๊ฐ์ผ ์ ์์.
๋ฐ๋ผ์ ๋ฉ๋ชจ๋ฆฌ์๋ ์ด์ ์ ์ผ๋ ๊ฐ์ด ๋จ์์์ ์ ์์.
๋ฐ๋ผ์ ์ ์ธ๋ง ํ๋ฉด ์ด์ ์ ์๋ ๊ฐ์ ๊ฐ์ง ์ ์์
null๊ฐ์ ํ ๋นํ๋ฉด ์ด์ ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ง์ฐ๊ณ ๋น ๊ฐ์ ๋ฃ์ด์ค.
'full stack > JAVA' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[JAVA] for๋ฌธ, ์ด์ค for๋ฌธ ๋ฌธ์ ํ์ด (2023.03.28) (0) | 2023.03.28 |
---|---|
[JAVA] While๋ฌธ ๋ฌธ์ ํ์ด, for ๋ฐ๋ณต๋ฌธ (2023.03.27) (0) | 2023.03.27 |
[JAVA] ๋ฐ๋ณต๋ฌธ while, do~while (2023.03.24) (0) | 2023.03.24 |
[JAVA] ์กฐ๊ฑด๋ฌธ (2023.03.23 ์์ ) (0) | 2023.03.23 |
[JAVA] ๋ณ์์ ์ ์ถ๋ ฅ (1) | 2023.03.21 |