๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
JAVA/๊ธฐ๋ณธ ์ด๋ก 

8. ๋ฐ˜๋ณต๋ฌธ - for ๋ฌธ

by ๐Ÿณ Laboon 2024. 2. 10.
๋ฐ˜๋ณต๋ฌธ์ด๋ž€?

 

ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด์—์„œ ๋ฐ˜๋ณต๋ฌธ์ด๋ž€ ๋ง ๊ทธ๋Œ€๋กœ ๋ฐ˜๋ณตํ•˜๋Š” ๊ณผ์ •์„ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ๋Š” ๋ฌธ๋ฒ•์„ ๋œปํ•œ๋‹ค.

๋ฐ˜๋ณต๋ฌธ์—๋Š” ์ž˜ ์•Œ๋ ค์ง„ 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