๊ฐ๋ฐํ๋ค๋ณด๋ฉด ๋ถ๊ธฐ ์ฒ๋ฆฌ๋ฅผ ํ๋๊ฒ ํ์์ ์ด์ด์ง๋ค.
์ด๋ switch๋ฅผ ์ฌ์ฉํ๋ ๊ฒ ๋์์ง else if ์ ์ฌ์ฉ์ด ๋์์ง ๊ณ ๋ฏผ์ด ๋ ๋๊ฐ ์๋ค.
๋ณดํต ์ฝ๋ ์ ๋ฆฌ๋ switch๊ฐ ํ ๋์ ๋ณด๊ธฐ ์ฌ์ด ํธ์ด๊ณ ,
๊ฐ์ธ์ ์ผ๋ก ์ฌ์ฉํ๊ธฐ์๋ if~else ๋ฌธ์ด ์ฒ๋ฆฌํ๊ธฐ๊ฐ ์ฌ์ด ๊ฒ ๊ฐ๋ค.
๊ทธ๋๋ ์ฝ๋ ๊ฐ์์ฑ ๋ฐ ๊ฐ๋ฐ์ ํธ์์ฑ์ ๊ณ ๋ คํ์ง ์์ ์๋ ์์ง๋ง...
์ ์ผ ์ค์ํ ๊ฑด ํ๋ก๊ทธ๋จ ์ฑ๋ฅ์ด๋ผ... ๋ ๊ฐ์ง์ ๋ก์ง์ ์ธ ์ฐจ์ด๋ฅผ ์ ๋ฆฌํด๋ณด๊ณ ์ ํ๋ค.
switch๋ฌธ
๋ณ์๋ฅผ ๋ฏธ๋ฆฌ ์ ๋ ฅ ๋ฐ์ ๋๊ณ , ๋ฏธ๋ฆฌ ์ ํด๋์ ๊ฐ๋ค๊ณผ ์ผ์น ์ฌ๋ถ๋ฅผ ํ๋จํ์ฌ control flow๋ฅผ ์ฒ๋ฆฌ
if~else๋ฌธ
boolean์ผ๋ก ๊ฒฐ๊ณผ ๊ฐ์ด ๋์ค๋ ์กฐ๊ฑด๋ฌธ์ ๊ฒฐ๊ณผ์ ๋ฐ๋ผ true, false ๋๊ฐ์ง control flow๋ฅผ ๊ฐ์ง๋ค.
๊ทธ๋ฌ๋ฏ๋ก . . .
if~else ๋ฌธ์ ๋ชจ๋ switch๋ก ๋ณํ ์ํค์ง๋ ๋ชปํ์ง๋ง
switch ๋ฌธ์ผ๋ก ์์ฑ๋ ๋ฌธ๋ฒ์ ๋ชจ๋ if~else ๋ก ๋ณํ ์ํค๋ ๊ฒ์ ๊ฐ๋ฅํ๋ค.
๊ฒฐ๊ณผ์ ์ผ๋ก ๋๊ฐ๋ฅผ ๊ฐ์ ๊ธฐ๋ฅ์ ํ๋๋ก ๊ตฌํ์ ํ ์ ์์ง๋ง
๊ตฌ์กฐ์ ์ผ๋ก๋ ์ด๋จ๊น?
else if ๊ตฌ๋ฌธ๊ณผ switch ๊ตฌ๋ฌธ์ logic์ ์ธ ์ฐจ์ด
if else ๊ตฌ๋ฌธ
๊ฐ๊ฐ ์กฐ๊ฑด๋ฌธ์ ๋ฐ๋ณตํ๋ฉฐ control flow๋ฅผ ๊ฒฐ์ ํ๋ค.
N๊ฐ์ if else ๋ฌธ์ด ์์ผ๋ฉด N๊ฐ ์กฐ๊ฑด๋ฌธ์ ์ง์์ฌ๋ถ๋ฅผ ํ๋จ.
Switch ๊ตฌ๋ฌธ
JVM์์ switch ๊ตฌ๋ฌธ์์ case ๊ฐ๋ค์ ๋ถํฌ์ ๋ฐ๋ผ
๋ด๋ถ์ ์ผ๋ก ๊ฐ๊ฐ์ case์ ์ต์ ํ๋ 2๊ฐ์ ์๋ฐ ๋ฐ์ดํธ์ฝ๋๋ฅผ ์์ฑํ๊ฒ ๋๋๋ฐ...
๊ณตํต์ ์ผ๋ก ๋ ๊ฒฝ์ฐ ๋ชจ๋ hashtable์ด ์ฐ์๋๋ ๊ตฌ์กฐ๋ฅผ ๋๋ค.
๊ทธ๋ฆฌ๊ณ case ๊ฐ์ ๋ฐ๋ผ ์ต์ ํ ๋ฃจํด์ ์ค์ ํ๊ฒ ๋๋ค.
- case๊ฐ๋ค์ด ์๋ก ํฐ ์ฐจ์ด์์ด ๋ถ์ด์๋ ๊ฒฝ์ฐ: TableSwitch ํ์์ ์ปดํ์ผ ์ํ
- case๊ฐ๋ค์ด ์๋ก ์ฐจ์ด๊ฐ ํฌ๊ฒ ๋ ๊ฒฝ์ฐ : LookupSwitch ํ์์ ์ปดํ์ผ ์ํ
TableSwitch ๋ฐฉ์
case๋ก ์ฃผ์ด์ง ๊ฐ๊ณผ case๋ค ์ฌ์ด์ ๊ฐ๋ค์ ํด๋นํ๋ case๊น์ง ์ ๋ถ ๊ณ์ฐํ์ฌ ๋ฐ์ดํธ์ฝ๋๋ก ์์ฑํ๋ ๋ฐฉ์
HashTable ๊ณผ ์ ์ฌํ ๊ตฌ์กฐ : ์๋ฐ ๋ฐ์ดํธ ์ฝ๋์์ lable๋ง์ ์ฌ์ฉ
LookupSwitch ๋ฐฉ์
TableSwitch ๋ฐฉ์์ ์ฝ๋์๋ ๋ค๋ฅด๊ฒ, ์ฌ์ด ๊ฐ๋ค์ ํด์ ํํ๋ก ๊ณ์ฐํด๋์ง ์์.
List ์ ์ ์ฌํ ๊ตฌ์กฐ : ์๋ฐ ๋ฐ์ดํธ ์ฝ๋์์ key์ ํจ๊ป label์ ์ฌ์ฉ
์ต์ข ์ ์ผ๋ก...
Switch ๊ตฌ๋ฌธ์ item์ ๊ฐ์(N)์ ๋ฐ๋ผ O(lgN) (์ต์ ์ ๊ฒฝ์ฐ) ์ ์คํ๋๊ณ
if~else ๊ตฌ๋ฌธ์ item์ ๊ฐ์(N)์ ๋ฐ๋ผ ์คํ๋๋ค.. O(N)
๊ฒ์ฆ
๋์ผ ๊ฒฐ๊ณผ ๊ฐ์ ๋์์ผ๋ก for ๋ฌธ ์ค์ฒฉ ํ์ฌ ํ ์คํธ๋ฅผ ์์ผ๋ณด์.
// in case: if~else ๊ตฌ๋ฌธ ์ฌ์ฉ
long a = System.currentTimeMillis();
int ret = -1;
for (int i=0; i<1000000000; ++i)
for (int num=0; num<5; ++num)
if (num == 0) ret = 10;
else if (num == 1) ret = 20;
else if (num == 2) ret = 30;
else if (num == 3) ret = 40;
else if (num == 4) ret = 50;
else ret = 12;
long b = System.currentTimeMillis();
System.out.println(ret);
System.out.println(b-a+"ms");
50
8718ms
// in case: Switch ๊ตฌ๋ฌธ ์ฌ์ฉ
long a = System.currentTimeMillis();
int ret = -1;
for (int i=0; i<1000000000; ++i)
for (int num=0; num<5; ++num)
switch (num) {
case 0: ret = 10; break;
case 1: ret = 20; break;
case 2: ret = 30; break;
case 3: ret = 40; break;
case 4: ret = 50; break;
default: ret = 12; break;
}
long b = System.currentTimeMillis();
System.out.println(ret);
System.out.println(b-a+"ms");
50
2820ms
๋ถ๊ธฐ ๊ตฌ๋ฌธ์ด ์ฝ 5๊ฐ ์ ๋์ ๋ถ๊ณผํ๋ฐ์๋ switch๋ฌธ์ด 3~4๋ฐฐ ์ ๋ ๋น ๋ฅธ ๊ฒ์ ํ์ธ ๊ฐ๋ฅํ๋ค.
๋ถ๊ธฐ ๊ตฌ๋ฌธ์ด ๋์ด๋ ์๋ก ์ฐจ์ด๋ ๋ฒ์ด์ง ๊ฒ์ผ๋ก ์์๋๋ค.
์์ฝ
์์์ ๋งํ๋ฏ์ด ๋ณดํต ๊ตฌํ ์๊ฐ์ด๋ ์ต์ํ๋ค๋ ์ด์ ๋ก
'ํ๋์ ๋ณ์ ๊ฐ์ ๋ฐ์ ๊ทธ ๊ฐ์ ๋น๊ตํด control flow๋ฅผ ์ ํ๋ ์ฝ๋'๋ฅผ ๊ตฌํํ ๋
if~else ๊ตฌ๋ฌธ์ ๋ง์ด ์ฑํํ๊ฒ ๋๋ค.
ํ์ง๋ง ์๋ ๊ฐ์ ํผํฌ๋จผ์ค ์ธก๋ฉด์์๋ switch ๋ฌธ์ด ์ฐ์ธํ๋ฏ๋ก...
์ฐธ๊ณ ํ์ฌ ๋ฒ๋ฆ์ ๋ค์ ๋ค์ด๋ ๊ฒ๋ ์ข์ํ ๋ค.
+)
case๋ฌธ์ ๊ฒฝ์ฐ ์ฐ์ฐ์ ํ ์ ๋ณด๋ฅผ ๊ฐ์ง๊ณ ์๊ณ , ๊ทธ๊ฑธ๋ก ๊ฒฐ๊ณผ ๊ฐ์ ๊ฐ์ ธ๋ค ์ฃผ๋ฏ๋ก
"๋ฉ๋ชจ๋ฆฌ" ์ธก๋ฉด์์ ๋จ์ ์ ๊ฐ์ง๊ธด ํ๋ค.
๋ถ๊ธฐ 3๊ฐ๊น์ง๋ if~else๋ฌธ. ๊ทธ ์ด์์ ๋ถ๊ธฐ๋ switch~case๋ฌธ.