๋ฐ๋ณต๋ฌธ์ด๋?
ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ๋ฐ๋ณต๋ฌธ์ด๋ ๋ง ๊ทธ๋๋ก ๋ฐ๋ณตํ๋ ๊ณผ์ ์ ์ํํ ์ ์๋ ๋ฌธ๋ฒ์ ๋ปํ๋ค.
๋ฐ๋ณต๋ฌธ์๋ ์ ์๋ ค์ง for๋ฌธ๊ณผ while๋ฌธ์ด ์กด์ฌํ๋ค.
์ถ๊ฐ๋ก do while๋ฌธ๋ ์กด์ฌํ๋๋ฐ ์์ง ๊น์ง๋ ํน๋ณํ ๊ฒฝ์ฐ๋ฅผ ์ ์ธํ๊ณ ๋ ์ฌ์ฉ์ ํ์ง ์์๋ค.
for๋ฌธ
for๋ฌธ์ ๊ธฐ๋ณธ์ ์ธ ๋ฌธ๋ฒ์ผ๋ก ๋๋ถ๋ถ์ ์ฌ๋์ด ์ ์๊ณ ์๋ค.
ํ์ง๋ง, ์๊ฐ๋ณด๋ค ํท๊ฐ๋ คํ๋ ํฌ์ธํธ๋ค์ด ์์ด์ ๊ทธ๊ฒ์ ์ง๊ธฐ ์ํด์ ๊ฐ์ ธ์๋ค.
์ฐ์ , ์ฌ๋งํ ์ฑ ์์ ์ค๋ช ํ๋ for๋ฌธ์ ๊ธฐ๋ณธ ๊ตฌ์ฑ์ ์๋์ ๊ฐ๋ค.
for (int i = 0; i < 10; i++) {}
๋๋ถ๋ถ ์ฌ๊ธฐ์ int i = 0 ์ ์ด๊ธฐ๊ฐ, i < 10์ ์กฐ๊ฑด์, i++์ ์ฆ๊ฐ์์ด๋ผ๊ณ ํํํฉ๋๋ค.
for (์ด๊ธฐ๊ฐ; ์กฐ๊ฑด์; ์ฆ๊ฐ์)
๊ทผ๋ฐ ์ ๋ ํท๊ฐ๋ฆฌ๋ ๋ถ๋ถ์ด ์ข ์์์ต๋๋ค.
๋งจ ์ฒ์ for๋ฌธ์ ์ ํ์ ๋, ์กฐ๊ฑด์์ด ' i < 10 ' ์ด๋ฉด i < 10 ์ผ ๋๊น์ง? ์ธ๊ฐ? ๋ผ๋ ์๊ฐ ๋๋ฌธ์ ์กฐ๊ธ ํค๋งธ์์ต๋๋ค.
for๋ฌธ์ ๋ป
๊ทธ๋์ ์ ๋ ์ ๊ฐ ์ดํดํ๊ธฐ ์ฌ์ด ๋ฐฉ์์ผ๋ก ์ ๊ทผ ํ์ต๋๋ค.
for๋ผ๋ ๋ป์ ~ ๋์ ์ด๋ผ๋ ๋ป์ด ์์ต๋๋ค.
์ด ๋ป ๊ทธ๋๋ก for ๋ฌธ์ '์กฐ๊ฑด์' ๋์ ์ํํ๊ฒ ๋ค. ์ด ๋ป์ผ๋ก ํด์ํด์ผ ํฉ๋๋ค.
์ฆ, ์กฐ๊ฑด์์ด i < 10 ์ด๋ฉด ๋ณ์ i๊ฐ 10๋ณด๋ค ์์ ๋, ๊ณ์ ์ํํ๋ค๋ ๋ง์ ๋๋ค.
for๋ฌธ์ ์ํ ์์
for (int i = 10, j = 20, cnt = 1; i < j; i++, j-=2, cnt++) {
System.out.printf("for %d๋ฒ ์งธ : i = %d, j = %d\n", cnt, i, j);
}
์์ ๊ฐ์ ์ฝ๋๋ฅผ ์คํํด๋ณด๊ฒ ์ต๋๋ค.
์ฒซ ๋ฒ์งธ ์ํ (์ด๊ธฐ๊ฐ),
๋จผ์ , '์ด๊ธฐ๊ฐ'์ ๋ค์ด๊ฐ๋ ๋ด์ฉ์ 0๊ฐ ์ด์ ์์ฑํ๋ฉด ๋ฉ๋๋ค.
์ด๊ธฐ๊ฐ์ ์ค์ ํ์ง ์์๋ ์ํ๋๋ ๊ฒ์ด์ฃ .
์ ๋ 3๊ฐ์ ๋ณ์ i, j, cnt๋ฅผ ์ด๊ธฐ๊ฐ์ผ๋ก ํน์ ๊ฐ์ ํ ๋น ํ์ต๋๋ค.
๋ ๋ฒ์งธ ์ํ (์กฐ๊ฑด์),
์กฐ๊ฑด๋์ for๋ฌธ์ ์ํํ ์ ์๋์ง ํ์ธํฉ๋๋ค.
์กฐ๊ฑด์ i < j ์ด๋ฏ๋ก, (i : 10) < (j : 20) ๋ฅผ ๋ง์กฑํฉ๋๋ค.
๋ ๋ฒ์งธ ์ํ์์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฒฝ์ฐ ์ธ ๋ฒ์งธ ์ํ์ผ๋ก ๋์ด๊ฐ๊ณ ,
์กฐ๊ฑด์ ๋ง์กฑํ์ง ์๋ ๊ฒฝ์ฐ ์ฌ๊ธฐ์ for๋ฌธ์ ์ข ๋ฃ๋ฉ๋๋ค.
โป ์กฐ๊ฑด์์ boolean ๊ฐ๋ง ๋ฉ๋๋ค. C++์ ๋ค๋ฆ.
์ธ ๋ฒ์งธ ์ํ (๋ฌธ๋ฒ),
๋ ๋ฒ์งธ ์ํ์์ ๋ง์กฑํ ๊ฒฝ์ฐ ์ธ ๋ฒ์งธ ์ํ์ ํฉ๋๋ค.
์ธ ๋ฒ์งธ ์ํ์ for ๋ฌธ์ ์ค๊ดํธ { } ๋ก ๋ฌถ์ฌ ์๋ ๋ฌธ๋ฒ์ ์ํํ๋ ๊ฒ ์ ๋๋ค.
์ฐ๋ฆฌ๊ฐ ์ํํ ๋ฌธ๋ฒ์ for๋ฌธ์ ๊ฐ ์ํ ํ์์ ๋ํ i์ j๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
๋ชจ๋ ๋ฌธ๋ฒ์ด ๋๋๋ฉด ๋ค ๋ฒ์งธ ์ํ์ ์์ํฉ๋๋ค.
๋ค ๋ฒ์งธ ์ํ (์ฆ๊ฐ์),
์ฌ๋๋ค์ด ๋ง์ ์ฆ๊ฐ์์ผ๋ก ํํํ ๊ฒ์ด์ง ์ฌ์ค์ ๋ค์ ์ํํ ๋ช ๋ น์ ๋๋ค.
์ฆ ๋ฌธ๋ฒ์์ ๋ง์ง๋ง ์ค์ ์ถ๊ฐํ๋ ๊ฒ๊ณผ ๊ฐ์ต๋๋ค.
์ฐ์ ์ ์ฝ๋์์ ํด๋นํ๋ ๋ค ๋ฒ์งธ ์ํ์ cnt์ i๋ฅผ 1์ฉ ์ฆ๊ฐํ๊ณ j๋ฅผ 2์ฉ ๊ฐ์ํ๋ ๊ฒ์ ๋๋ค.
๋ค์ฏ ๋ฒ์งธ ์ํ (๋ฐ๋ณต),
์กฐ๊ฑด์์ ๋ฐ๋ผ ์ข ๋ฃ ๋ ๋๊น์ง ๋ฐ๋ณตํฉ๋๋ค.
for๋ฌธ์ ์ด๋ ๊ฒ ์ 5๊ฐ์ง ์ฐ์ฐ์ผ๋ก ์ด๋ฃจ์ด์ง๋ ๋ฌธ๋ฒ์ ๋๋ค.
for๋ฌธ์ ๋ค์ํ๊ฒ ์ ์ํ๋ ๋ฐฉ๋ฒ
์ ์, ๋ค ๋ฒ์งธ ์ํ์์ ์ฆ๊ฐ์์ด ๋ฌธ๋ฒ ๋ง์ง๋ง์ ๋ถ์ด๋ ๋๋ค๋ ๊ฒ์ ๋ณด์์ ๋
๊ทธ๋ผ ์์ผ๋ ์์ผ๋ ๋ง์ฐฌ๊ฐ์ง๊ฐ ์๋๊ฐ? ๋ผ๋ ์๊ฐ์ด ๋ค๋ฉด ์ ๋ง ์ ์ ๊ทผํ์ต๋๋ค.
์ค์ ๋ก ์ด๊ธฐ๊ฐ, ์กฐ๊ฑด์, ๋ฌธ๋ฒ, ์ฆ๊ฐ์ ๋ชจ๋ ๋น์๋ ๋ฉ๋๋ค.
ํ์์ ๋ฐ๋ผ ์ ์ ํ๊ฒ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ๋ ์๊ณ ๊ฐ์ฅ ๋ณดํธ์ ์ผ๋ก ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ๋ ์์ต๋๋ค.
// ์ด๊ธฐ๊ฐ์ ๋น์ ์ ๋
int i = 0;
for (; i < 10; i++) {}
// ์กฐ๊ฑด์์ ๋น์ ์ ๋ (๋ฌดํ ๋ฃจํ)
for (int i = 0; ;i++) {}
// ๋ฌธ๋ฒ์ ๋น์ ์ ๋
for (int i = 0; i < 5; i++, System.out.println("%d", i));
// ์ฆ๊ฐ์์ ๋น์ ์ ๋
for (int i = 0; i < 5; ) {
System.out.println("%d", i++));
}
// ๋ชจ๋ ๋น์ ์ ๋ (๋ฌดํ ๋ฃจํ)
for ( ; ; );
์์ ๊ฐ์ด ๋ค์ํ๊ฒ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ด ์์ผ๋ ์ฐธ๊ณ ํ๋ฉด ์ข๊ฒ ์ต๋๋ค.
๋์ , ์ค์ํ ์ ์ '์กฐ๊ฑด์'์ ๋น์ฐ๋ ๊ฒฝ์ฐ ์ปดํจํฐ๊ฐ ์ผ๋ง ๋์ ๋ฐ๋ณต์ ์ํํ ๊ฒ์ธ์ง ์ ์ ์์ต๋๋ค.
๊ทธ๋์ ๊ทธ๋ฅ ๊ณ์ ๋ฐ๋ณต์ ์ํํ๊ฒ ๋๋ฏ๋ก ๋ฌดํ ๋ฃจํ์ ๋น ์ง๊ฒ ๋ฉ๋๋ค.
break, continue
์ด๋ฐ ๋ฌดํ ๋ฃจํ์์ ๋น ์ ธ๋์ค๋ ๋ฐฉ๋ฒ์ผ๋ก๋ break ๋ฌธ๋ฒ์ด ์์ต๋๋ค.
break๋ ํ์ฌ ๋ฐ๋ณต์ ์ข ๋ฃํ๊ฒ ๋ค๋ ์๋ฏธ๊ฐ ๋ฉ๋๋ค.
continue ๋ฌธ๋ฒ์ ์ธ ๋ฒ์งธ ์ํ์ ํ์ง ์๊ฒ ๋ค๋ ์๋ฏธ๋ฅผ ๊ฐ์ง ๋ฌธ๋ฒ์ ๋๋ค.
์ฌ๊ธฐ์ ๋ค ๋ฒ์งธ ์ํ์ ๋ํ ํ์์ฑ์ด ๋์ต๋๋ค.
continue ๋ฌธ๋ฒ์ผ๋ก ์ธ ๋ฒ์งธ ์ํ์ ํ์ง ์๋๋ผ๋ ๊ทธ ์ธ ์ํ์ ํ๊ฒ ๋ฉ๋๋ค.
๋ค ๋ฒ์งธ ์ํ(์ฆ๊ฐ์)์ ๋ฌธ๋ฒ์ ๋ง์ง๋ง์ ์ถ๊ฐ ํ์ ๋, ๋ฌธ๋ฒ์์ continue ๋ฌธ๋ฒ์ด ํฌํจ๋์ด ์๋ค๋ฉด
๋ฌธ๋ฒ ๋ง์ง๋ง์ ์ถ๊ฐ๋ ๋ค ๋ฒ์งธ ์ํ์ด ์คํ๋์ง ์์ ๋ ๋ค์ ๋ฌดํ๋ฐ๋ณต์ ๋น ์ง๊ฒ ๋ฉ๋๋ค.
// break๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ
for (int i = 1; i <= 3; i++) {
System.out.printf("%d๋ฒ ์งธ for๋ฌธ ์ํ ๋จ.", i);
break;
}
/*
==== ์ถ๋ ฅ ๊ฒฐ๊ณผ ====
1๋ฒ ์งธ for๋ฌธ ์ํ ๋จ.
*/
// continue๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ
for (int i = 1; i <= 3; i++) {
System.out.printf("%d๋ฒ ์งธ for๋ฌธ ์ํ ๋จ.", i);
continue;
System.out.printf("%d๋ฒ ์งธ for๋ฌธ ์ํ ๋จ.", i++);
}
/*
==== ์ถ๋ ฅ ๊ฒฐ๊ณผ ====
1๋ฒ ์งธ for๋ฌธ ์ํ ๋จ.
2๋ฒ ์งธ for๋ฌธ ์ํ ๋จ.
3๋ฒ ์งธ for๋ฌธ ์ํ ๋จ.
*/
// continue๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ, ๋ค ๋ฒ์งธ ์ํ์ด ์๋ ๊ฒฝ์ฐ
for (int i = 1; i <= 3; ) {
System.out.printf("%d๋ฒ ์งธ for๋ฌธ ์ํ ๋จ.", i);
continue;
System.out.printf("%d๋ฒ ์งธ for๋ฌธ ์ํ ๋จ.", i++);
}
/*
==== ์ถ๋ ฅ ๊ฒฐ๊ณผ ====
System.out.printf("%d๋ฒ ์งธ for๋ฌธ ์ํ ๋จ.", i);
๋ฌดํ ๋ฃจํ
*/
๋ณดํต ๋ฌด์ํ๊ฑฐ๋ ์ข ๋ฃ ํ๋ ๊ฒฝ์ฐ๋ ํน์ ์กฐ๊ฑด์์๋ง ์ํ๋๋ฏ๋ก if๋ฌธ๊ณผ ๊ฐ์ด ์ํ๋ฉ๋๋ค.
for๋ฌธ์ ์ด๋ป๊ฒ ์ฌ์ฉํ๋์?
์ฃผ๋ก for๋ฌธ์ array, ์์ด ๋ฑ ํน์ ํ ๊ท์น์ด ์กด์ฌํ๋ ๊ฒฝ์ฐ ์ฌ์ฉํฉ๋๋ค.
Array์์ for๋ฌธ ์ฌ์ฉ (ํฅ์๋ for ๋ฌธ)
๋ฐฐ์ด์ ์ธ๋ฑ์ค๊ฐ 0๋ฒ์งธ๋ถํฐ ๋ฐฐ์ด์ ํฌ๊ธฐ - 1 ๊น์ง ๊ฐ ์ธ๋ฑ์ค๋ง๋ค 1์ ์ฐจ์ด์ ๊ท์น์ ๊ฐ์ต๋๋ค.
๋ฐฐ์ด์ ์ ๊ทผ ํ ๋๋ ์ธ๋ฑ์ค๋ก ์ ๊ทผํฉ๋๋ค.
๋ฐฐ์ด์ ๋ชจ๋ ์์์ ์ ๊ทผ์ ํ๋ ค๋ฉด for๋ฌธ์ ์ฌ์ฉํ๋ฉด ์ฝ๊ฒ ์ ๊ทผํ ์ ์์ต๋๋ค.
// 1๋ถํฐ 10๊น์ง์ ์์ด ์์ฑ
int[] arr = new int[10];
for (int i = 0; i < arr.length(); i++) {
arr[i] = (i+1);
}
for (int i: arr) {
System.sout.print(i + " ");
}
๊ทธ ์ธ์๋ ๋ค์ํ ๊ท์น์ด ์ฌ์ฉ๋๋ ๊ณณ์์๋ ํ์๋ก ์ฌ์ฉ๋๋ฉฐ,
์ฝ๋ฉ์ for๋ฌธ๊ณผ if๋ฌธ์ผ๋ก ๋ชจ๋ ์ฝ๋๋ฅผ ์์ฑํ ์ ์๋ค๋ ๋ง์ด ์์๋งํผ ์ค์ํ ๋ด์ฉ์ ๋๋ค.
for๋ฌธ์ ์ดํดํ๊ธฐ ์ํด ์ถ์ฒํ๋ ๋ฌธ์
๊ตฌ๊ตฌ๋จ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด๊ธฐ
์์ ์ถ๋ ฅ
1๋จ : 1 2 3 4 5 6 7 8 9
2๋จ : 2 4 6 8 10 12 14 16 18
...
9๋จ : 9 18 27 36 45 54 63 72 81
public class MultiplicationTable
{
public static void main(String[] args) {
for(int i = 1; i <= 9; i++) {
System.out.printf("%d๋จ = ", i);
for(int j = 1; j <= 9; j++) {
System.out.printf("%2d ", i * j);
}
System.out.println();
}
}
}
์์ด [1, 2, 3, 4, 5]์ ๋ค์ง์ด์ ์ถ๋ ฅํ๊ธฐ
์์ ์ถ๋ ฅ
5, 4, 3, 2, 1
public class PrintReverseArray
{
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
for (int i = arr.length - 1; i > 0; i--) {
System.out.printf("%d, ", arr[i]);
}
System.out.printf("%d", arr[0]);
}
}
๋ ธ์ ์ ๋ฆฌ URL
https://www.notion.so/24jihwan/019643d1ca304dd684ceaa73c34cf08e
๋ ผ๋ฆฌ ์ฌ๊ณ | Notion
์ฐ์ฐ์์ ๋ช ๋ น๋ฌธ ์ดํด
24jihwan.notion.site
'JAVA > ๊ธฐ๋ณธ ์ด๋ก ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
4. ์ /์ถ๋ ฅ (Input/Output, I/O) (0) | 2024.02.24 |
---|---|
9. ๋ฐ๋ณต๋ฌธ - while ๋ฌธ, do while ๋ฌธ (1) | 2024.02.10 |
7. ๋ค์ฐจ์ ๋ฐฐ์ด (Multi Dimensional Array) (1) | 2024.02.10 |
6. ๋ฐฐ์ด (Array) (1) | 2024.02.10 |
5. ์ฐ์ฐ์(Operator)์ ์ฐ์ฐ ์์ (1) | 2024.02.10 |