์ฐ์ ์ฐ์ฐ์๋ +, -, *, / ์ด๋ ๊ฒ ์ฌ์น์ฐ์ฐ์ ๋ชจ๋๋ผ ์ฐ์ฐ %๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
int A = 10;
int B = 3;
System.out.println(A + B); // 13
System.out.println(A - B); // 7
System.out.println(A * B); // 30
System.out.println(A / B); // 3
System.out.println(A % B); // 1
๋นํธ ์ฐ์ฐ์๋ '๋นํธ ๋ ผ๋ฆฌ ์ฐ์ฐ์'์ '๋นํธ ์ํํธ ์ฐ์ฐ์'๋ก ๊ตฌ๋ถํ ์ ์๋ค.
๋นํธ ๋ ผ๋ฆฌ ์ฐ์ฐ์
๋นํธ ๋ ผ๋ฆฌ ์ฐ์ฐ์๋ ํผ์ฐ์ฐ์๋ฅผ ๋นํธ๋จ์๋ก ๋ ผ๋ฆฌ ์ฐ์ฐ์ํ๋ค.
ํผ์ฐ์ฐ์๋ก ์ค์๋ ํ์ฉํ์ง ์๊ณ , ์ ์(๋ฌธ์ ํฌํจ)๋ง ํ์ฉํ๋ค.
๋นํธ ์ํํธ ์ฐ์ฐ์
ํผ์ฐ์ฐ์์ ๊ฐ ๋นํธ ์๋ฆฌ๋ฅผ '์ค๋ฅธ์ชฝ(>>)' ๋๋ '์ผ์ชฝ(<<)'์ผ๋ก ์ด๋(shift) ํ๋ค๊ณ ํด์ '๋นํธ ์ํํธ ์ฐ์ฐ์'๋ผ๊ณ ํ๋ค.
๊ด๊ณ ์ฐ์ฐ์๋ ์กฐ๊ฑด์์ ์์ฃผ ์ฐ์ด๋ ์ฐ์ฐ์๋ก
๋ ๋น๊ต ๊ฐ๋ฅํ ๊ฐ์ด๋ ๊ฐ์ฒด์ ๊ด๊ณ๋ฅผ ๋น๊ตํ๋ ์ฐ์ฐ์์ด๋ค.
๊ด๊ณ ์ฐ์ฐ์๋ <, >, <=, >=, ==, != ์ผ๋ก ๊ตฌ์ฑ๋์ด ์๊ณ boolean type์ ๋ฆฌํดํ๋ค.
a < b // a๊ฐ b๋ณด๋ค ์์๊ฐ?
a > b // a๊ฐ b๋ณด๋ค ํฐ๊ฐ?
a <= b // a๊ฐ b๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์๊ฐ?
a >= b // a๊ฐ b๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์๊ฐ?
a == b // a์ b๊ฐ ๊ฐ์๊ฐ?
a != b // a์ b๊ฐ ๋ค๋ฅธ๊ฐ?
==, != ๋ ๊ฐ์ฒด๋ฅผ ๋น๊ตํ ๋ ๋ ํผ๋ฐ์ค๋ฅผ ๋น๊ตํ๊ธฐ ๋๋ฌธ์ ๊ฒ์ผ๋ก ๋ณด์ด๋ ๊ฐ์ ๊ฐ๋๋ผ๋ ์ฐธ์กฐํ๋ ๋ ํผ๋ฐ์ค๊ฐ ๋ค๋ฅด๋ฉด ์๋ํ์ง ์์ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์๋ ์๋ค.
๋ ผ๋ฆฌ ์ฐ์ฐ์๋ ๋ ผ๋ฆฌ์ ๊ฒฐํฉ์ด๋, ๋ ผ๋ฆฌ๋ฅผ ๋ค์ง์๋ ์ฌ์ฉํ๋ ์ฐ์ฐ์๋ก boolean type์ ๋ฆฌํดํ๋ค.
A && B // A์ B ๋ชจ๋ true์ด๋ฉด ์ฐ์ฐ๊ฒฐ๊ณผ๋ true (and)
A || B // A์ B ๋ ์ค ํ๋๋ผ๋ true์ด๋ฉด ์ฐ์ฐ๊ฒฐ๊ณผ๋ true (or)
!A // ์ฐ์ฐ๊ฒฐ๊ณผ๋ A๊ฐ true์ด๋ฉด false, A๊ฐ false์ด๋ฉด true (not)
์ฌ๊ธฐ์ and ์ฐ์ฐ์ ์ฒซ๋ฒ์งธ ๋
ผ๋ฆฌ๊ฐ false๋ฉด, ๋ค์ ๋
ผ๋ฆฌ๋ฅผ ์ฒดํฌํ์ง ์๊ณ false๋ฅผ ๋ฆฌํดํ๋ค.
๊ทธ๋ฆฌ๊ณ or ์ฐ์ฐ์ ์ฒซ๋ฒ์งธ ๋
ผ๋ฆฌ๊ฐ true๋ฉด, ๋ค์ ๋
ผ๋ฆฌ๋ฅผ ์ฒดํฌํ์ง ์๊ณ true๋ฅผ ๋ฆฌํดํ๋ค.
๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ๋ ผ๋ฆฌ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ ๋ ์๊ฐ, ๋ฉ๋ชจ๋ฆฌ์ ๋ญ๋น๋ ์์ ์ ์๊ณ , ๊ฒฝ์ฐ์ ๋ฐ๋ผ ๋ฐํ์์๋ฌ๊ฐ ๋ฐ์ํ ์๋ ์๊ธฐ ๋๋ฌธ์ ๋ ผ๋ฆฌ์ ์์๊ฐ ์๋นํ ์ค์ํ๋ค.
์ฐธ์กฐ๋ณ์๊ฐ ์ฐธ์กฐํ๊ณ ์๋ ์ธ์คํด์ค์ ์ค์ ํ์ ์ ์์๋ณผ ๋ instanceof ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋๋ฐ ์ด ์ฐ์ฐ์๋ boolean type์ ๋ฆฌํดํ๋ค.
"๊ฐ์ฒด instanceof ํด๋์ค" ํ์์ผ๋ก ์ฌ์ฉํ๋ฉฐ, ์ฃผ๋ก ์์๊ด๊ณ๋ฅผ ํ์ธํ ๋ ์ฌ์ฉํ๋ค.
class A { }
class B extends A { }
public class main {
public static void main(String[] args){
A a = new A();
A ab = new B();
B b = new B();
System.out.println(a instanceof A); //true
System.out.println(ab instanceof A); //true
System.out.println(b instanceof A); //true
System.out.println(a instanceof B); //false
System.out.println(ab instanceof B); //true
System.out.println(b instanceof B); //true
}
}
์์ ๊ฐ์ฒด๋ ๋ถ๋ชจ ํด๋์ค์ instance์ง๋ง, ๋ถ๋ชจ ๊ฐ์ฒด๋ ์์ ํด๋์ค์ instance๊ฐ ์๋๋ค.
์ฐ๋ณ์ ๊ฐ์ ์ข๋ณ์ ๋ณ์์ ๋์ ํ๋ ์ฐ์ฐ์์ด๋ค.
A = B
๋์ ์ฐ์ฐ์๋ ๋ค์ํ ์ฐ์ฐ์์ ๊ฒฐํฉํ์ฌ ์๋์ ๊ฐ์ ๋ณตํฉ ๋์ ์ฐ์ฐ์๋ก ํ์ฉ๊ฐ๋ฅํ๋ค.
A += B
A -= B
A *= B
A /= B
A %= B
A &= B
A |= B
A ^= B
A >>= B
A <<<= B
(๋งค๊ฐ๋ณ์) -> {์คํ์ฝ๋}์ ๊ฐ์ ๋๋ค์์์ ํ์ดํ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ค.
์ฌ๊ธฐ์ ๋๋ค์์ด๋ "์๋ณ์์์ด ์คํ๊ฐ๋ฅํ ํจ์"๋ก, ํจ์๋ฅผ ๋ฐ๋ก ์ ์ธํ์ง ์๊ณ ์ฝ๋ํ์ค์ ํจ์๋ฅผ ์จ์ ๊ทธ๊ฒ์ ํธ์ถํ๋ ๋ฐฉ์์ด๋ค.
๋ณดํต ํน์ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ ๋ ์์ฃผ ์ฌ์ฉํ๊ฒ ๋๋ค.
Arrays.sort(list, (l1, l2) -> l1[0]) - l2[0]));
์ ์ฝ๋๋ 2์ฐจ์ ๋ฐฐ์ด์ ์ ๋ ฌํ ๋, ๋ฐฐ์ด์ ์ฒซ๋ฒ์งธ ๊ฐ์ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ๋ผ๋ ๋๋ค์์ด๋ค.
๋ด๋ถ์ ์ผ๋ก๋ Comparator ์ธํฐํ์ด์ค์ compare(T o1, T o2)๋ฉ์๋๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํ ๊ฒ์ด๋ค.
// ๋ณ์ = ์กฐ๊ฑด๋ฌธ ? ์ฐธ : ๊ฑฐ์ง;
min = A < B ? A : B;
// return ์กฐ๊ฑด๋ฌธ? ์ฐธ : ๊ฑฐ์ง;
return A < B ? A : B;
๋ณ์์ ๊ฐ์ ํ ๋นํ ๋๋ง ์ผํญ์ฐ์ฐ์๋ฅผ ์ธ ์ ์๋๊ฒ์ด ์๋๋ผ, ๊ฐ์ ๋๊ฒจ์ฃผ๊ฑฐ๋ ์ถ๋ ฅํ๋ ๋ฑ ๊ฐ์ ๋ฐ์ ์ฒ๋ฆฌ๋ฅผ ํด์ค ์ ์์ผ๋ฉด ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
๋ง์ฝ ๋์ผํ ์ฐ์ ์์์ธ ๊ฒฝ์ฐ๋ ํด๋น ์ฐ์ฐ์์ ์ฐ์ฐ๋ฐฉํฅ์์ ๋จผ์ ๋ฑ์ฅํ๋ ์ฐ์ฐ์๊ฐ ์ฐ์ ์ ์ผ๋ก ์ฐ์ฐ๋๋ค.
if(์กฐ๊ฑด์){ }
else if( ์ ์กฐ๊ฑด์ด ๊ฑฐ์ง์ผ ๊ฒฝ์ฐ ์กฐ๊ฑด){ }
else if( ์ ์กฐ๊ฑด์ด ๊ฑฐ์ง์ผ ๊ฒฝ์ฐ ์กฐ๊ฑด){ }
else { // ๋ชจ๋ ์กฐ๊ฑด๋ค์ด ๊ฑฐ์ง์ผ ๊ฒฝ์ฐ }
if๋ง ๋จ๋ ์ผ๋ก ์ฌ ์ ์๊ณ , else if์ else๋ if๋ฌธ์ด ์ ํ๋์ด์ผ์ง ๋ค ๋ฐ๋ผ ๋์ฌ ์ ์๋ค.
else if๋ if{} - else{ if{} } ์ ์ฝ์ ๊ฐ๋ ์ด๋ค.
switch(๋ณ์) {
case A : // ๋ณ์์ ๊ฐ์ด A์ผ ๋
// ์ง์
break;
case B : // ๋ณ์์ ๊ฐ์ด B์ผ ๋
// ์ง์
break;
default :
// A์ B๊ฐ ์๋ ๊ฒฝ์ฐ
}
switch์ ๋ณ์๋ Primitive ํ์ , Enum, String, Wrapper ํด๋์ค๊ฐ ๊ฐ๋ฅํ๋ค.
์ฌ๊ธฐ์ ์ฃผ์ํ ์ ์ case A์ ์ง์ ํด์ ์ฒ๋ฆฌ๋ฅผ ํ๊ณ break๊ฐ ๋์ง ์์ผ๋ฉด ์๋ case B์๋ ์๋์ผ๋ก ์ง์ ํ๊ฒ ํ๋ก๊ทธ๋จ์ด ์ค๊ณ๋์ด ์๊ธฐ ๋๋ฌธ์
A์ ์ง์ ํ์ ๋ ์ฒ๋ฆฌํ๊ณ ์ถ์ ๋ด์ฉ๋ง ์ฒ๋ฆฌํ๊ณ ์ถ๋ค๋ฉด break๋ฅผ ํด์ค์ switch๋ฌธ์ ๋น ์ ธ๋์์ผ ํ๋ค.
while(์กฐ๊ฑด์){
// ์กฐ๊ฑด์์ด ์ฒ์ ๋ถํฐ ์ฑ๋ฆฝ๋์ง ์์ผ๋ฉด ์ ์ด์ ๋ฐ๋ณต๋ฌธ์ ์ง์
์ ์ํ ์๋ ์์
// ๋ฐ๋ณต๋ด์ฉ
}
do{
// ๋ฌด์กฐ๊ฑด ์ต์ 1๋ฒ์ ๋ฐ๋ณต๋ฌธ ์คํ
// ๋ฐ๋ณต๋ด์ฉ
} while(์กฐ๊ฑด์); // ์ธ๋ฏธ์ฝ๋ก ';' ํ์
for(์ด๊ธฐํ; ์กฐ๊ฑด์; ์ฆ๊ฐ์){
// ๋ฐ๋ณต๋ด์ฉ
}
for(๋ฐ์ดํฐํ์
์งํฉ์์ : ๋ฐ๋ณต์งํฉ๊ฐ์ฒด){
//๋ฐ๋ณต ๊ฐ๋ฅํ ์งํฉ๋ค์ ์์๋ค์ ๊บผ๋ด์ด ์ฒ๋ฆฌ
}
๋ฐ๋ณต์งํฉ๊ฐ์ฒด์๋ array, iterable ํ์ ์ด ์ฌ ์ ์์ผ๋ฉฐ enum์ ๊ฒฝ์ฐ enum.values()๋ฅผ ๋ฐ๋ณต์งํฉ๊ฐ์ฒด๋ก ์ฌ์ฉํ๋ค.
for-each๋ฌธ์ ์ฌ์ฉํ๋ ๋ชฉ์
1. ์๋ฃ๊ตฌ์กฐ์ฌ์ฉ์ ๋ํ ์ถ์ํ
2. ๋ฐ๋ณต ๊ฐ๋ฅํ ์งํฉ์ ์์)๊ฐ์ ์์ ์ด ๋ถ๊ฐ๋ฅ(์กฐํ ๋ชฉ์ )