์๋ฐ ํ๋ก๊ทธ๋๋ฐ์์ ๋ฐ๋ณต๋ฌธ์ ๋งค์ฐ ์ค์ํฉ๋๋ค. ๊ทธ์ค ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ด๋ฉด์๋ ์ ์ฉํ while ๋ฌธ์ ๋ํด ์์๋ณด๊ฒ ์ต๋๋ค. while ๋ฌธ์ ์กฐ๊ฑด์ด ์ฐธ์ผ ๋๊น์ง ์ฝ๋ ๋ธ๋ก์ ๋ฐ๋ณต ์คํํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ์ด ๊ธ์์๋ java while ๋ฌธ์ ๊ธฐ๋ณธ ๊ตฌ์กฐ๋ถํฐ ํ์ฉ ๋ฐฉ๋ฒ, ์ฃผ์์ฌํญ๊น์ง ์์ธํ ๋ค๋ค๋ณด๊ฒ ์ต๋๋ค.
โฃ ๋ชฉ์ฐจ
1. while ๋ฌธ ๊ธฐ๋ณธ ๊ตฌ์กฐ๐คนโ๏ธ
while ๋ฌธ์ ํ๋ก๊ทธ๋๋ฐ์์ ํน์ ์กฐ๊ฑด์ด ๋ง์กฑ๋ ๋๊น์ง ์ผ๋ จ์ ์์ ์ ๋ฐ๋ณตํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. while ๋ฌธ์ ๋ค์๊ณผ ๊ฐ์ ๊ธฐ๋ณธ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๋๋ค.
while (์กฐ๊ฑด์) {
// ์กฐ๊ฑด์์ด ์ฐธ์ผ ๋ ์คํ๋ ์ฝ๋
}
์ฌ๊ธฐ์ ์กฐ๊ฑด์์ true ๋๋ false๋ก ํ๊ฐ๋ ์ ์๋ ์์ด๋ฉฐ, ์กฐ๊ฑด์์ด true์ผ ๊ฒฝ์ฐ ์ค๊ดํธ ์์ ์ฝ๋ ๋ธ๋ก์ด ๋ฐ๋ณตํด์ ์คํ๋๊ณ false๋ผ๋ฉด while ๋ฌธ์ ์ข ๋ฃํฉ๋๋ค.
2. while ๋ฌธ ์์ ๐คธโ๏ธ
๊ฐ๋จํ ์์ ๋ฅผ ํตํด while ๋ฌธ์ ์ดํดํด๋ณด๊ฒ ์ต๋๋ค.
โถ 1๋ถํฐ 10๊น์ง ์ซ์ ์ถ๋ ฅํ๊ธฐ
์ด ์ฝ๋๋ ๋ณ์ i๊ฐ 10 ์ดํ์ธ ๋์ 1๋ถํฐ 10๊น์ง์ ์ซ์๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
int i = 1;
while (i <= 10) {
System.out.println(i);
i++;
}
โถ ์ฌ์ฉ์๊ฐ ํน์ ํ ๊ฐ์ ์
๋ ฅํ ๋๊น์ง ๊ณ์ํด์ ์
๋ ฅ ๋ฐ๊ธฐ
while ๋ฌธ์ ์ฌ์ฉ์๋ก๋ถํฐ ์
๋ ฅ์ ๋ฐ์ ๋ ์ ์ฉํ๊ฒ ์ฌ์ฉ๋ ์ ์์ต๋๋ค. ๋ค์ ์์ ๋ ์ฌ์ฉ์๊ฐ ํน์ ํ ๊ฐ์ ์
๋ ฅํ ๋ ์ ์ฉํ๊ฒ ์ฌ์ฉ๋ ์ ์์ต๋๋ค.
import java.util.Scanner;
Scanner scanner = new Scanner(System.in);
int userInput;
System.out.println("์ํ๋ ์ซ์๋ฅผ ์
๋ ฅํ์ธ์:");
while (!scanner.hasNextInt()) {
System.out.println("์ซ์๋ฅผ ์
๋ ฅํด์ฃผ์ธ์!");
scanner.next(); // ์๋ชป๋ ์
๋ ฅ๊ฐ ๋ฌด์
}
userInput = scanner.nextInt();
System.out.println("์
๋ ฅํ ์ซ์๋ " + userInput + "์
๋๋ค.");
โถ ์ฌ์ฉ์๋ก๋ถํฐ ์
๋ ฅ๋ฐ์ ์์ ์ ์๊น์ง์ ํฉ์ ๊ณ์ฐํ์ฌ ์ถ๋ ฅํ๊ธฐ
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// ์ฌ์ฉ์๋ก๋ถํฐ ์์ ์ ์๋ฅผ ์
๋ ฅ ๋ฐ์
System.out.print("์์ ์ ์๋ฅผ ์
๋ ฅํ์ธ์: ");
int number = scanner.nextInt();
// ํฉ์ ์ ์ฅํ ๋ณ์ ์ด๊ธฐํ
int sum = 0;
// ๋ณ์ ์ด๊ธฐํ
int i = 1;
// while๋ฌธ์ ์ฌ์ฉํ์ฌ 1๋ถํฐ ์
๋ ฅ๋ฐ์ ์ซ์๊น์ง์ ํฉ ๊ณ์ฐ
while (i <= number) {
sum += i; // ํฉ ๊ณ์ฐ
i++; // ๋ค์ ์ซ์๋ก ์ด๋
}
// ๊ฒฐ๊ณผ ์ถ๋ ฅ
System.out.println("1๋ถํฐ " + number + "๊น์ง์ ํฉ: " + sum);
}
}
์ฌ์ฉ์๋ก๋ถํฐ ์์ ์ ์๋ฅผ ์ ๋ ฅ๋ฐ์ ํด๋น ์ซ์๊น์ง์ ํฉ์ ๊ณ์ฐํ์ฌ ์ถ๋ ฅํ๋ ๊ฐ๋จํ while ๋ฌธ ์์ ์ ๋๋ค. ์ ๋ ฅ๋ฐ์ ์ซ์๋ฅผ ๋ณ์ number์ ์ ์ฅํ๊ณ , ํฉ์ ๊ณ์ฐํ๊ธฐ ์ํ ๋ณ์ sum์ ์ด๊ธฐํํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋ณ์ i๋ฅผ 1๋ก ์ด๊ธฐํ ํ ํ, while ๋ฌธ์ ์ฌ์ฉํ์ฌ 1๋ถํฐ number๊น์ง์ ์ซ์๋ฅผ ๋ํด sum์ ์ ์ฅํฉ๋๋ค. while ๋ฌธ์ด ์ข ๋ฃ๋๋ฉด ์ต์ข ํฉ์ ์ถ๋ ฅํฉ๋๋ค.
โถ์ค์ฒฉ while ๋ฌธ ์ด์ฉํ ๊ตฌ๊ตฌ๋จ ์ถ๋ ฅํ๊ธฐ
์ค์ฒฉ while ๋ฌธ์ ํ while ๋ฌธ ์์ ๋ค๋ฅธ while ๋ฌธ์ ํฌํจํ๋ ๊ฒ์ ๋งํฉ๋๋ค. ์ด๋ ๋ณต์กํ ์ํฉ์์๋ ์ ์ฐํ๊ฒ ๋ฐ๋ณต ์์
์ ์ฒ๋ฆฌํ ์ ์๋๋ก ๋์์ค๋๋ค. ๋ค์์ ์ค์ฒฉ while ๋ฌธ์ ์ฌ์ฉํ์ฌ ๊ตฌ๊ตฌ๋จ์ ์ถ๋ ฅํ๋ ์์ ์
๋๋ค.
public class Main {
public static void main(String[] args) {
int i = 2;
while (i <= 9) {
int j = 1;
System.out.println(i + "๋จ");
while (j <= 9) {
System.out.println(i + " * " + j + " = " + (i * j));
j++;
}
System.out.println(); // ๊ฐ ๋จ์ ๊ตฌ๋ถํ๊ธฐ ์ํ ๋น ์ค ์ถ๋ ฅ
i++;
}
}
}
์ด ์์ ์์๋ ๋ฐ๊นฅ์ชฝ while ๋ฌธ์์๋ ๊ตฌ๊ตฌ๋จ์ ๋จ์ ๋ํ๋ด๋ ๋ณ์ i๋ฅผ 2๋ถํฐ 9๊น์ง ์ฆ๊ฐ์ํค๋ฉด์ ๋ฐ๋ณตํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ ์ชฝ while๋ฌธ์์๋ ๊ฐ ๋จ์์์ ์ซ์๋ฅผ ๋ํ๋ด๋ ๋ณ์ j๋ฅผ 1๋ถํฐ 9๊น์ง ์ฆ๊ฐ์ํค๋ฉด์ ๊ตฌ๊ตฌ๋จ์ ์ถ๋ ฅํฉ๋๋ค.
3. while ๋ฌธ ์ฌ์ฉ ์ ์ฃผ์ํ ์ ๐ซ
while ๋ฌธ์์ ์กฐ๊ฑด์์ด ์ฐธ์ด๋ฉด ๋ฌดํ ๋ฃจํ์ ๋น ์ง ์ ์์ต๋๋ค. ๋ฌดํ ๋ฐ๋ณต์ ์ํ์ ํ๋ก๊ทธ๋จ์ด ์๋์น ์๊ฒ ๋๋์ง ์๊ณ ๋ฌดํํ ์คํ๋๋ ์ํฉ์ ์๋ฏธํฉ๋๋ค. ์ด๋ ํ๋ก๊ทธ๋จ์ ๋น์ ์์ ์ผ๋ก ์ข
๋ฃ์ํค๊ณ , ์์คํ
์ ๋ฆฌ์์ค๋ฅผ ์๋นํ๋ ๋ฑ์ ์ฌ๊ฐํ ๋ฌธ์ ๋ฅผ ์ผ๊ธฐํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ๋ฌดํ ๋ฐ๋ณต์ ๋น ์ง์ง ์๋๋ก ์ฃผ์ํด์ผ ํฉ๋๋ค.
while ๋ฌธ ์ฌ์ฉ์ ์ฃผ์ํ ์ ๊ณผ ๋ฌดํ ๋ฐ๋ณต์ ํผํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- ์ ์ ํ ์ข ๋ฃ ์กฐ๊ฑด ์ค์ : while ๋ฌธ ๋ด๋ถ์์ ์ข ๋ฃ ์กฐ๊ฑด์ ๋ช ํํ๊ฒ ์ค์ ํฉ๋๋ค. ์ด ์กฐ๊ฑด์ด ์ถฉ์กฑ๋ ๋ ๋ฐ๋ณต์ด ๋ฉ์ถ๋๋ก ํด์ผ ํฉ๋๋ค.
- ๋ณ์ ์ ๋ฐ์ดํธ: ๋ฐ๋ณต๋ฌธ ๋ด๋ถ์์ ๋ณ์๋ฅผ ์ ๋ฐ์ดํธํ๋ ๊ฒ์ ์์ง ๋ง์์ผ ํฉ๋๋ค. ์ข ๋ฃ ์กฐ๊ฑด์ ์ํฅ์ ์ฃผ๋ ๋ณ์๋ฅผ ์ ์ ํ ์ ๋ฐ์ดํธํ์ฌ ๋ฐ๋ณต๋ฌธ์ด ์ข ๋ฃ๋ ์ ์๋๋ก ํด์ผ ํฉ๋๋ค.
- ์กฐ๊ฑด์ ๊ฒ์ฆ: while ๋ฌธ์ ์กฐ๊ฑด์์ ์ ํํ๊ฒ ๊ฒ์ฆํด์ผ ํฉ๋๋ค. ์กฐ๊ฑด์์ด ํญ์ ์ฐธ์ด ๋๊ฑฐ๋ ํญ์ ๊ฑฐ์ง์ด ๋๋ ๊ฒฝ์ฐ๋ฅผ ๋ฐฉ์งํด์ผ ํฉ๋๋ค.
- ๋ฌดํ ๋ฃจํ ๋ฐฉ์ง: ๋ฌดํ ๋ฐ๋ณต์ ๋น ์ง๋ ๊ฒ์ ๋ฐฉ์งํ๊ธฐ ์ํด ๋ณด์กฐ์ ์ธ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ๋ฌดํ ๋ฐ๋ณต์ ๋ฐฉ์งํ๊ธฐ ์ํ ์นด์ดํฐ๋ฅผ ์ฌ์ฉํ๊ฑฐ๋, ์ฌ์ฉ์๊ฐ ํน์ ํค๋ฅผ ์ ๋ ฅํ ๋ ๋ฐ๋ณต์ ์ข ๋ฃํ๋ ๋ฑ์ ๋ฐฉ๋ฒ์ ํ์ฉํ ์ ์์ต๋๋ค.
- ํ ์คํธ์ ๋๋ฒ๊น : ๋ฐ๋ณต๋ฌธ์ ์์ฑํ ํ์๋ ํญ์ ํ ์คํธ๋ฅผ ํตํด ๋ฌดํ ๋ฐ๋ณต์ ๋น ์ง๋์ง ํ์ธํด์ผ ํฉ๋๋ค. ๋ํ, ๋๋ฒ๊น ๋๊ตฌ๋ฅผ ์ฌ์ฉํ์ฌ ํ๋ก๊ทธ๋จ์ ์คํํ๋ฉด์ ๋ฐ๋ณต๋ฌธ์ด ์ ๋๋ก ๋์ํ๋์ง ํ์ธํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// ์ ์ ํ ์ข
๋ฃ ์กฐ๊ฑด ์ค์ : ์ฌ์ฉ์๊ฐ -1์ ์
๋ ฅํ ๋๊น์ง ๋ฐ๋ณต
int userInput;
while (true) {
System.out.print("์ ์๋ฅผ ์
๋ ฅํ์ธ์ (-1 ์
๋ ฅ ์ ์ข
๋ฃ): ");
userInput = scanner.nextInt();
// ์กฐ๊ฑด ๊ฒ์ฌ: ์
๋ ฅ๋ ๊ฐ์ด -1์ด๋ฉด ๋ฐ๋ณต ์ข
๋ฃ
if (userInput == -1) {
System.out.println("ํ๋ก๊ทธ๋จ์ ์ข
๋ฃํฉ๋๋ค.");
break; // ๋ฐ๋ณต ์ข
๋ฃ
}
// ๋ณ์ ์
๋ฐ์ดํธ: ์ฌ์ฉ์๊ฐ ์ฌ๋ฐ๋ฅธ ์
๋ ฅ์ ํ ๋๋ง๋ค ๋ฐ๋ณต ํ์ ์ฆ๊ฐ
// ์ฌ๊ธฐ์๋ ํน์ ๋ฒ์ ๋ด์ ๊ฐ์ธ์ง ํ์ธํ๋ ์์
์ด ์ด๋ฃจ์ด์ง
if (userInput >= 1 && userInput <= 100) {
System.out.println("์
๋ ฅํ ๊ฐ์ ์ฌ๋ฐ๋ฅธ ๋ฒ์ ๋ด์ ์์ต๋๋ค.");
} else {
System.out.println("์
๋ ฅํ ๊ฐ์ด ์ฌ๋ฐ๋ฅธ ๋ฒ์์ ์ํ์ง ์์ต๋๋ค.");
}
// ํ
์คํธ์ ๋๋ฒ๊น
: ์
๋ ฅ๊ฐ ํ์ธ
System.out.println("์
๋ ฅ๋ ๊ฐ: " + userInput);
}
scanner.close(); // ์ค์บ๋ ๋ซ๊ธฐ
}
}
์ฌ์ฉ์๋ก๋ถํฐ ์ ์๋ฅผ ์
๋ ฅ๋ฐ๊ณ , ์
๋ ฅ๋ ์ ์๊ฐ ํน์ ๋ฒ์ ๋ด ๊ฐ์ธ์ง ํ์ธํ๋ ํ๋ก๊ทธ๋จ์ ์์์
๋๋ค. ์ด ํ๋ก๊ทธ๋จ์์ ์ ์ ํ ์ข
๋ฃ ์กฐ๊ฑด ์ค์ , ๋ณ์ ์
๋ฐ์ดํธ, ์กฐ๊ฑด์ ๊ฒ์ฆ, ๋ฌดํ ๋ฃจํ ๋ฐฉ์ง, ํ
์คํธ์ ๋๋ฒ๊น
์ ๊ฐ ๋จ๊ณ๋ฅผ ์ด๋ฃจ๊ณ ์์ต๋๋ค.
4. do-while ๋ฌธ๐
do-while ๋ฌธ์ while ๋ฌธ๊ณผ ์ ์ฌํ์ง๋ง, ๋จผ์ ์ฝ๋ ๋ธ๋ก์ ์คํํ ๋ค์ ์กฐ๊ฑด์ ๊ฒ์ฌํ์ฌ ๋ฐ๋ณต ์ฌ๋ถ๋ฅผ ๊ฒฐ์ ํ๋ ์ฐจ์ด๊ฐ ์์ต๋๋ค. ์ด๋ ์ฝ๋ ๋ธ๋ก์ด ์ต์ํ ํ ๋ฒ์ ์คํ๋จ์ ๋ณด์ฅํฉ๋๋ค. do-while ๋ฌธ์ ๊ธฐ๋ณธ ๊ตฌ์กฐ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
do {
// ์คํํ ์ฝ๋ ๋ธ๋ก
} while (์กฐ๊ฑด์);
๋จผ์ do ๋ธ๋ก ์์ ์ฝ๋๊ฐ ์คํ๋๊ณ , ๊ทธ ํ์ while ๋ค์ ์กฐ๊ฑด์์ด ํ๊ฐ๋ฉ๋๋ค. ์กฐ๊ฑด์์ด true๋ฉด ๋ฃจํ๊ฐ ๊ณ์๋๊ณ , false๋ฉด ๋ฃจํ๊ฐ ์ข
๋ฃ๋ฉ๋๋ค.
do-while ๋ฌธ์ ๊ฐ๋จํ ์์ ๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค. ์ฌ์ฉ์๋ก๋ถํฐ ๊ฐ์ ์
๋ ฅ๋ฐ์์ 0์ด ์
๋ ฅ๋ ๋๊น์ง ํฉ๊ณ๋ฅผ ๊ณ์ฐํด ๋ณด๊ฒ ์ต๋๋ค.
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int sum = 0;
int number;
do {
System.out.print("์ ์๋ฅผ ์
๋ ฅํ์ธ์ (0 ์
๋ ฅ ์ ์ข
๋ฃ): ");
number = scanner.nextInt();
sum += number;
} while (number != 0);
System.out.println("์
๋ ฅ๋ ์ ์์ ํฉ: " + sum);
}
}
์ด ์์ ์์๋ ์ฌ์ฉ์๊ฐ 0์ ์
๋ ฅํ๊ธฐ ์ ๊น์ง ๊ณ์ํด์ ์ฌ์ฉ์๋ก๋ถํฐ ์ ์๋ฅผ ์
๋ ฅ๋ฐ๊ณ , ์
๋ ฅ๋ ์ ์๋ค์ ํฉ์ ๊ณ์ฐํ์ฌ ์ถ๋ ฅํฉ๋๋ค.
5. ํต์ฌ ๋ด์ฉ๐