반응형
/*
* 반복문
* - 특정 조건에 따라 지정된 범위의 문장들을 반복 실행하는 문
* - for문, while문으로 구분됨
*
* 1. for문
* - 가장 기본적인 반복문
* - 반복 횟수가 정해져 있는 경우에 주로 사용
* - 초기식, 조건식, 증감식의 위치가 정해져 있어, 초보자가 익히기 쉬움
* - 초기식 : 반복 횟수를 판별하기 위한 조건식에서 사용될
* 제어변수를 선언하거나 초기화하는 문장
* - 조건식 : 반복 여부를 결정하기 위한 조건식
* => if문과 마찬가지로 true 일 때 블록 내의 문장을 실행하고
* false 일 때 for문을 종료하고 빠져나감
* - 증감식 : 반복을 위한 조건식에 맞춰 초기식에서 초기화한 제어변수를
* 증가 또는 감소시키는 문장
*
* < 기본 문법 >
* for(초기식; 조건식; 증감식) {
* // 조건식 결과가 true 일 때 반복 실행할 문장들...
* }
*/
public class Ex {
public static void main(String[] args) {
// => 제어변수 i는 for문에서 선언된 변수이므로
// for문의 블록{}이 끝나면 사용 불가능한 변수(존재하지 않음)
// => 따라서, 제어변수 i를 for문 종료 후에도 사용하려면
// 최소한 for문보다 윗쪽(앞쪽)에서 선언해야한다!
int i; // for문보다 위에 위치하므로 for문 종료후에도 유지됨
for(i = 1; i <= 10; i++) {
// 조건식 결과가 true 일 때 실행할 문장
System.out.println(i + " : Hello, World!");
}
// for문 종료 후 i값 확인 가능
System.out.println("for문 종료 후 i값 = " + i);
/*
* 위의 for문에 대한 디버깅(Debugging)
* -------------------------------------------------------------------
* 초기식(i) 조건식(i <= 10) 실행결과(i + "Hello, World!") 증감식(i++)
* -------------------------------------------------------------------
* 1 true 1 : Hello, World! 출력 1 -> 2
* 2 true 2 : Hello, World! 출력 2 -> 3
* 3 true 3 : Hello, World! 출력 3 -> 4
* 4 true 4 : Hello, World! 출력 4 -> 5
* 5 true 5 : Hello, World! 출력 5 -> 6
* 6 true 6 : Hello, World! 출력 6 -> 7
* 7 true 7 : Hello, World! 출력 7 -> 8
* 8 true 8 : Hello, World! 출력 8 -> 9
* 9 true 9 : Hello, World! 출력 9 -> 10
* 10 true 10 : Hello, World! 출력 10 -> 11
* 11 false for문을 빠져나감
*/
System.out.println("======================");
// 제어변수 i가 1 ~ 10까지 1씩 증가하면서 i값 출력
// => 1 2 3 4 5 6 7 8 9 10
for(i = 1; i <= 10; i++) {
System.out.print(i + " ");
}
System.out.println(); // 줄바꿈 역할
System.out.println("----------------------");
// 제어변수 i가 1 ~ 10까지 2씩 증가하면서 i값 출력(홀수 출력)
// => 1 3 5 7 9
for(i = 1; i <= 10; i += 2) {
System.out.print(i + " ");
}
System.out.println(); // 줄바꿈 역할
System.out.println("----------------------");
// 제어변수 i가 2 ~ 10까지 2씩 증가하면서 i값 출력(짝수 출력)
// => 2 4 6 8 10
for(i = 2; i <= 10; i += 2) {
System.out.print(i + " ");
}
System.out.println(); // 줄바꿈 역할
System.out.println("----------------------");
// 제어변수 i가 10 ~ 1까지 1씩 감소하면서 i값 출력(역순으로 출력)
// => 10 9 8 7 6 5 4 3 2 1
for(i = 10; i >= 1; i--) {
System.out.print(i + " ");
}
}
}public class Ex2 {
public static void main(String[] args) {
/*
* 반복문을 사용한 연산의 누적(ex. 합계 계산 등)
* 1. 연산을 누적할 누적 변수 선언 및 초기화(반복문보다 먼저 수행)
* 2. 반복문을 사용하여 특정 횟수 반복
* 3. 반복문 내에서 특정 연산(데이터)을 누적 변수에 누적
* 4. 반복문 종료 후 누적 변수 값 사용(출력)
*/
// 1 ~ 10 까지의 1씩 증가하는 정수의 합(total)을 계산 후 출력
int total = 0; // 누적변수 선언 및 초기화
for(int i = 1; i <= 10; i++) { // 1 ~ 10까지 1씩 증가하면서 반복
// 누적변수에 현재 값 i를 누적
total += i; // total = total + i;
System.out.println("i = " + i + ", total = " + total);
}
System.out.println("1 ~ 10 까지 정수 합 = " + total);
System.out.println("================================");
}
}public class Test_p {
public static void main(String[] args) {
/*
* 정수형 변수 visitCount가 0일 때,
* "처음 오셨군요. 방문해 주셔서 감사합니다."를 출력
*
* visitCount와 상관없이 "방문횟수는 XX번 입니다." 출력하는 코드
*
* 출력결과
* visitCount = 0
*
* 처음 오셨군요. 방문해 주셔서 감사힙니다.
* 방문횟수는 0번 입니다.
*
* visitCount = 5
*
* 방문횟수는 5번 입니다.
*
*/
int visitCount = 1;
if(visitCount == 0) {
// 조건식 판별 결과가 true 일 때
System.out.println("처음 오셨군요. 방문해 주셔서 감사합니다.");
}
System.out.println("방문횟수는 " + visitCount + "번 입니다.");
System.out.println("===========================");
/*
* 정수형 num 변수를 선언
* num의 값이 3의 배수 이거나 5의 배수 이면
* "3의 배수이거나 5의 배수 입니다"
* 아니면, "3의 배수이거나 5의 배수가 아닙니다"
*
*/
/*
* AND : 두 비교 연산의 관계를 ~이고, ~이면서, 그리고 로 정의
* OR : ~이거나, 또는 으로 정의
*
*/
int num = 4;
if(num % 3 ==0 || num % 5 == 0) {
System.out.println("3의 배수이거나 5의 배수 입니다.");
} else {
System.out.println("3의 배수이거나 5의 배수가 아닙니다");
}
/*
* 1 < num && 100 > num
*
* 1 < num < 100
*/
System.out.println("========================");
/*
* 영문자 인지 확인하는 코드
* if문 하나만 사용해서
* 영문자인지 아닌지 판별
* 영문자 a ~ z A ~ Z
*
*/
char ch ='^';
if(ch >= 'A' && ch <= 'Z' || ch >='a' && ch <= 'z' ) {
// ch >= 'A' && ch <='z'
// 영문자 일 때
System.out.println("영문자입니다");
}else {
// 영문자가 아닐 때
System.out.println("영문자가 아닙니다");
}
}
}public class Test {
public static void main(String[] args) {
/*
* for문을 사용하여 특정 단에 해당하는 구구단 출력
* < 2단 >
* 2 * 1 = 2
* 2 * 2 = 4
* 2 * 3 = 6
* 2 * 4 = 8
* 2 * 5 = 10
* 2 * 6 = 12
* 2 * 7 = 14
* 2 * 8 = 16
* 2 * 9 = 18
*/
// 단(dan)과 곱해지는 수(i)를 저장할 변수를 선언하고 값을 저장하면
// 단이 바뀌더라도 대응이 가능하다!
// int dan = 5;
// int i = 1;
// System.out.println(" < " + dan + "단 >");
//// System.out.println("2 * 1 = 2");
// System.out.println(dan + " * " + i + " = " + (dan * i));
// i++;
// System.out.println(dan + " * " + i + " = " + (dan * i));
// i++;
// System.out.println(dan + " * " + i + " = " + (dan * i));
// i++;
// System.out.println(dan + " * " + i + " = " + (dan * i));
// i++;
// System.out.println(dan + " * " + i + " = " + (dan * i));
// i++;
// System.out.println(dan + " * " + i + " = " + (dan * i));
// i++;
// System.out.println(dan + " * " + i + " = " + (dan * i));
// i++;
// System.out.println(dan + " * " + i + " = " + (dan * i));
// i++;
// System.out.println(dan + " * " + i + " = " + (dan * i));
// i++;
// System.out.printf(" < %d단 >\n", dan);
// System.out.printf("%d * %d = %d\n", dan, i, dan * i);
System.out.println("====================================");
// for문을 사용하여 제어변수 i가 1 ~ 9 까지 1씩 반복하면서
// 구구단의 단(dan) 과 결합하여 구구단을 출력
int dan = 2;
System.out.println(" < " + dan + "단 >");
// 반복문을 사용하여 구구단 출력
for(int i = 1; i <= 9; i++) {
System.out.printf("%d * %d = %d\n", dan, i, dan * i);
}
}
}public class Test2 {
public static void main(String[] args) {
// 1 ~ 10 까지 1씩 증가하면서, 정수 중 짝수의 합만 계산
int total = 0; // 누적변수 선언 및 초기화
for(int i = 1; i <= 10; i++) { // 1 ~ 10까지 1씩 증가하면서 반복
// 짝수일 경우에만 누적변수에 현재 값 i를 누적
if(i % 2 == 0) { // 짝수 판별
// 짝수일 때 누적 수행
total += i;
System.out.println("i = " + i + ", total = " + total);
} else { // 짝수가 아닐 때(= 홀수일 때)
System.out.println(i + " : 홀수이므로 누적 X");
}
}
System.out.println("1 ~ 10 까지 정수 중 짝수의 합 = " + total);
System.out.println("==========================================");
// 1 ~ 10 까지 정수 중 홀수의 합 계산 후 출력
total = 0; // 누적변수 선언 및 초기화
for(int i = 1; i <= 10; i++) { // 1 ~ 10까지 1씩 증가하면서 반복
// 홀수일 경우에만 누적변수에 현재 값 i를 누적
if(i % 2 == 1) { // 홀수 판별
// 홀수일 때 누적 수행
total += i;
System.out.println("i = " + i + ", total = " + total);
} else { // 홀수가 아닐 때(= 짝수일 때)
System.out.println(i + " : 짝수이므로 누적 X");
}
}
System.out.println("1 ~ 10 까지 정수 중 홀수의 합 = " + total);
System.out.println("==========================================");
// 1 ~ 10까지 1씩 증가하면서 홀수, 짝수의 합을 각각 누적 후 출력
int oddTotal = 0; // 홀수의 합
int evenTotal = 0; // 짝수의 합
for(int i = 1; i <= 10; i++) {
if(i % 2 == 1) { // 홀수일 때
// 홀수의 합을 저장하는 변수 oddTotal 에 i값을 누적
oddTotal += i;
} else { // 홀수가 아닐 때(짝수일 때)
// 짝수의 합을 저장하는 변수 evenTotal 에 i값을 누적
evenTotal += i;
}
}
System.out.println("1 ~ 10 까지 정수 중 짝수의 합 = " + evenTotal);
System.out.println("1 ~ 10 까지 정수 중 홀수의 합 = " + oddTotal);
}
}public class Test3 {
public static void main(String[] args) {
// 정수 1 ~ 100 까지의 합(5050)을 누적변수 total 에 누적 후 출력
int total = 0; // 누적변수
for(int i = 1; i <= 100; i++) {
total += i; // i값 누적
}
System.out.println("1 ~ 100 까지 정수의 합 : " + total);
}
}public class Ex {
public static void main(String[] args) {
/*
* 중첩 for문
* - for문 내부에 또 다른 for문을 기술하는 것
* - 바깥쪽 for문과 안쪽 for문으로 구분
* => 바깥쪽 for문이 한 바퀴 돌 때, 안쪽 for문은 여러 바퀴를 돈다.
* => 즉, 안쪽 for문의 반복 횟수가 바깥쪽 for문 반복횟수보다 많다.
* = 안쪽 for문 반복 횟수 = 안쪽 for문 횟수 * 바깥쪽 for문 횟수
* ex) 시계의 분침이 바깥쪽 for문으로 0 ~ 59까지 60번을 반복할 때
* 분침 1바퀴 당 초침이 안쪽 for문으로 0 ~ 59까지 60번을 반복
* = 1시간(60분) 당 초침의 반복 횟수 = 분침횟수(60) * 초침횟수(60)
*
* < 기본 문법 >
* for(초기식1; 조건식1; 증감식1) { // 바깥쪽 for문
*
* 문장1; // 바깥쪽 for문의 조건식1 이 true 일 때 실행되는 문장
*
* for(초기식2; 조건식2; 증감식2) { // 안쪽 for문
*
* 문장2;
* // 반복 횟수 = 안쪽 for문 반복횟수 * 바깥쪽 for문 반복횟수
*
* }
*
* 문장3; // 안쪽 for문 반복이 종료된 후 실행되는 문장
*
* }
*/
// 바깥쪽 for문 : i값이 1 ~ 3까지 1씩 증가하면서 반복
for(int i = 1; i <= 3; i++) { // 바깥쪽 for문
System.out.println("i = " + i); // 3회(i 가 1 ~ 3까지)
for(int j = 1; j <= 2; j++) { // 안쪽 for문
System.out.println("----------> j = " + j);
// 반복횟수 = j횟수(2) * i횟수(3) = 6회
}
// 안쪽 for문 반복이 종료된 후 실행되는 문장
System.out.println("------- 안쪽 for문 반복 종료");
}
// 바깥쪽 for문 반복이 종료된 후 실행되는 문장
System.out.println("바깥쪽 for문 반복 종료");
}
}public class Ex2 {
public static void main(String[] args) {
/*
* while문
* - for문과 마찬가지로 특정 조건식의 판별 결과가 true 동안 반복 수행
* - for문과 달리 조건식 위치만 정해져 있고,
* 초기식과 증감식의 위치는 유동적으로 변함(생략도 가능)
* (개발자가 정해야한다)
* - for문은 주로 반복 횟수가 정해져 있는 경우 사용하며,
* while문은 주로 반복 횟수가 정해져 있지 않은 경우 사용
* - for문과 while문은 100% 상호 변환이 가능함
*
* < 기본 문법 >
* [초기식;] // while문 보다 위에 위치해야함(생략도 가능)
*
* while(조건식) {
* [증감식;]
* // 조건식 결과가 true 일 때 반복 실행할 문장
* [증감식;] // 증감식의 위치는 반복할 문장보다 위에 올 수도 있다!
* }
*
*/
// for문을 사용하여 "Hello, World!" 문자열 10번 반복 출력하기
for(int i = 1; i <= 10; i++) {
System.out.println(i + " : Hello, World!");
}
System.out.println("-------------------------");
// 위의 for문을 while문으로 변환
int i = 1; // 초기식
while(i <= 10) { // 조건식
System.out.println(i + " : Hello, World!"); // 반복 실행문
i++; // 증감식
}
// 제어변수 i가 while문보다 윗쪽에서 선언되었으므로
// while문 반복 종료 후에도 변수 i값에 접근 가능함
System.out.println("while문 종료 후 i값 = " + i);
System.out.println("-------------------------");
// 제어변수 i가 1 ~ 10까지 1씩 증가하면서 i값 출력
// => 1 2 3 4 5 6 7 8 9 10
i = 1; // 초기식
while(i <= 10) { // 조건식
System.out.print(i + " ");
i++; // 증감식
}
System.out.println(); // 줄바꿈 역할
System.out.println("----------------------");
// 제어변수 i가 1 ~ 10까지 2씩 증가하면서 i값 출력(홀수 출력)
// => 1 3 5 7 9
i = 1; // 초기식
while(i <= 10) { // 조건식
System.out.print(i + " ");
i += 2; // 증감식
}
System.out.println(); // 줄바꿈 역할
System.out.println("----------------------");
// 제어변수 i가 2 ~ 10까지 2씩 증가하면서 i값 출력(짝수 출력)
// => 2 4 6 8 10
i = 2; // 초기식
while(i <= 10) { // 조건식
System.out.print(i + " ");
i += 2; // 증감식
}
System.out.println(); // 줄바꿈 역할
System.out.println("----------------------");
// 제어변수 i가 10 ~ 1까지 1씩 감소하면서 i값 출력(역순으로 출력)
// => 10 9 8 7 6 5 4 3 2 1
i = 10; // 초기식
while(i >= 1) { // 조건식
System.out.print(i + " ");
i--; // 증감식
}
System.out.println(); // 줄바꿈 역할
System.out.println("========================");
// 증감식 위치에 따라 초기식, 조건식이 바뀔 수 있다!
i = 0; // 초기식
while(i < 10) { // 조건식
i++; // 증감식
System.out.print(i + " ");
}
System.out.println(); // 줄바꿈 역할
System.out.println("while 문 종료 후의 i값 = " + i);
}
}public class Ex3 {
public static void main(String[] args) {
/*
* do~while 문
* - while 문은 조건을 먼저 검사하고 반복 여부를 결정하지만
* do~while 문은 일단 반복문을 실행하고 난 뒤 조건을 검사하여
* 다음 반복 여부를 결정함
* - while 문은 조건식에 따라 반복문이 단 한 번도 실행되지 않을 수도 있지만
* do~while 문은 최소 한 번의 실행은 보장됨
*
* < 기본 문법 >
* do {
* // 반복 실행할 문장
* } while(조건식);
* => 주의! while문 뒤에 반드시 세미콜론(;) 필수!
*/
int i = 11; // 초기식
while(i <= 10) { // 조건식
// 제어변수 i 초기값이 10보다 클 경우
// 조건식 판별 결과가 false 이므로 반복문은 실행되지 못함!
System.out.println("i = " + i); // 반복실행할 문장
i++; // 증감식
}
System.out.println("while 문 종료 후 i값 = " + i);
System.out.println("======================");
i = 11;
do { // 조건식이 없으므로 블록문이 무조건 한 번 실행됨!
// 제어변수 i 초기값이 10보다 크더라도
// 조건식 판별을 마지막에 수행하므로 일단 실행문이 한 번 실행되고
// 이후 조건식 판별 결과가 false 이므로 do~while 문을 빠져나감
System.out.println("i = " + i);
i++;
} while(i <= 10); // 블록문 실행 후 조건식을 판별하여 다음 반복 여부 결정
System.out.println("do~while 문 종료 후 i값 = " + i);
}
}public class Test {
public static void main(String[] args) {
// 바깥쪽 for문 i값이 1 ~ 10까지 반복할 동안
// 안쪽 for문 j값을 1 ~ 5까지 반복하면서 i 와 j 값 출력
for(int i = 1; i <= 10; i++) {
System.out.println("i = " + i);
for(int j = 1; j <= 5; j++) {
System.out.println("-------> j = " + j);
// System.out.println("i = " + i + ", j = " + j);
}
}
System.out.println("===================");
/*
* 타이머(XX분 XX초)
* - 시(hour) : 0 ~ 23시
* - 분(min) : 0 ~ 59분
* - 초(sec) : 0 ~ 59초
*
* < 출력 예시 >
* 0분 0초
* 0분 1초
* 0분 2초
* ...생략...
* 0분 59초
* 1분 0초
* 1분 1초
* ...생략...
* 59분 58초
* 59분 59초
*
*/
// 바깥쪽 for문으로 분(min, 0 ~ 59) 반복
for(int min = 0; min <= 59; min++) {
// System.out.println(min + "분");
// 안쪽 for문으로 초(sec, 0 ~ 59) 반복
for(int sec = 0; sec <= 59; sec++) {
System.out.println(min + "분 " + sec + "초");
}
}
System.out.println("===============================");
/*
* 중첩 for문을 활용한 구구단 전체 출력(2단 ~ 9단)
*
* < 2단 >
* 2 * 1 = 2
* 2 * 2 = 4
* 2 * 3 = 6
* 2 * 4 = 8
* ...생략...
*
* < 3단 >
* 3 * 1 = 3
* ...생략...
*
* < 9단 >
* 9 * 1 = 9
* 9 * 2 = 18
* ...생략...
* 9 * 9 = 81
*
* => 단(dan)이 2 ~ 9 까지 1씩 증가(바깥쪽 for문)
* 이 때, 각 단마다 i값이 1 ~ 9 까지 1씩 증가(안쪽 for문)
*/
// 특정 단의 구구단을 출력
// int dan = 9;
// System.out.println(" < " + dan + "단 >");
//
// for(int i = 1; i <= 9; i++) {
// System.out.println(dan + " * " + i + " = " + (dan * i));
//// System.out.printf("%d * %d = %d\n", dan, i, dan * i);
// }
// 중첩 for문을 사용하여 2단 ~ 9단까지 출력
// => 바깥쪽 for문을 단으로 사용
for(int dan = 2; dan <= 9; dan++) { // 2단 ~ 9단 반복
System.out.println(" < " + dan + "단 >");
for(int i = 1; i <= 9; i++) { // 1 ~ 9 반복
System.out.printf("%d * %d = %d\n", dan, i, dan * i);
}
System.out.println();
}
System.out.println("================================");
/*
* 주사위 2개를 굴려서 주사위 눈의 합이 6일 때 두 주사위 값을 출력
* ex) 주사위1 주사위2 합계
* 1 + 5 = 6
* 2 + 4 = 6
* 3 + 3 = 6
* 4 + 2 = 6
* 5 + 1 = 6
*
* 주사위 눈 : 1 ~ 6
* 주사위(dice1, dice2) 변수 값을 1 ~ 6 까지 1씩 증가하면서 반복하면서
* 주사위 눈의 합계가 6인지 판별하여 6일 때 주사위 눈의 값 출력
*/
for(int dice1 = 1; dice1 <= 6; dice1++) {
for(int dice2 = 1; dice2 <= 6; dice2++) {
if(dice1 + dice2 == 6) { // 주사위 눈의 합이 6인지 판별
// 두 주사위 눈의 합이 6일 때만 출력문 실행
System.out.println(dice1 + " + " + dice2 + " = " + (dice1 + dice2));
}
}
}
System.out.println("============================");
// 방정식 4x + 5y = 60 의 해를 구해서 출력하기
// 단, x 와 y는 0 <= x, y <= 10
for(int x = 0; x <= 10; x++) {
for(int y = 0; y <= 10; y++) {
// 4x + 5y 가 60일 때 x, y 값을 출력
int sum = 4 * x + 5 * y; // 방정식 계산
if(sum == 60) { // if(4 * x + 5 * y == 60) 동일
// System.out.println("x = " + x + ", y = " + y);
System.out.printf("x = %d, y = %d 일 때 4x + 5y = %d\n", x, y, sum);
}
}
}
}
}public class Test2 {
public static void main(String[] args) {
// while 문을 사용하여 구구단 2단 출력
int dan = 2;
System.out.println(" < " + dan + "단 >");
int i = 1;
while(i <= 9) {
System.out.println(dan + " * " + i + " = " + (dan * i));
i++;
}
System.out.println("=========================");
// while 문을 사용하여 정수 1 ~ 10 까지의 합(total)을 계산 후 출력
int total = 0;
int num = 1; // 초기식
while(num <= 10) { // 조건식
total += num;
num++; // 증감식
}
System.out.println("1 ~ 10까지 정수의 합 = " + total);
}
}public class Ex {
public static void main(String[] args) {
/*
* 중첩 while문
* - 중첩 for문과 마찬가지로 while 문 내부에 또 다른 while 문을 기술
*
* < 기본 문법 >
* 초기식1;
*
* while(조건식1) {
* 초기식2;
*
* while(조건식2) {
* // 반복할 문장...
* 증감식2;
* }
*
* 증감식1;
* }
*/
// for문을 사용하여 i값이 1 ~ 5까지 반복할 동안
// j값이 1 ~ 3까지 반복하는 중첩 for문
// for(int i = 1; i <= 5; i++) {
//
// for(int j = 1; j <= 3; j++) {
// System.out.println("i = " + i + ", j = " + j);
// }
//
// }
int i = 1; // 초기식1
while(i <= 5) { // 조건식1
int j = 1; // 초기식2
while(j <= 3) { // 조건식2
System.out.println("i = " + i + ", j = " + j);
j++; // 증감식2
}
i++; // 증감식1
}
}
}public class Ex2 {
public static void main(String[] args) {
int startNum = 1;
int endNum = 10;
for(int i = startNum; i <= endNum; i++) {
System.out.println(i);
}
System.out.println("===================");
/*
* *****
* *****
* *****
* *****
* *****
*/
for(int i = 1; i <= 5; i++) { // 출력할 라인 수
for(int j = 1; j <= 5; j++) { // * 기호의 갯수
System.out.print("*");
}
System.out.println();
}
System.out.println("====================");
/*
* * 1번 라인(i = 1) = 별 1개(j = 1 ~ 1)
* ** 2번 라인(i = 2) = 별 2개(j = 1 ~ 2)
* *** 3번 라인(i = 3) = 별 3개(j = 1 ~ 3)
* **** 4번 라인(i = 4) = 별 4개(j = 1 ~ 4)
* ***** 5번 라인(i = 5) = 별 5개(j = 1 ~ 5)
*/
for(int i = 1; i <= 5; i++) { // 출력할 라인 수
for(int j = 1; j <= i; j++) { // * 기호의 갯수
System.out.print("*");
}
System.out.println();
}
System.out.println("====================");
/*
* ***** 5번 라인(i = 5) = 별 5개(j = 1 ~ 5)
* **** 4번 라인(i = 4) = 별 4개(j = 1 ~ 4)
* *** 3번 라인(i = 3) = 별 3개(j = 1 ~ 3)
* ** 2번 라인(i = 2) = 별 2개(j = 1 ~ 2)
* * 1번 라인(i = 1) = 별 1개(j = 1 ~ 1)
*/
for(int i = 5; i >= 1; i--) { // 출력할 라인 수
for(int j = 1; j <= i; j++) { // * 기호의 갯수
System.out.print("*");
}
System.out.println();
}
System.out.println("-----------");
/*
* ***** 1번 라인(i = 1) = 별 5개(j = 1 ~ 5)(j = 5 ~ 1)
* **** 2번 라인(i = 2) = 별 4개(j = 1 ~ 4)(j = 5 ~ 2)
* *** 3번 라인(i = 3) = 별 3개(j = 1 ~ 3)(j = 5 ~ 3)
* ** 4번 라인(i = 4) = 별 2개(j = 1 ~ 2)(j = 5 ~ 4)
* * 5번 라인(i = 5) = 별 1개(j = 1 ~ 1)(j = 5 ~ 5)
*/
for(int i = 1; i <= 5; i++) { // 출력할 라인 수
// for(int j = 1; j <= (6 - i); j++) { // * 기호의 갯수
for(int j = 5; j >= i; j--) { // * 기호의 갯수
System.out.print("*");
}
System.out.println();
}
}
}public class Ex3 {
public static void main(String[] args) {
/*
* break 문과 continue 문
* - 반복문 내에서 특정 조건식과 결합하여
* 반복문의 실행 흐름을 제어하는 용도로 사용
*
* 1. break 문
* - 반복문 내에서 조건식에 따라 반복문을 종료하는 용도로 사용
* 주로 if문과 조합하여 반복문을 빠져나갈 조건을 설정
*
* < 기본 문법 >
* for(초기식; 조건식; 증감식) 또는 while(조건식) {
* if(조건) {
* break; // 현재 소속된 반복문의 블록문을 빠져나감(종료)
* }
* }
*
*/
int i;
for(i = 1; i <= 10; i++) {
System.out.println(i);
// i값이 5일 때 for문을 빠져나감
if(i == 5) {
System.out.println("i = 5 이므로 for문을 종료");
break;
}
}
System.out.println("for문 종료 후 i값 = " + i);
System.out.println("==========================");
i = 1;
while(i <= 10) {
System.out.println(i);
// i값이 5일 때 while문을 빠져나감
if(i == 5) {
System.out.println("i = 5 이므로 while문을 종료");
break;
}
i++;
}
// System.out.println("while문 종료 후 i값 = " + i);
System.out.println("=================================");
/*
* 2. continue 문
* - 반복문 내에서 조건식에 따라 반복문의 다음 문장 실행을 생략하고
* 다음 반복을 진행하는 용도로 사용
*
* < 기본 문법 >
* for(초기식; 조건식; 증감식) 또는 while(조건식) {
* if(조건) {
* continue;
* // 현재 반복문의 continue 문 아래쪽 문장 실행을 생략하고
* // 다음 반복 실행을 위해 for문의 증감식 또는
* // while 문의 조건식으로 이동
* }
*
* 문장x; // continue 문에 의해 실행이 생략되는 문장
* }
*/
for(i = 1; i <= 10; i++) {
// i값이 5일 때 출력문 실행을 생략하고 다음 반복 진행
if(i == 5) {
System.out.println("i = 5 이므로 출력문 실행을 생략");
continue;
}
System.out.println(i); // i값이 5일 때 출력문이 실행되지 못함
}
System.out.println("for문 종료 후 i값 = " + i);
}
}public class Ex4 {
public static void main(String[] args) {
// 중첩 for문을 사용하여 구구단 2단 ~ 9단 출력
// => 단, 구구단의 단이 5단일 때 반복문 종료
// for(int dan = 2; dan <= 9; dan++) { // 2단 ~ 9단 반복
// System.out.println(" < " + dan + "단 >");
//
//// // 현재 단이 5단일 때 반복문 종료
//// if(dan == 5) {
//// break;
//// }
//
// for(int i = 1; i <= 9; i++) { // 1 ~ 9 반복
// if(dan == 5) {
// // 현재 단이 5단일 때 반복문 종료하는 것이 아니라
// // 안쪽 for문을 빠져나가고 바깥쪽 for문의 다음 반복 진행
// break;
// }
//
// System.out.printf("%d * %d = %d\n", dan, i, dan * i);
// } // 안쪽 for문 끝
//
// System.out.println();
//
// } // 바깥쪽 for문 끝
/*
* Label 기능
* - 반복문의 앞에 위치하여 break 또는 continue 의 동작 지점을 지정
* - break 문 또는 continue 문 뒤에 해당 레이블의 이름을 지정할 경우
* Label 위치의 다음 반복문에 break 또는 continue 문이 적용됨
* - 주로, 중첩 반복문에서 반복문을 한꺼번에 빠져나가기 위해 사용
* - 반복문 앞 또는 위에 주로 대문자로 된 문자를 작성하고 콜론을 붙임
*
* < 기본 문법 >
* 레이블명:
* 바깥쪽반복문() {
*
* 안쪽반복문() {
* if(조건식) {
* break 레이블명; // 또는 continue 레이블명;
* }
* }
*
* }
*/
EXIT_FOR: // 레이블
for(int dan = 2; dan <= 9; dan++) { // 2단 ~ 9단 반복
System.out.println(" < " + dan + "단 >");
for(int i = 1; i <= 9; i++) { // 1 ~ 9 반복
if(dan == 5) {
// break EXIT_FOR; // EXIT_FOR 레이블을 찾아 해당 반복문을 종료
continue EXIT_FOR; // EXIT_FOR 레이블을 찾아 다음 반복을 진행
}
System.out.printf("%d * %d = %d\n", dan, i, dan * i);
} // 안쪽 for문 끝
System.out.println();
} // 바깥쪽 for문 끝
}
}public class Test {
public static void main(String[] args) {
/*
* 중첩 while문 활용
*
* 타이머(XX분 XX초)
* - 시(hour) : 0 ~ 23시
* - 분(min) : 0 ~ 59분
* - 초(sec) : 0 ~ 59초
*
* < 출력 예시 > System.out.println(min + "분 " + sec + "초");
* 0분 0초
* 0분 1초
* 0분 2초
* ...생략...
* 0분 59초
* 1분 0초
* 1분 1초
* ...생략...
* 59분 58초
* 59분 59초
*
*/
int min = 0;
while(min <= 59) {
// System.out.println(min + "분");
int sec = 0;
while(sec <= 59) {
System.out.println(min + "분 " + sec + "초");
sec++;
}
min++;
}
System.out.println("===============================");
/*
* 중첩 while문을 활용한 구구단 전체 출력(2단 ~ 9단)
* < 2단 >
* 2 * 1 = 2
* 2 * 2 = 4
* 2 * 3 = 6
* ...생략...
*
* < 3단 >
* 3 * 1 = 3
* ...생략...
*
* < 9단 >
* 9 * 1 = 9
* ...생략...
* 9 * 9 = 81
*
* => 단(dan)이 2 ~ 9 까지 1씩 증가(바깥쪽 for문)
* 이 때, 각 단마다 i값이 1 ~ 9 까지 1씩 증가(안쪽 for문)
*/
int dan = 2;
while(dan <= 9) {
System.out.println(" < " + dan + "단 >");
int i = 1;
while(i <= 9) {
System.out.println(dan + " * " + i + " = " + (dan * i));
i++;
}
System.out.println();
dan++;
}
}
}public class Test3 {
public static void main(String[] args) {
/*
* 1 ~ 100 까지 정수의 합을 계산(total 변수에 저장)
* => 단, 합계가 1000 보다 클 경우 반복문을 종료하고 빠져나간 뒤
* 1000 보다 커지는 시점의 정수(x)를 출력
*/
int total = 0;
int x;
for(x = 1; x <= 100; x++) {
total += x;
if(total > 1000) {
break; // 합계(total)가 1000 보다 클 때 for문 종료
}
}
System.out.println("1 ~ " + x + "까지 정수의 합 = " + total);
System.out.println("합계가 1000보다 클 때 x = " + x);
System.out.println("========================================");
/*
* 1 + (-2) + 3 + (-4) + 5 + (-6) + ...생략... 형식으로 계속 더할 때
* 총합이 100 이상이 되는 x값 출력(break 사용)
* <힌트> 정수가 짝수일 때는 음수 형태로 변환하여 합계 누적
*/
x = 1;
total = 0;
// while(true) {
// if(x % 2 == 0) { // 짝수일 때
// System.out.println(-x);
// total += -x; // 음수값으로 변환하여 누적
// } else { // 홀수일 때
// System.out.println(x);
// total += x; // 양수값 그대로 누적
// }
//
// if(total >= 100) {
// break;
// }
//
// x++;
// }
x = 0;
total = 0;
while(total < 100) { // 합계가 100보다 작을 동안 반복(= 100 이상이면 종료)
x++;
if(x % 2 == 0) { // 짝수일 때
System.out.println(-x);
total += -x; // 음수값으로 변환하여 누적
} else { // 홀수일 때
System.out.println(x);
total += x; // 양수값 그대로 누적
}
}
System.out.println();
System.out.println("x = " + x);
System.out.println("total = " + total);
}
}
반응형
'JAVA' 카테고리의 다른 글
| [Java] 배열 테스트 문제 (0) | 2021.10.28 |
|---|---|
| [Java] 배열(Array) (0) | 2021.10.26 |
| [Java] 다중 else if 문, 중첩 if문, switch문 (0) | 2021.10.26 |
| [Java] 조건문(if문, else if문) (0) | 2021.10.26 |
| [Java] 연산자 (0) | 2021.10.25 |