줄맞춤 잘하기..
반복문
for 값이 정해져있는 반복문
while문은 무한으로
반복문은 뭐를 반복시킬지가 젤 어려움,, 반복의 조건은 어디까지일까 시작은 어디서부터 값이 변화하는건 몇개씩일까.?
for문
for(초기식;-> 조건식; -> 수행될문장; -> 증감식) -> 조건식 -> 수행될문장-> 증감식 으로 반복
조건식이 false가 될때까지
for(int i =1; i <= 10; i++) {
System.out.println(i + "출력" ) ;
}
1부터 10까지 1씩 증가시켜서
1출력
2출력
3출력 ... 10출력까지 출력하세요
1회전 : i =1
i <= 10 true
1출력
i++ -> 1( 현재는 다음번에는 2)
2회전 : 2 <= 10 true
2출력
i++ -> 2(3)
11
초기식은 0부터 시작하는게 맞는지 1부터 시작하는게 맞는지 10부터 시작하는게 맞는지 생각
어떤초기식을 쓰냐 따라 조건식과 증감식이 달라짐
for문 옆에; 붙이지 않도록 주의
for문에서 무한히 돌리려면 조건식을 빼면 됨
int i = 1;
for( ; ; ) {
System.out.print(i);
if(i == 10 ) {
break;
}
System.out.print(i);
= i++
for문 중첩되는부분 잘체크
일반 for문은 1차원
이중 for문은 x축 y축
삼중 for문은 x축 y축 z축
Random random = new Random();
int random = ran.nextInt(10); 이거 사용도 가능
package com.greedy.section02.looping_statement
class Application
class A_for
package com.greedy.section02.looping_statement;
import java.util.Random;
import java.util.Scanner;
public class A_for {
/**
* <pre>
* 단순 for문 실행 흐름을 확인하기 위한 용도의 기능을 제공
* </pre>
*/
public void testSimpleStatement() {
/* [for문 표현식] */
/*
* for(초기식; 조건식; 증감식) {
* 조건을 만족하는 경우 수행할 구문(반복할 구문);
* }
* */
/* 1부터 10까지 1씩 증가시키면서 i값을 출력하는 반복문*/
for(int i = 1; i <= 10; i++) {
System.out.print(i);
}
/* 기본 반복문을 이용해서 조금씩 바꿔가며 문법에 익숙해지자
*
* 1.증감식이 없는경우
* 2.조건식이 없는경우
* 3.초기식, 조건식, 증감식이 없는경우
* 4.초기식, 조건식, 증감식 등을 변경하고 실행 값 예측해보기
* 5.역순으로 반복문 실행 등등 테스트해보기
* */
}
public void testForExample1() {
/* 10명의 학생 이름을 입력받아 이름을 출력해보자*/
Scanner sc = new Scanner(System.in);//
// System.out.print("1 번째 학생의 이름을 입력해주세요 : ");
// String student1 = sc.nextLine();
// System.out.println("1 번째 학생의 이름은 " + student1 + "입니다.");
//
// System.out.print("2 번째 학생의 이름을 입력해주세요 : ");
// String student2 = sc.nextLine();
// System.out.println("2 번째 학생의 이름은 " + student2 + "입니다.");
//
// System.out.print("3 번째 학생의 이름을 입력해주세요 : ");
// String student3 = sc.nextLine();
// System.out.println("3 번째 학생의 이름은 " + student3 + "입니다.");
//
// System.out.print("4 번째 학생의 이름을 입력해주세요 : ");
// String student4 = sc.nextLine();
// System.out.println("4 번째 학생의 이름은 " + student4 + "입니다.");
// System.out.print("5 번째 학생의 이름을 입력해주세요 : ");
// String student5 = sc.nextLine();
// System.out.println("5 번째 학생의 이름은 " + student5 + "입니다.");
//
// System.out.print("6 번째 학생의 이름을 입력해주세요 : ");
// String student6 = sc.nextLine();
// System.out.println("6 번째 학생의 이름은 " + student6 + "입니다.");
//
// System.out.print("7 번째 학생의 이름을 입력해주세요 : ");
// String student7 = sc.nextLine();
// System.out.println("7 번째 학생의 이름은 " + student7 + "입니다.");
//
// System.out.print("8 번째 학생의 이름을 입력해주세요 : ");
// String student8 = sc.nextLine();
// System.out.println("8 번째 학생의 이름은 " + student8 + "입니다.");
//
// System.out.print("9 번째 학생의 이름을 입력해주세요 : ");
// String student9 = sc.nextLine();
// System.out.println("9 번째 학생의 이름은 " + student9 + "입니다.");
//
// System.out.print("10 번째 학생의 이름을 입력해주세요 : ");
// String student10 = sc.nextLine();
// System.out.println("10 번째 학생의 이름은 " + student10 + "입니다.");
//
// System.out.println("10명의 학생 이름을 입력 받고 출력하는 기능을 완료했습니다!");
/*
* 반복해야 하는 내용은
* 1. 안내문구 출력
* 2. 학생 이름 입력받아 변수에 저장
* 3. 저장된 이름을 출력
*
* 반복하는 횟수 : 1부터 10까지 1씩 증가 총 10번 반복
* */
for(int i = 1; i <= 10 ; i++) {
System.out.print(i + " 번째 학생의 이름을 입력해주세요 : ");
String student = sc.nextLine();
System.out.println( i + " 번째 학생의 이름은 " + student + "입니다.");
}
System.out.println("10명의 학생 이름을 입력 받고 출력하는 기능을 완료했습니다!");
}
public void testForExample2() {
/* 1 ~ 10까지의 합계를 구하시오
*
* -> 1부터 10까지 1씩 증가시키면서 증가시키는 값을 저장할 변수에 계속 누적시켜 변수에
* 저장된 값을 출력하세요
* */
int num1 = 1;
int num2 = 2;
int num3 = 3;
int num4 = 4;
int num5 = 5;
int num6 = 6;
int num7 = 7;
int num8 = 8;
int num9 = 9;
int num10 = 10;
int sum = 0;
sum += num1;
sum += num2;
sum += num3;
sum += num4;
sum += num5;
sum += num6;
sum += num7;
sum += num8;
sum += num9;
sum += num10;
System.out.println("sum : " + sum); //반복에서 제외
/*반복해야 하는 내용*/
/* 1. 변수에 1씩 증가하는 값 담기
* 2. 저장된 값을 sum에 누적시키기
* */
int sum2 = 0;
for(int i = 0; i < 10; i++) {
sum2 += i + 1;
}
System.out.println("sum2: " + sum2);
}
public void testForExample3() {
/* 5 ~ 10 사이의 난수를 발생시켜서
* 1부터 발생한 난수까지의 합계를 구해보자.
* */// Random ran = new Random();
// int random = ran.nextInt(6) + 5;
int random = new Random().nextInt(6) + 5;
System.out.println("random : " + random);
System.out.println("random : " + random);
int sum = 0;
if(random == 5) {
sum += 1;
sum += 2;
sum += 3;
sum += 4;
sum += 5;
} else if(random == 6) {
sum += 1;
sum += 2;
sum += 3;
sum += 4;
sum += 5;
sum += 6;
} else if(random == 7) {
sum += 1;
sum += 2;
sum += 3;
sum += 4;
sum += 5;
sum += 6;
sum += 7;
} else if(random == 8) {
sum += 1;
sum += 2;
sum += 3;
sum += 4;
sum += 5;
sum += 6;
sum += 7;
sum += 8;
} else if(random == 9) {
sum += 1;
sum += 2;
sum += 3;
sum += 4;
sum += 5;
sum += 6;
sum += 7;
sum += 8;
sum += 9;
} else if(random == 10) {
sum += 1;
sum += 2;
sum += 3;
sum += 4;
sum += 5;
sum += 6;
sum += 7;
sum += 8;
sum += 9;
sum += 10;
}
System.out.println("1부터 " + random + "까지의 합은 : " + sum);
int sum2 = 0;
for(int i = 1; i <= random; i++) {
sum2 += i;
}
System.out.println("1부터 " + random + "까지의 합은 : " + sum2);
}
public void testForExample4() {
/* 숫자 두 개를 입력 받아 작은 수에서 큰 수까지의 합계를 구하세요
* 단, 두 숫자는 같은 숫자를 입력하지 않는다는 가정으로
* */
Scanner sc = new Scanner(System.in);
System.out.println("첫 번째 정수 입력 : ");
int first = sc.nextInt();
System.out.println("두 번째 정수 입력 : ");
int second = sc.nextInt();
int sum = 0;
if(first > second) { // 첫 번째 정수가 더 큰 경우
for(int i = second; i <= first; i++) {
sum += i;
}
}else { // 두 번째 정수가 더 큰 경우
for(int i = first; i <= second; i++) {
sum += i;
}
}
System.out.println("sum : " + sum);
}
public void printSimpleGugudan( ) {
/*
* 키보드로 2 ~ 9 사이의 구구단을 입력받아
* 2 ~ 9 사이인 경우 해당 단의 구구단을 출력하고
* 그렇지 않은 경우 " 반드시 2 ~ 9 사이의 양수를 입력해야 합니다. " 출력
*
*
* 출력할 구구단의 단 수를 입력하세요 : 5
*
* 5 * 1 = 5
* 5 * 2 = 10
* 5 * 3 = 15 ...
* */
Scanner sc = new Scanner(System.in);
System.out.print("출력할 구구단의 단 수를 입력하세요 : ");
int dan = sc. nextInt();
if (dan >=2 && dan <= 9) {
for (int i = 1; i <= 9; i++) {
System.out.println(dan + " * " + i + " = " + (dan * i));
}
} else {
System.out.println(" 반드시 2 ~ 9 사이의 양수를 입력해야 합니다. ");
}
sc.close();
}}
->출력할 구구단의 단 수를 입력하세요 : 7
7 1 = 7
7 2 = 14
7 3 = 21
7 4 = 28
7 5 = 35
7 6 = 42
7 7 = 49
7 8 = 56
class A_nestedFor
매개변수 선언 int dan 반복되는 메소드
반복문 자바 별 찍기
package com.greedy.section02.looping_statement;
import java.util.Scanner;
public class A_nestedFor {
public void printGugudanFromTwoToNine() {
/* 2단부터 단을 1씩 증가시키는 반복문 */
for(int dan = 2; dan < 10; dan++) {
for(int su = 1; su < 10; su++) {
System.out.println(dan + " * " + su + " = " + (dan * su));
}
System.out.println();
}
}
public void printupgradeGugudanFromTwoToNine() {
/* 2단부터 단을 1씩 증가시키는 반복문 */
for(int dan = 2; dan < 10; dan++) {
printGugudanOf(dan);
System.out.println();
}
}
public void printGugudanOf(int dan) {
for(int su = 1; su < 10; su++) {
System.out.println(dan + " * " + su + " = " + (dan * su));
}
}
public void pirntStarInputRowTimes() {
Scanner sc = new Scanner(System.in);
System.out.print("출력할 행 수를 입력하세요 : ");
int row = sc.nextInt();
/*
* 5
*
* *****
* *****
* *****
* *****
* *****
* */
for(int i = 1; i <= row; i++) { //행
for(int j = 1; j <= row; j++) { // 열
System.out.print("*");
}
System.out.println();
}
sc.close();
}
public void printTrianleStars() {
/*
* * (1,1)
* ** (2,1)(2,2)
* *** (3,1)(3,2)(3,3)
* **** (4,1)(4,2)(4,3)(4,4)
* ***** (5,1)(5,2)(5,3)(5,4)(5,5)
* */
Scanner sc = new Scanner(System.in);
System.out.print("출력할 행 수를 입력하세요 : ");
int row = sc.nextInt();
for (int i =1; i <= row; i++) {
for(int j = 1; j <= i; j++) {
System.out.print("*");
}
System.out.println();
}
}}
->출력할 행 수를 입력하세요 : 5
- **
class B_while
charAT -> 문자 하나씩 가져오는거
문자열의 갯수를 반환하는 메소드사용
str.length() 문자열의 길이를 가져오기 메소드
while문은 조건식이 참일때만 실행!
package com.greedy.section02.looping_statement;
import java.util.Scanner;
public class B_while {
public void testSimpleWhileStatement() {
/*
* [while문 표현식]
* 초기식;
*
* while(조건식) {
*
* 조건을 만족하는 경우 수행할 구문(반복할 구문);
* 증감식;
* }
* */
/*1부터 10까지 1씩 증가시키면서 i값을 출력하는 기본 반복문 */
for(int i = 1; i <=10; i++) {
System.out.println(i);
}
System.out.println("=======================");
int i = 1;
while(i <=10) {
System.out.println(i);
i++;
}
}
public void testWhileExample1() {
/* 입력한 문자열의 인덱스를 이용하여 문자 하나씩 출력해보기 */
/* charAt(int index) : 문자열에서 인덱스에 해당하는 문자를 char형으로 반환하는 기능
* length() : String 클래스의 메소드로 문자열의 길이를 int형으로 반환한다
*
* index는 0부터 시작하고 마지막 인덱스는 항상 길이(length)보다 한 개 작은 숫자를 가진다.
* 만약 존재하지 않은 인덱스에 접근하게되면 StringIndexOutOfBoundsException이 발생한다.
* */
Scanner sc = new Scanner(System.in);
System.out.print("문자열 입력 : ");
String str = sc.nextLine();
System.out.println("======= for문 ==========");
for(int i = 0; i < str.length(); i++) {
char ch = str.charAt(i);
System.out.println(i + " : " + ch);
}
System.out.println("======== while문 ==========");
int index = 0;
while(index < str.length()) {
char ch = str.charAt(index);
System.out.println(index + " : " + ch);
index++;
}
}
public void testWhileExample2() {
/* 정수 하나를 입력 받아 1부터 입력받은 정수까지의 합계를 구한다. */
Scanner sc = new Scanner(System.in);
System.out.println(" 정수를 하나 입력하세요 : ");
int num = sc.nextInt();
int i = 1;
int sum = 0;
while(i <= num) {
sum += i;
i++;
}
System.out.println("1부터 입력 받은 정수" + num + "까지의 합은" + sum + "입니다.");
sc.close();
}
public void testWhileExample3() {
/* 중첩 while문을 이용한 구구단 출력하기 */
int dan = 2;
while(dan < 10) {
int su = 1;
while(su < 10) {
System.out.println(dan + "*" + su + "=" + (dan * su));
su++;
}
System.out.println();
dan++;
}
}}
->문자열 입력 : hello
======= for문 ==========
0 : h
1 : e
2 : l
3 : l
4 : o
======== while문 ==========
0 : h
1 : e
2 : l
3 : l
4 : o
정수를 하나 입력하세요 :
8
1부터 입력 받은 정수8까지의 합은36입니다.
21=2
22=4
23=6
24=8
25=10
26=12
27=14
28=16
2*9=18
31=3
32=6
33=9
34=12
35=15
36=18
37=21
38=24
3*9=27
41=4
42=8
43=12
44=16
45=20
46=24
47=28
48=32
4*9=36
51=5
52=10
53=15
54=20
55=25
56=30
57=35
58=40
5*9=45
61=6
62=12
63=18
64=24
65=30
66=36
67=42
68=48
6*9=54
71=7
72=14
73=21
74=28
75=35
76=42
77=49
78=56
7*9=63
81=8
82=16
83=24
84=32
85=40
86=48
87=56
88=64
8*9=72
91=9
92=18
93=27
94=36
95=45
96=54
97=63
98=72
9*9=81
class C_doWhile
원래 false는 동작을 안함 dowhile은 일단 한번은 실행함
package com.greedy.section02.looping_statement;
import java.util.Scanner;
public class C_doWhile {
public void testSimpleDoWhileStatement() {
/*
* [do-while문 표현식]
* 초기식;
* do {
* 1회차에는 무조건 실행하고, 이후에는 조건식을 확인하여 조건을 만족하는
* 경우 수행할 구문(반복할 구문)
* 증감식;
* } while(조건식);
* */
do {
System.out.println("최초 한 번 동작함");
} while(false);
System.out.println("반복문 종료 확인...");
}
public void testDoWhileExample1() {
/* 키보드로 문자열 입력 받아 반복적으로 출력
* 단, exit가 입력되면 반복문을 종료한다.
* */
Scanner sc = new Scanner(System.in);
String str = "";
do {
System.out.print("문자열을 입력하세요 : ");
str = sc.nextLine();
System.out.println(str);
} while(!str.equals("exit"));
/* equals() : 문자열은 == 비교가 불가능하다. 문자열이 같은지를 비교하는 기능을 제공하고 있다. */
System.out.println("프로그램을 종료합니다.");
sc.close();
}}
->최초 한 번 동작함
반복문 종료 확인...
문자열을 입력하세요 : esc
esc
문자열을 입력하세요 : esc
esc
문자열을 입력하세요 : esc
esc
문자열을 입력하세요 :
Application
package com.greedy.section02.looping_statement;
public class Application {
public static void main(String[] args) {
A_for a = new A_for();// a.testSimpleStatement();
// a.testForExample1();
// a.testForExample2();
// a.testForExample3();
// a.testForExample4();
// a.printSimpleGugudan();
A_nestedFor an = new A_nestedFor();// an.printGugudanFromTwoToNine();
// an.printupgradprintTrianleStarseGugudanFromTwoToNine();
// an.pirntStarInputRowTimes();
// an.printTrianleStars();
B_while bw = new B_while();// bw.testSimpleWhileStatement();
// bw.testWhileExample1();
// bw.testWhileExample2();
// bw.testWhileExample3();
C_doWhile cd = new C_doWhile();// cd.testSimpleDoWhileStatement();
cd.testDoWhileExample1();
}}
package com.greedy.section03.branching_statement
class A_break
unreachable code : 여기까지 코드가 도달할 수 없다.
break는 가장 가까운 반복문을 나간다.
System.out.println(dan + " " + su + " = " + (dan su));
} -> break 사용할때 출력문의 위치 중요하다 밑에있어야함
return은 메소드의 가장아래에 있어야하며 호출한곳으로 다시 돌아간다.
밑에 코드가 있어도 종료 시키고 호출한곳으로 감
break부분을 return으로 바꿔도 나가긴하는데 극단적으로 나감
break는 9단까지 *5부분 return은 2단만
label:을 하면 크게 묶음으로 이름이 붙여짐
package com.greedy.section03.branching_statement;
public class A_break {
public void testSimpleBreakStatement() {
/* break문은 반복문내에서 사용한다.
* 해당 반복문을 빠져 나올 때 사용하며, 반복문의 조건문 판단
* 결과와 상관없이 반복문을 빠져나올때 사용한다.
*
* 일반적으로 if(조건식) {break; } 처럼 사용된다.
* 단, switch문은 반복문이 아니지만 예외적으로 사용된다.
* */
int sum = 0;
for(int i = 1; ; i++) {
sum += i;
if(i == 100) {
break;
}
}
System.out.println("1부터 100까지의 합은 " + sum + "입니다.");
int sum2 = 0;
int i2 = 1;
while(true) {
sum2 += i2;
if(i2 == 100) {
break;
}
i2++;
}
System.out.println("1부터 100까지의 합은 " + sum2 + "입니다.");
}
public void testSimpleBreakStatement2() {
/* 중첩 반복문 내에서 분기문 흐름
* break는 모든 반복문을 종료하는 것이 아닌, 자신에게 가장 인접한 반복문 실행만 멈춘다.
* */
/* 구구단 2 ~ 9단까지 출력
* 단 각 단의 수가 5보다 큰 경우 출력을 생략한다.
* */
for(int dan = 2 ; dan < 10; dan++) {
for(int su = 1; su < 10; su++) {
if(su > 5) {
/* su가 5보다 큰 경우 해당 반복문을 빠져나온다. */
break;
}
System.out.println(dan + " * " + su + " = " + (dan * su));
}
System.out.println();
}
}
public void testJumpBreak() {
/* 중첩 반복문 내에서 분기문(break)을 이용하여 한 번에 여러 개의 반복문 중지시킬때 사용*/
label:
for(;;) {
for(int i = 0; i < 10; i++) {
System.out.println(i);
if(i == 3 ) {
break label;
}
}
}
}}
->
1부터 100까지의 합은 5050입니다.
1부터 100까지의 합은 5050입니다.
2 1 = 2
2 2 = 4
2 3 = 6
2 4 = 8
2 * 5 = 10
3 1 = 3
3 2 = 6
3 3 = 9
3 4 = 12
3 * 5 = 15
4 1 = 4
4 2 = 8
4 3 = 12
4 4 = 16
4 * 5 = 20
5 1 = 5
5 2 = 10
5 3 = 15
5 4 = 20
5 * 5 = 25
6 1 = 6
6 2 = 12
6 3 = 18
6 4 = 24
6 * 5 = 30
7 1 = 7
7 2 = 14
7 3 = 21
7 4 = 28
7 * 5 = 35
8 1 = 8
8 2 = 16
8 3 = 24
8 4 = 32
8 * 5 = 40
9 1 = 9
9 2 = 18
9 3 = 27
9 4 = 36
9 * 5 = 45
0
1
2
3
class B_continue
package com.greedy.section03.branching_statement;
public class B_continue {
public void testSimpleContinueStatment() {
/* continue문은 반복문 내에서 사용한다.
* 해당 반복문의 반복 회차를 중간에 멈추고 다시 증감식으로 넘어가게 해준다.
* 일반적으로 if(조건식) { continue; } 처럼 사용된다.
*
* 보통 반복문 내에서 특정 조건에 대한 예외를 처리하고자 할 때 자주 사용된다.
* */
/* 1부터 100사이의 4의 배수이면서 5의 배수인 값 출력 */// for(int i = 1; i <= 100; i++) {
//
// if(i % 4 == 0 && i % 5 == 0 ) {
//
// / i값이 4와 5의 공배수인 값/
// System.out.println(i);
//
// } else {
// /공배수가 아닌 경우 증감식으로 이동/
// continue;
// }
//
// }
for(int dan = 2; dan < 10; dan++) {
/* continue는 모든 반복문을 건너 뛰는것이 아닌 자신에게 가장 인접한 반복문 실행만 건너뛴다.
* */
for(int su = 1; su < 10; su++) {
if(su % 2 == 0) {
continue;
}
System.out.println(dan + " * " + su + " = " + (dan * su));
}
System.out.println();
}
}
public void testJumpContinue() {
label:
for(int dan = 2; dan < 10; dan++) {
for(int su = 1; su < 10; su++) {
if(su % 2 == 0) {
continue label;
}
System.out.println(dan + " * " + su + " = " + (dan * su));
}
System.out.println();
}
}}
->20
40
60
80
100
2 1 = 2
2 3 = 6
2 5 = 10
2 7 = 14
2 * 9 = 18
3 1 = 3
3 3 = 9
3 5 = 15
3 7 = 21
3 * 9 = 27
4 1 = 4
4 3 = 12
4 5 = 20
4 7 = 28
4 * 9 = 36
5 1 = 5
5 3 = 15
5 5 = 25
5 7 = 35
5 * 9 = 45
6 1 = 6
6 3 = 18
6 5 = 30
6 7 = 42
6 * 9 = 54
7 1 = 7
7 3 = 21
7 5 = 35
7 7 = 49
7 * 9 = 63
8 1 = 8
8 3 = 24
8 5 = 40
8 7 = 56
8 * 9 = 72
9 1 = 9
9 3 = 27
9 5 = 45
9 7 = 63
9 * 9 = 81
2 1 = 2
3 1 = 3
4 1 = 4
5 1 = 5
6 1 = 6
7 1 = 7
8 1 = 8
9 1 = 9
application
package com.greedy.section03.branching_statement;
public class Application {
public static void main(String[] args) {
A_break a = new A_break();// a.testSimpleBreakStatement();
// a.testSimpleBreakStatement2();
// a.testJumpBreak();
B_continue b = new B_continue();// b.testSimpleContinueStatment();
b.testJumpContinue();
}
}
깃랩 테스트
