์กฐ๊ฑด๋ฌธ - switch ๋ฌธ
switch ๋ฌธ์ case์ default๋ก ๊ตฌ์ฑ๋๊ณ , ๊ฐ case๋ฅผ ์ง์ ํด์ค๋ค.
if๋ฌธ๊ณผ switch๋ฌธ์ ์ฐจ์ด์
switch๋ฌธ์ด ์๋๊ฐ ๋ ๋น ๋ฆ (์ฅ์ )
- if ๋ฌธ๊ณผ switch ๋ฌธ์ ๋ฐฉ์์ผ๋ก ๋ชฉ์ ์ง(๋ถ์ฐ)๋ฅผ ๊ฐ๋ คํ ๋ :
if ๋ฌธ์ ๊ฐ๋ ค๋ ๊ณณ์ ์์ฐจ์ ์ผ๋ก ๋ฌผ์ด๋ณด๋ฉฐ ๋ชฉ์ ์ง๋ก ํฅํจ.
๊ฐ๋ ๊ณณ์ด .. ์ฒ์์ธ๊ฐ? -> ๋์ ์ธ๊ฐ> -> ๋๊ตฌ์ธ๊ฐ> -> ๋ถ์ฐ์ธ๊ฐ?
switch ๋ฌธ์ ๊ฐ๋ ค๋ ๊ณณ์ผ๋ก ์ง์ง.
๊ฐ๋ ๊ณณ์ด ๋ถ์ฐ์ด๋ค.
๋จ์ ) switch ๋ฌธ์ ๊ฐ๊ฐ์ case๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ๋ด๊ณ ์๊ธฐ ๋๋ฌธ์ if ๋ฌธ๋ณด๋ค ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ ์ฐจ์งํ๋ค.
๋ฐ๋ผ์, switch ๋ฌธ์ ํ์๋ก ์ํํด์ผํ ๋, ์กฐ๊ฑด์ด ๋จ์ํ ๊ฒฝ์ฐ์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค.
- AND ์กฐ๊ฑด์ด๋ OR ์กฐ๊ฑด์ switch ๋ฌธ์์ ์ฌ์ฉํ ์ ์๋ค.
- jdk 1.7 ์ด์ ๋ฒ์ ์์๋ switch ๋ฌธ์ case์ ๋ฌธ์๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
๋ฐ๋ณต๋ฌธ(Loop Statement)
- ๋ฐ๋ณต๋ฌธ์ ๋จ์ํ ์ผ์ ๋ฐ๋ณตํ ๋ ์ฌ์ฉํ๋ค.
- ๋ฐ๋ณต์ "์๋ํ"๋ฅผ ์ํด ๊ฐ์ฅ ์ค์ํ ์กฐ๊ฑด์ด๋ค.
- ๋ฐ๋ณต ์ญ์ "ํน์ ํ ์กฐ๊ฑด" ์ด ๋ง์กฑ๋์ด์ผ ๋ฐ๋ณต๋๋ค.
- ๋ฐ๋ณต๋ฌธ์ ์ข ๋ฅ : for ๋ฌธ , while ๋ฌธ
// ์ธ์ ์ ๋ฆฌํ์ง, ํน์ง์ด ๋ญ์ง, ์ธ์ ์ฌ์ฉ๋๋์ง ์๊ธฐ!
//** ๋ฐ๋ณต๋ฌธ ์์ฑํ๊ธฐ ์ ์ ๋จ์ํ๊ฒ ์์ฑํด๋ณด๊ณ ๊ท์น์ ์ฐพ์์ ์์ฑํ๊ธฐ ์์ํ๋ฉด ์ฌ์!!!****
for ๋ฌธ
- ์ข ๋ฃ ํ์๊ฐ ์ ํด์ง ๊ฒฝ์ฐ ์ ์ฉํ๋ค.
- ์์ ) ๋ฌผ 10์ ๋ ๋ค ์ค.
for(์ด๊ธฐ๊ฐ; ์กฐ๊ฑด; ์ฆ๊ฐ) {
ํด์ผํ ์ผ;
}
// ์ปคํผ 10์์ ํ๋ค. ๋ฌผ ํ ์ ๋น 2๊ฐ์ ์ปคํผ ๋ฏน์ค๋ฅผ ๋ฃ๋๋ค.
for (int i = 1; i <= 10; i++) {
๋ฌผ ๋ ์ค๊ธฐ;
for ( int j =1; j <= 2; j++) {
์ปคํผ ๋ฏน์ค ๋ฃ๊ธฐ;
}
}
while ๋ฌธ
- ์ข ๋ฃ ํ์๊ฐ ์ ํด์ง์ง ์์ ๊ฒฝ์ฐ ์ ์ฉํ๋ค.
- ์์ ) ๋ด๊ฐ ๊ทธ๋ง์ด๋ผ๊ณ ํ ๋ ๊น์ง A4์ฉ์ง ์ข ๋ฆฌํํด์ค.
while(์กฐ๊ฑด) {
ํด์ผํ ์ผ;
}
do while ๋ฌธ
- ์ผ๋จ ์ ์ง๋ฌ ๋๊ณ ์กฐ๊ฑด์ ์ฒดํฌํ๋ค.
- ์ฆ, do ์ ๋ด์ฉ์ ์คํ ํ while ์ ์ง์ ์ฌ๋ถ๋ฅผ ์ฒดํฌ
do {
ํด์ผํ ์ผ;
} while(์กฐ๊ฑด);
public static void main(String[] args) {
//while์ ์กฐ๊ฑด์ ๋ณด๊ณ ์คํ ์ฌ๋ถ๋ฅผ ํ๋จ
int i = 11;
while (i<10) {
i++;
}
System.out.println("while cnt:"+i);
//do while์ ์ผ๋จ ์คํํ๊ณ ๋ค์ ์คํ ์ฌ๋ถ๋ฅผ ํ๋จํ๋ค.
i = 11;
do {
i++;
} while (i<10);
System.out.println("do while cnt:"+i);
}
// while๊ณผ do while ์ ์กฐ๊ฑด์ด ๋ฌธ์ ๊ฐ ์์ ๊ฒฝ์ฐ ๋์ผํ ๊ฒฐ๊ณผ๋ฅผ ๋ธ๋ค.
// ํ์ง๋ง ์ด๊ธฐ ์กฐ๊ฑด์ด ๋ง์ง ์์ ๊ฒฝ์ฐ ์ฐจ์ด๋ฅผ ๋ณด์ธ๋ค. (do๋ ์ด๊ธฐ ์กฐ๊ฑด์ด ๋ง์ง ์์๋ ์ผ๋จ ์คํํ๋๊น.)
๋น ์ ธ๋๊ฐ๊ฑฐ๋(break) ๋ฌด์ํ๊ธฐ(continue)
- ํ๋ก๊ทธ๋๋ฐ์์ ๋ฌธ์ฅ๋ค์ code block {} ์์์ ์คํ๋๋ค.
1. break : ํน๋ณํ ๊ฒฝ์ฐ ์์ญ ์์ ๋ด์ฉ์ ๋ชจ๋ ์คํํ์ง ์๊ณ ๋น ์ ธ ๋์ค๋ ๋ฐฉ๋ฒ
์์ code block์ ๋๊ฐ๋ฒ๋ฆฌ๊ธฐ ๋๋ฌธ์ ๋ ์ด์ ์คํ๋์ง ์๋๋ค.
public static void main(String[] args) {
// break : ํด๋น ๊ตฌ๋ฌธ์ ํ์ถ ํ๋ค.
for (int i = 0; i < 10; i++) {
if (i==3) {
break; //i๊ฐ 3์ผ ๋ ํ์ถํด ๋ฒ๋ ธ์ผ๋ฏ๋ก 3์ ์ถ๋ ฅ๋์ง ์๋๋ค.
}
System.out.println(i);
}
System.out.println();
/* ๊ฒฐ๊ณผ๊ฐ
* 0
* 1
* 2
* 4
* 5
* 6
* 7
* 8
* 9
*/
// continue : ๋ด ์๋ ๊ตฌ๋ฌธ์ ๋ฌด์ํด๋ผ.
for (int i = 0; i < 10; i++) {
if (i==3) {
continue; //i๊ฐ 3์ผ ๋ ์๋ ๊ตฌ๋ฌธ์ ๋ฌด์ํ๊ณ ๋์ด๊ฐ์ผ๋ฏ๋ก 3์ด ์ถ๋ ฅ๋์ง ์๋๋ค.
}
System.out.println(i);
/* ๊ฒฐ๊ณผ๊ฐ
* 0
* 1
* 2
* 4
* 5
* 7
* 8
*/
}
2. continue : ํน๋ณํ ๊ฒฝ์ฐ ๋ฌด์ํ๊ณ ์ง๋์น๋ ๋ฐฉ๋ฒ
code block์ ๋๊ฐ๋ ๊ฒ์ด ์๋ ํน์ ์ํฉ๋ง์ ๋ฌด์ํ๊ณ ์๋ก ๋ค์ ์ฌ๋ผ๊ฐ๋ ๊ฒ์ด๋ฏ๋ก ๊ณ์ ์คํ๋๋ค.
๋ฐฐ์ด(Array)
- ๋ณ์๋ ๋ฌผ์ด๋ ๊ฐ์ข ์๋ฃ๋ฅผ ๋ด๊ณ ์๋ ์๊ณผ ๊ฐ๋ค๊ณ ํ๋ค.
- ๋ฐฐ์ด์ ๋ณ์๋ฅผ ์ผ๋ ฌ๋ก ์ธ์๋๊ณ ๊ฐ ์์์ ๋ฒํธ๋ฅผ ๋ถ์ฌ ๋์ ํํ. ์ฆ, ์ฌ๋ฌ ๊ฐ์ ๋ณ์๋ฅผ ํ๋์ ๋ด๋ ๊ธฐ๋ฅ.
- ๋ณ์๊ฐ ๋งฅ์ฃผ๊ฐ ๋ค์ด์๋ ๋งฅ์ฃผ์์ด๋ผ๋ฉด ๋ฐฐ์ด์ ์ฌ๋ฌ ๋งฅ์ฃผ๋ฅผ ์ธ์๋์ ๋งฅ์ฃผ ์ํ๋ฌ.
- ๋ณ์ 100๊ฐ vs ๋ฐฐ์ด ํ๋
- : ๋ณ์๋ 100๊ฐ ๋ชจ๋ ๋ค๋ฅธ ์ด๋ฆ์ ๊ฐ์ง๊ณ ์์ด์ผ ํ๋ค.
- : ๋ฐฐ์ด์ ํ๋์ ์ด๋ฆ๋ง์ ๊ฐ์ง๊ณ ์์ผ๋ฉด ๋๋ฉฐ, ๋ฐฐ์ด์ ์์๋ค์ ๊ฐ์ ๋ฐฐ์ด์ ๋ฐฉ ๋ฒํธ๋ฅผ ๋ถ๋ฅด๋ฉด ๋๋ค.
- -> ๋ฐฐ์ด์ ๊ฐ ์์๋ค์ ๊ธฐ์ค ์์์ ์ผ๋ง๋ ๋จ์ด์ ธ ์๋์ง๊ฐ ์๋์ผ๋ก ์ด๋ฆ์ด ๋๋ค.
- ๋ฐฐ์ด์ ์ฒซ๋ฒ์งธ ๊ฐ์ 0๋ฒ์งธ ==> 3๋ฒ์งธ ๊ฐ์ ๊ธฐ์ค ์์ธ 0๋ฒ์งธ ์์ผ๋ก๋ถํฐ 2์นธ ๋จ์ด์ ธ ์์ผ๋ฏ๋ก ๋ฐฐ์ด์ 2๋ฒ์งธ
- ๋ฐฐ์ด a[0] a[1] a[2] a[3] ...
- 0๋ถํฐ ์์ํ๋ ๊ฒ์ ์๊ธฐ ์์ ์ด ๊ธฐ์ค์ด ๋๊ธฐ ๋๋ฌธ.
- ๋ฐฐ์ด์ ๋ช ๊ฐ์ ๋ฐ์ดํฐ๊ฐ ๋ค์ด๊ฐ์ผ ํ ์ง ๋ฏธ๋ฆฌ ์ ํด์ค์ผ ํ๋ค.
๋ค์ฐจ์ ๋ฐฐ์ด
- ๋ฐฐ์ด์ 1์ฐจ์ ๋ฐฐ์ด, 2์ฐจ์ ๋ฐฐ์ด, 3์ฐจ์ ๋ฐฐ์ด ๋ฑ ๋ค์ฐจ์ ๋ฐฐ์ด์ ํ์ฉํ ์ ์๋ค.
- ๋ค์ฐจ์ ๋ฐฐ์ด์ ๊ฐ๋
์ ์ํํธ์ ๋ฐฉ์ ๊ฐ๋
์ผ๋ก ์๊ฐํด ๋ณผ ์ ์๋ค.
<2์ฐจ์> Royal ์ํํธ 1์ธต 2ํธ royal[1][2]
<3์ฐจ์> Royal ์ํํธ 1์ธต 2ํธ 1๋ฒ ๋ฐฉ royal[1][2][1]
โป String str = null; // ์ง์ง ์๋ฌด ๊ฒ๋ ์๋.. ์ง๊ณต ์ํ์ ์์
String str2 =""; //๋น ๊ฐ์ด๋ผ๋ ์ ๋ณด๋ฅผ ๊ฐ์ง๊ณ ์๋.. ๊ณต๊ธฐ๋ ์๋ ์ํ์ ์์
ํฅ์๋ for๋ฌธ
๊ธฐ์กด ๋ฐฉ์์ for๋ฌธ
int[] scores = {95,75,84,35};
for(int i=0; i<score.length; i++) {
System.out.println(score[i]);
}
ํฅ์๋ for๋ฌธ = i๋ฅผ ํตํ ์์ ์ ๋ณด๊ฐ ํ์ํ์ง ์์ ๋ ์ฌ์ฉ.
int[] scores = {95,75,84,35};
for(int s:score) {
System.out.println(s);
}
- ๋ฐฐ์ด(score)์ ์๋ ๊ฐ์ ํ๋์ฉ ๋ฝ์์ ์์ ๋ณ์(s)์ ์ ๋ฌ
- ์ฅ์ : ๊ฐํธํ๋ค
- ๋จ์ : ๋ช ๋ฒ์งธ ๊ฐ์ธ์ง ์์๋ฅผ ์๊ธฐ ์ด๋ฝ๋ค.
- ๋ฐ๋ผ์ i๋ฅผ ํตํ ์์ ์ ๋ณด๊ฐ ํ์ํ์ง ์์ ๋ ์ฌ์ฉํ๋ค.
- ๋ง์ผ ํฅ์๋ for ๋ฌธ์ ๊ผญ ์ฌ์ฉํ๋ฉด์ ์์๋ ์๊ณ ์ถ๋ค๋ฉด ์๋์ ๊ฐ์ด ์ฌ์ฉํ๋ค.
int cnt = 0; //ํฅ์๋ for๋ฌธ์ ์์๋ฅผ ์ ์ ์๊ธฐ ๋๋ฌธ์ ํ์ํ๋ค๋ฉด ๋ณ์๋ฅผ ๋ฐ๋ก ์ ์๋ฅผ ๋ด๋ ค์ค์ผํ๋ค.
for (int score : scores) {
System.out.println(cnt+" : "+score);
cnt++;
'Back-End > JAVA' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
JAVA, SPRING ๊ธฐ์ ๋ฉด์ ์ ๋ฆฌ (0) | 2022.09.06 |
---|---|
[์๋ฐ] ๋ฌธ์์ด๊ณผ ์ ๋๋ฆญ (String & Generic) (0) | 2022.04.20 |
STS /์ดํด๋ฆฝ์ค] ์ฌ์ฉ๋ฒ (๊ณ์ ์ถ๊ฐ) (0) | 2022.04.08 |
[์๋ฐ] JAVA, STS ์ค์น (0) | 2022.04.07 |
[์๋ฐ] ์๋ฐ ๊ธฐ์ด ๊ฐ๋ (0) | 2022.04.07 |