
1. for๋ฌธ
๐ก๋ฐ๋ณต ํ์๋ฅผ ์๊ณ ์์ ๋ ์ฃผ๋ก ์ฌ์ฉ
for๋ฌธ์ ๊ตฌ์กฐ์ ์ํ ์์
- ์ด๊ธฐํ
- ์กฐ๊ฑด์
- ์ฆ๊ฐ์
- ๋ธ๋ก {}
for(์ด๊ธฐํ; ์กฐ๊ฑด์; ์ฆ๊ฐ์;) {
... // ์กฐ๊ฑด์์ด ์ฐธ์ผ ๋ ์ํ๋๋ค.
}
์ํ ์์
1. ์ด๊ธฐํ
2. ์กฐ๊ฑด์
3. ์ํ๋ ๋ฌธ์ฅ
4. ์ฆ๊ฐ์

์ด๊ธฐํ
๐ก ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉ๋ ๋ณ์๋ฅผ ์ด๊ธฐํํ๋ ๊ณผ์ , ์ฒ์์ ๋จ ํ๋ฒ ์ํ๋๋ค.
for(int i = 0; i < 5; i++) {...} // ๋ณ์ 1๊ฐ
for(int i = 0, j = 0; i < 5; i++) {...} // ๋ณ์ 2๊ฐ -> ,(์ฝค๋ง)๋ฅผ ๊ตฌ๋ถ์๋ก ๋ณ์ ์ด๊ธฐํ
์กฐ๊ฑด์
๐ก ์กฐ๊ฑด์์ ๊ฐ์ด ์ฐธ(true)์ด๋ฉด ๋ฐ๋ณต ๊ณ์ ์งํํ๊ณ ๊ฑฐ์ง(false)์ด๋ฉด ๋ฐ๋ณต์ ์ค๋จํ๊ณ for๋ฌธ์์ ๋ฒ์ด๋๋ค.
โ ์กฐ๊ฑด์์ด โ์ฐธ์ธ ๋์โ ๋ฐ๋ณต์ ๊ณ์ํจ
for(int i = 0; i < 5; i++) {...} // i๊ฐ 5๋ณด๋ค ์์ ๋์ ๋ฐ๋ณต
์ฆ๊ฐ์
๐ก๋ฐ๋ณต๋ฌธ์ ์ ์ดํ๋ ๋ณ์์ ๊ฐ์ ์ฆ๊ฐ ๋๋ ๊ฐ์์ํค๋ ์
๋งค ๋ฐ๋ณต๋ง๋ค ๋ณ์์ ๊ฐ์ด ์ฆ๊ฐ์์ ์ํด์ ์กฐ๊ธ์ฉ ๋ณํ๋ค๊ฐ ๊ฒฐ๊ตญ ์กฐ๊ฑด์์ด ๊ฑฐ์ง์ด ๋์ด for๋ฌธ์ ๋ฒ์ด๋๊ฒ ๋๋ค.
for(int i = 1; i <= 10; i++) { ... } // 1๋ถํฐ 10๊น์ง 1์ฉ์ฆ๊ฐ
for(int i = 10; i >= 1; i--) { ... } // 10๋ถํฐ 1๊น์ง 1์ฉ๊ฐ์
for(int i = 1; i <= 10; i+= 2) { ... } // 1๋ถํฐ 10๊น์ง 2์ฉ์ฆ๊ฐ
for(int i = 1; i <= 10; i*= 3) { ... } // 1๋ถํฐ 10๊น์ง 3๋ฐฐ์ฉ์ฆ๊ฐ
์ด๊ธฐํ, ์กฐ๊ฑด์, ์ฆ๊ฐ์ ์ด ์ธ๊ฐ์ง ์์๋ ํ์ํ์ง ์์ผ๋ฉด ์๋ตํ ์ ์๋ค.
โ ๋ชจ๋ ์๋ตํ๋ ๊ฒ๋ ๊ฐ๋ฅ!!
for(;;) {...} // ์ด๊ธฐํ, ์กฐ๊ฑด์, ์ฆ๊ฐ์ ๋ชจ๋ ์๋ต. ์กฐ๊ฑด์์ ์ฐธ
์กฐ๊ฑด์์ด ์๋ต๋ ๊ฒฝ์ฐ: ์ฐธ(true)๋ก ๊ฐ์ฃผ๋์ด ๋ฌดํ ๋ฐ๋ณต๋ฌธ์ด ๋๋ค.
โ ๋ธ๋ญ{} ์์ if๋ฌธ์ ๋ฃ์ด์ ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ฉด for๋ฌธ์ ๋น ์ ธ๋์ค๊ฒ ํด์ ํ๋ค.
๋ณ์ 1๊ฐ vs ๋ณ์ 2๊ฐ
โ ๋ณ์๊ฐ 1๊ฐ์ธ for๋ฌธ, ๋ณ์๊ฐ 2๊ฐ์ธ for๋ฌธ์ ๊ฐ๊ฐ ๋ง๋ค์ด์ ์๋์ ์คํ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํด๋ผ.

for(int i = 1, j = 10; i <= 10; i++, j--) {
System.out.printf("%d\t %d\n", i, j);
}
for(int i = 1; i <= 10; i++) {
System.out.printf("%d\t %d\n", i, 11 - i);
}
for๋ฌธ์ ์ฌ์ฉ๋๋ ๋ณ์์ ์๊ฐ ์ ์ ๊ฒ์ด ๋ ํจ์จ์ ์ด๊ณ ๊ฐ๋จํ๋ฏ๋ก ๋ณ์๋ค์ ๊ด๊ณ๋ฅผ ์ ํ์ ํ์ฌ ๋ถํ์ํ ๋ณ์์ ์ฌ์ฉ์ ์ค์ด๋ ๊ฒ์ด ์ข๋ค.
โ ๊ฐ์ ๊ฒฐ๊ณผ๋ผ๋ฉด ๋ ์ ์ ๋ณ์ ์ฌ์ฉํ๊ธฐ!
์ค์ฒฉ for๋ฌธ
๐ก for๋ฌธ ์์ ๋ ๋ค๋ฅธ for๋ฌธ์ ํฌํจ์ํค๋ ๊ฒ

for(int i = 1; i <= 3; i++)
for(int j = 1; j <= 3; j++)
for(int k = 1; j <= 3; k++)
System.out.println(""+i+j+k);
i, j, k๊ฐ ๊ฐ๊ฐ 1, 2, 3์ผ ๋
"" + i + j + k
-> "" + 1 + 2 + 3
-> "1" + 2 + 3
-> "12" + 3
-> "123"
๋ฌธ์์ด์ ์ด๋ค type๋ ๋ํด๋ ๋ฌธ์์ด์ด ๋๋ค.
ํฅ์๋ for๋ฌธ
for(ํ์
๋ณ์๋ช
: ๋ฐฐ์ด๋๋์ปฌ๋ ์
) {
// ๋ฐ๋ณตํ ๋ฌธ์ฅ
}
ํ์ : ๋ฐฐ์ด ๋๋ ์ปฌ๋ ์ ์ ์์์ ํ์
์์: int [] arr = {10, 20, 30, 40 ,50};
for(int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
for(int tmp: arr) {
System.out.println(tmp);
}
ํฅ์๋ for๋ฌธ์ ์ผ๋ฐ์ ์ธ for๋ฌธ๋ณด๋ค ๊ฐ๊ฒฐํ์ง๋ง ๋ฐฐ์ด์ด๋ ์ปฌ๋ ์ ์ ์ ์ฅ๋ ์์๋ฅผ ์ฝ์ด์ค๋ ์ฉ๋๋ก๋ง ์ฌ์ฉํ ์ ์๋ค๋ ์ ์ฝ์ด ์๋ค.
์ํ๋ ๋ฌธ์ฅ์ด ์๋ for๋ฌธ
for(int j = 0; j <2_000_000_000; j++) ๏ฝ
; // ์๋ฌด๋ฐ ๋ด์ฉ๋ ์๋ ๋น ๋ฌธ์ฅ
}
for(int j = 0; j <2_000_000_000; j++); // ํ ๋ฌธ์ฅ์ด๋ผ ๊ดํธ{} ์๋ต ๊ฐ๋ฅ
for(int j = 0; j <2_000_000_000; j++) {} // ๊ดํธ{}์์ ๋ฌธ์ฅ์ ๋ฃ์ง ์์๋ ๋จ
์์)
for (i = 1; i <= 10; i++); // ๋น ๋ฌธ์ฅ ';'์ 10๋ฒ ๋ฐ๋ณตํ๋ค.
{
System.out.println("i = " + i); // i = 11 ์ด ์ถ๋ ฅ๋๋ค.
}
๋น ๋ฌธ์ฅโ;โ๋ง for๋ฌธ์ ์ํ ๊ฒ์ผ๋ก ๊ฐ์ฃผ๋์ด ๋ธ๋ก {}์ ๋ฐ๋ณต๋์ง ์๋๋ค. ๋จ ํ๋ฒ๋ง ์ํ๋๋ค.
2. while๋ฌธ
๐ก์กฐ๊ฑด์์ด ์ฐธ(true)์ธ ๋์, ์ฆ ์กฐ๊ฑด์์ด ๊ฑฐ์ง์ด ๋ ๋๊น์ง ๋ธ๋ญ {} ๋ด์ ๋ฌธ์ฅ์ ๋ฐ๋ณตํ๋ค.
while(์กฐ๊ฑด์) {
... // ์กฐ๊ฑด์์ ์ฐ์ฐ๊ฒฐ๊ณผ๊ฐ ์ฐธ(true)์ธ ๋์, ๋ฐ๋ณต๋ ๋ฌธ์ฅ๋ค์ ์ ๋๋ค.
}

1. ์กฐ๊ฑด์์ด ์ฐธ์ด๋ฉด ๋ธ๋ก{ } ์์ผ๋ก ๋ค์๊ฐ๊ณ , ๊ฑฐ์ง์ด๋ฉด while๋ฌธ์ ๋ฒ์ด๋๋ค.
2. ๋ธ๋ญ{ }์ ๋ฌธ์ฅ์ ์ํํ๊ณ ๋ค์ ์กฐ๊ฑด์์ผ๋ก ๋์๊ฐ๋ค.
for๋ฌธ๊ณผ while๋ฌธ์ ๋น๊ต
for๋ฌธ
for(int i = 1; i <= 10;i++) {
System.out.println(i);
}
while๋ฌธ
int i = 1;
while(i <= 10) {
System.out.println(i);
i++;
}
for๋ฌธ์ ์ด๊ธฐํ. ์กฐ๊ฑด์, ์ฆ๊ฐ์์ ํ ๊ณณ์ ๋ชจ์ ๋์ ๊ฒ์ผ ๋ฟ. while๋ฌธ๊ณผ ๋ค๋ฅด์ง ์๋ค
๋ง์ผ ์ด๊ธฐํ๋ ์ฆ๊ฐ์์ด ํ์ํ์ง ์์ ๊ฒฝ์ฐ๋ผ๋ฉด, while๋ฌธ์ด ๋ ์ ํฉํ ๊ฒ์ด๋ค.
while๋ฌธ์ ์กฐ๊ฑด์์ ์๋ต ๋ถ๊ฐ
while () { // ERROR ์กฐ๊ฑด์์ด ์์!
...
}
๋ฌดํ ๋ฐ๋ณต๋ฌธ (์กฐ๊ฑด์์ด ํญ์ true)
for(;;) {
...
}
while(true) {
...
}
3. do - while๋ฌธ
do {
... // ์กฐ๊ฑด์์ ์ฐ์ฐ๊ฒฐ๊ณผ๊ฐ ์ฐธ์ผ ๋ ์ํ๋๋ ๋ฌธ์ฅ๋ค
} while (์กฐ๊ฑด์); -> ๋์ ';'์ ์์ง ์๋๋ก ์ฃผ์!!
์ต์ํ ํ ๋ฒ์ ๋ธ๋ก์ด { } ๋ฌด์กฐ๊ฑด ์ํ๋๋ค.
โ ๋ค์๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ์ถ๋ ฅ๋๋๋ก do-while๋ฌธ์ ์ฌ์ฉํ์ฌ 3, 6, 9 ๊ฒ์์ ๊ตฌํํ๋ผ. (๋จ, ๋ฒ์๋ 1์์ 100๊น์ง์ด๋ค.)

public class game369{
public static void main(String[] args) {
for (int i = 1; i <= 100; i++) {
System.out.printf("i = %d ", i);
int tmp = i;
do {
if (tmp % 10 % 3 == 0 && tmp % 10 != 0) { // ๋์๋ฆฌ๊ฐ 3์ ๋ฐฐ์์ธ์ง ํ์ธ (0์ ์ ์ธ)
System.out.print("์ง");
}
} while ((tmp /= 10) != 0);
System.out.println();
}
}
}
4. break๋ฌธ
๐ก ์์ ์ด ํฌํจ๋ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ฐ๋ณต๋ฌธ์ ๋ฒ์ด๋๋ค.
while(true) {
if(sum > 100)
break;
i++;
sum += i;
}
๋ฌดํ ๋ฐ๋ณต๋ฌธ์๋ ์กฐ๊ฑด๋ฌธ๊ณผ break๋ฌธ์ด ํญ์ ๊ฐ์ด ์ฌ์ฉ๋๋ค.
5. continue๋ฌธ
๐ก ๋ฐ๋ณต์ด ์งํ๋๋ ๋์ค์ ๋ฐ๋ณต๋ฌธ์ ๋์ผ๋ก ์ด๋ํ์ฌ ๋ค์ ๋ฐ๋ณต์ผ๋ก ๋์ด๊ฐ๋ค.
์ ์ฒด ๋ฐ๋ณต ์ค ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฒฝ์ฐ๋ฅผ ์ ์ธํ๊ณ ์ ํ ๋ ์ ์ฉํ๋ค.
3์ ๋ฐฐ์ ์ ์ธ

for (int i = 1; i <= 10; i++) {
if (i % 3 == 0) {
continue;
}
System.out.println(i);
}
break๋ฌธ & continue๋ฌธ

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (true) {
int num = scanner.nextInt();
if (num == 0) {
System.out.println("ํ๋ก๊ทธ๋จ ์ข
๋ฃ");
break;
} else if (num == 1) {
System.out.println("์ฌ์
๋ ฅ");
continue;
}
System.out.println("๊ตฟ");
}
}
์ ๋ ฅ ๊ฐ ๋ณ๋ก ๋ฐ๋ก ์ฒ๋ฆฌํ๊ณ ์ถ์ ๊ฒฝ์ฐ์ ์ ์ฉํ๋ค.
6. ์ด๋ฆ ๋ถ์ ๋ฐ๋ณต๋ฌธ

0์ ์ ๋ ฅํ๋ ๊ฒฝ์ฐ for๋ฌธ์ ๋ฒ์ด๋๊ณ 99๋ฅผ ์ ๋ ฅํ๋ ๊ฒฝ์ฐ 'break outer'์ ์ํด for๋ฌธ๊ณผ while๋ฌธ์ ๋ชจ๋ ๋ฒ์ด๋ ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ๋๋ค.
Reference
์๋ฐ์ ์ ์ - ๋จ๊ถ ์ฑ
'๐ Book > ์๋ฐ์ ์ ์' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
5-2์ฅ String๋ฐฐ์ด (0) | 2023.03.29 |
---|---|
5-1์ฅ ๋ฐฐ์ด (0) | 2023.03.29 |
4-1์ฅ ์กฐ๊ฑด๋ฌธ (0) | 2023.03.29 |
3-6์ฅ ๊ธฐํ ์ฐ์ฐ์ (0) | 2023.03.14 |
3-5์ฅ ๋ ผ๋ฆฌ ์ฐ์ฐ์ (1) | 2023.03.14 |
๋๊ธ