네이버 클라우드 캠프 28일차 230602
#1 교육정리
1) 흐름제어문 : 조건문 if
2) 흐름제어문 : 반복문 while
3) 흐름제어문 : for 반복문
#2 흐름 제어문 : 조건문 if
조건문 if)
조건문이란 말 그대로 주어진 조건에 따라 다른 문장을 선택할 수 있도록 프로그래밍하는 것을 말합니다. 예를 들어 '만약 나이가 8살 이상이면 학교에 다닌다' 라는 문장에서는 '나이'가 조건이 됩니다. 다음은 우리가 배울 조건문과 유사항 형태를 쉽게 표현한 것입니다.
만약(나이가 8살 이상이라면) {
학교에 다닙니다
}
그렇지 않다면 {
학교에 다니지 않습니다
}
다음과 같은 문장을 if 문으로 나타내면 아래와 같습니다.
문법1 : if (조건) 문장1; => 조건이 참일때 문장1을 수행합니다.
int age = 10;
if (age >= 8) { // age 값이 8이상이면 아래 "학교에 다닙니다" 문장을 수행합니다.
System.out.println("학교에 다닙니다");
}
문법2 : if (조건) {문장1; 문장2;}
조건이 참일 때 여러 개의 문장을 실행하고 싶다면 중괄호 {} 를 사용하여 묶습니다.
블록으로 묶지 않으면 첫 번째 문장만 if에 종속됩니다.
들여쓰기는 문법에 영향을 끼치지 않습니다.
public class Exam0120 {
public static void main(String[] args) {
int age = 17;
if (age >= 19)
System.out.println("성인이다."); // 이 문장만 if에 소속된다.
System.out.println("군대 가야한다.");
System.out.println("일해야 한다.");
System.out.println("세금 납부해야 한다.");
System.out.println("------------------------------");
// 여러 문장을 if 문에 종속시키고 싶으면, 블록을 사용하라!
if (age >= 19) {
System.out.println("성인이다.");
System.out.println("군대 가야한다.");
System.out.println("일해야 한다.");
System.out.println("세금 납부해야 한다.");
}
}
}
군대 가야한다.
일해야 한다.
세금 납부해야 한다.
------------------------------
if 문의 조건은 반드시 boolean 데이터여야 합니다.
즉, if 문은 조건식의 결과가 true인 경우에만 해당 블록의 코드를 실행합니다.
아래와 같이 예시를 들어보겠습니다.
ublic class Exam0130 {
public static void main(String[] args) {
if (true) System.out.println("1111");
if (false) System.out.println("2222"); // <= 실행되지 않음!
if (10 < 8 + 5) System.out.println("3333");
// 그 외의 모든 데이터 타입은 컴파일 오류이다.
// if (1) System.out.println("4444"); // 컴파일 오류!
// if (3.14f) System.out.println("4444"); // 컴파일 오류!
// if (0b0110 & 0b0011) System.out.println("4444"); // 컴파일 오류!
// == 연산자 대신 =을 사용한 경우,(오타)
int a = 100;
if (a == 100) System.out.println("5555"); // OK!
// 다음은 a 변수에 100을 넣는다.
// 그런데 a가 boolean이 아니기 때문에 컴파일 오류가 발생한다.
// if (a = 100) System.out.println("6666"); // 컴파일 오류!
boolean b;
if (b = true) System.out.println("된다!");
}
}
1111
3333
5555
된다!
조건문 if ~ else)
조건식을 만족하는 경우와 만족하지 않는 경우를 모두 나타낼 때는 if ~ else 문을 사용합니다.
if ~ else 문은 '만약 ~이라면, 그렇지 않다면' 으로 해석할 수 있습니다. 주어진 조건식이 '참'일 경우에 if문 블록 안에 있는 문장을 수행하고 '거짓'일 경우에는 else문 블록 안에 있는 문장을 수행합니다. 따라서 'else'문에는 '조건식'을 사용하지 않습니다. if ~ else 문은 어떤 조건식이 참인 경우와 그 반대의 경우를 구현한 것이기 때문입니다.
else 문만 단독으로 사용할 수 없고 항상 if 문과 짝을 이뤄 사용해야 합니다.
그리고 if문과 else문 사이에 다른 문장이 올 수 없습니다.
if (조건식) {
수행문1; //조건식이 참일 경우에 이 문장을 수행
}
else {
수행문2; //조건식이 거짓일 경우에 이 문장을 수행
}
public class Exam0140 {
public static void main(String[] args) {
int age = 17;
// if 문은 else 문 없이 단독으로 사용할 수 있다.
if (age < 19)
System.out.println("미성년입니다.1");
if (age >= 19)
System.out.println("성년입니다.1");
// else문을 사용하는 아주 모범적인 예!
if (age >= 19) // 조건이 거짓이면 다음 else 문을 실행한다.
System.out.println("성인입니다.2");
else
System.out.println("미성년입니다.2");
// 여러 문장을 실행할 때 블록으로 묶어야 한다.
if (age >= 20) {
System.out.println("--------------");
System.out.println("성인입니다.3");
}
else {
System.out.println("--------------");
System.out.println("미성년입니다.3");
}
// 한 문장일 때는 블록으로 묶지 않아도 된다.
if (age >= 19) { // OK!
System.out.println("성인입니다.4");
System.out.println("--------------------------");
}
else
System.out.println("미성년입니다.4");
// 한 문장일 때는 블록으로 묶지 않아도 된다.
if (age >= 19)
System.out.println("성인입니다.5");
else {
System.out.println("미성년입니다.5");
System.out.println("--------------------------");
}
}
}
미성년입니다.1
미성년입니다.2
--------------
미성년입니다.3
미성년입니다.4
미성년입니다.5
--------------------------
그런데 하나의 상황에 조건이 여러 개인 경우에는 if ~ else if ~else ... 문으로 표현할 수 있습니다.
다음의 식은 코드를 통해서 살펴보겠습니다.
- 기본 if ~ else if ~ else 식
import java.util.Scanner;
public class Exam0160 {
public static void main(String[] args) {
Scanner keyScan = new Scanner(System.in);
System.out.print("나이를 입력하세요? ");
int age = keyScan.nextInt();
if (age < 8)
System.out.println("아동입니다.");
else {
if (age < 14)
System.out.println("어린이입니다.");
else {
if (age < 19)
System.out.println("청소년입니다.");
else {
if (age < 65)
System.out.println("성인입니다.");
else
System.out.println("노인입니다.");
}
}
}
keyScan.close();
}
}
나이를 입력하세요? 15(입력한 값)
청소년입니다.
- 기본 if ~ else if ~ else 식
if ~ else ~ 는 한문장이기 때문에 if ~ else ~ 만 있다면 블록으로 묶지 않아도 됩니다.(하지만 조건이 여러개일경우 어떤 if문에 어떤 else 식을 실행하는지 헷갈릴 수 있어 주의해야합니다.)
import java.util.Scanner;
public class Exam0161 {
public static void main(String[] args) {
Scanner keyScan = new Scanner(System.in);
System.out.print("나이를 입력하세요? ");
int age = keyScan.nextInt();
// if ~ else ~는 한 문장이기 때문에
// if ~ else ~ 만 있다면 블록으로 묶지 않아도 된다.
if (age < 8)
System.out.println("아동입니다.");
else
if (age < 14)
System.out.println("어린이입니다.");
else
if (age < 19)
System.out.println("청소년입니다.");
else
if (age < 65)
System.out.println("성인입니다.");
else
System.out.println("노인입니다.");
keyScan.close();
}
}
나이를 입력하세요? 20
성인입니다.
switch-case)
조건문을 구현할 때 if문을 사용하면 번거로운 경우가 있습니다.
그래서 주로 조건이 하나의 변수 값이나 상수 값으로 구분되는 경우 사용합니다. 조건이 복잡한 식으로 이루어진다면, 예를 들어 10 < age < 20 과 같은 경우는 switch-case 문이 적합하지 않습니다. 하나의 값으로 조건을 비교할 수 있을 때, 예를 들어 학점 A, B, C 처럼 대상을 하나의 값으로 비교할 수 있을 때 사용합니다.
문법은 switch (값) {}
값으로 가능한 데이터 타입 : int 정수(byte, short, int, char), 문자열, 특별한 상수 Enum 타입 / case 값으로 변수를 사용할 수 없고 리터럴만 가능합니다.
다음은 switch 사용 전의 코드입니다.
import java.util.Scanner;
//# 흐름 제어문 - switch 사용 전
//
public class Exam0210 {
public static void main(String[] args) {
// 키보드 입력을 다루는 도구 생성
Scanner keyScan = new Scanner(System.in);
System.out.println("[지원부서]");
System.out.println("1. S/W개발");
System.out.println("2. 일반관리");
System.out.println("3. 시설경비");
System.out.print("지원 분야의 번호를 입력하세요? ");
// 사용자가 콘솔 창에 입력할 수 있도록
// 커서를 대기시키고 싶다면 nextInt()를 실행하라!
// => nextInt()는 사용자가 숫자를 입력하고 엔터를 칠 때까지 기다린다.
int no = keyScan.nextInt();
System.out.println("제출하실 서류는 다음과 같습니다.");
if (no == 1) {
System.out.println("정보처리자격증");
System.out.println("졸업증명서");
System.out.println("이력서");
} else if (no == 2) {
System.out.println("졸업증명서");
System.out.println("이력서");
} else if (no == 3) {
System.out.println("이력서");
} else {
System.out.println("올바른 번호를 입력하세요!");
}
keyScan.close();
}
}
다음은 switch 사용 후의 코드입니다.
아울러 아래 코드에서 no의 값이 case에 해당하는 경우 break 명령을 만날 때까지 아래로 계속 실행합니다.
import java.util.Scanner;
//# 흐름 제어문 - switch 사용 후
//
public class Exam0221 {
public static void main(String[] args) {
Scanner keyScan = new Scanner(System.in);
System.out.println("[지원부서]");
System.out.println("1. S/W개발");
System.out.println("2. 일반관리");
System.out.println("3. 시설경비");
System.out.print("지원 분야의 번호를 입력하세요? ");
int no = keyScan.nextInt();
System.out.println("제출하실 서류는 다음과 같습니다.");
switch (no) {
case 1:
System.out.println("정보처리자격증");
System.out.println("졸업증명서");
System.out.println("이력서");
break; // 여기까지만 실행한다.
case 2:
System.out.println("졸업증명서");
System.out.println("이력서");
break; // 여기까지만 실행한다.
case 3:
System.out.println("이력서");
break; // 여기까지만 실행한다.
default:
System.out.println("올바른 번호를 입력하세요!");
}
keyScan.close();
}
}
if vs switch 문을 사용 비교해보면,
복잡한 조건으로 프로그램 흐름을 제어해야 하는 상황이라면 if 문을 사용하고,
int나 문자열처럼 단순한 값으로 프로그램을 제어할 수 있다면 switch문을 사용하는게 낫습니다.
상수를 사용하지 않았을 때 아래와 같은 문법도 있습니다.
그러나, 값의 의미를 달아야만 다른 개발자들이 이해할 수 있습니다.
public class Exam0240 {
public static void main(String[] args) {
int level = 1;
// 상수를 사용하지 않았을 때
// => 값의 의미를 주석으로 달아야만 다른 개발자가 이해할 수 있다.
switch (level) {
case 0: // 손님
System.out.println("조회만 가능합니다.");
break;
case 1: // 일반회원
System.out.println("글작성 가능합니다.");
break;
case 2: // 관리자
System.out.println("다른 회원의 글을 변경, 삭제할 수 있습니다.");
break;
}
}
}
글작성 가능합니다.
상수를 좀 더 조직적으로 관리하는 방법으로는,
enum을 사용하여 상수를 정의합니다. nested enum은 기본이 static 입니다. 그래서 static을 생략해도 됩니다.
enum으로 정의된 상수를 사용하려면 enum 타입의 변수를 선언해야 합니다.
final int 처럼 직접 값을 지정하지 않아도 되며, 값을 직접 지정할 수도 있습니다.
enum을 사용하는 주된 이유는 100, 200, "admin" 과 같이 값을 직접 지정할 필요가 없습니다. enum 변수에는 그 타입에 정의된 값만 저장할 수 있습니다. 그래서 안전한 코드를 작성할 수 있습니다.
아래와 같이 코드로 살펴보겠습니다.
public class Exam0242 {
enum Level {
GUEST, MEMBER, ADMIN
}
public static void main(String[] args) {
Level level = Level.MEMBER;
// 다음과 같이 switch나 case 값으로 enum 타입의 값이 올 수 있다.
switch (level) {
case GUEST:
System.out.println("조회만 가능합니다.");
break;
case MEMBER:
System.out.println("글작성 가능합니다.");
break;
case ADMIN:
System.out.println("다른 회원의 글을 변경, 삭제할 수 있습니다.");
break;
}
}
}
글작성 가능합니다.
#3 흐름제어문 : 반복문 while
반복문 while)
자바 프로그램에서 사용하는 반복문의 종류에는 while문, do-while문, for문 이렇게 세가지가 있습니다. 모두 반복 수행을 한다는 것은 동일하지만, 사용 방법에는 조금씩 차이가 있습니다.
while문은 조건식이 참인 동안 수행문을 반복해서 수행합니다.
문법은 아래 코드와 같습니다.
public class Exam0310 {
public static void main(String[] args) {
int count = 0;
// 문법1:
// while (조건) 문장;
// => 조건이 참인 동안 문장을 계속 실행한다.
while (count < 5) System.out.println(count++);
System.out.println("---------------------------");
// 문법2:
// while (조건)
// 문장;
// => 조건이 참인 동안 문장을 계속 실행한다.
count = 0;
while (count < 5)
System.out.println(count++);
System.out.println("---------------------------");
// 문법3:
// while (조건) {}
// => 여러 개의 문장을 반복 실행하려면 블록으로 묶어라!
count = 0;
while (count < 5) {
System.out.println(count);
count++;
}
}
}
0
1
2
3
4
---------------------------
0
1
2
3
4
---------------------------
0
1
2
3
4
반복문 while - break와 continue 활용)
- continue
public class Exam0321 {
public static void main(String[] args) {
int count = 0;
int sum = 0;
// 1부터 100까지의 짝수의 합은?
// => continue 사용 전
count = 0;
sum = 0;
while (count < 100) {
count++;
if ((count & 1) == 0) { // count & 1 ==> count & 0x01 ==> count % 2
sum += count;
}
}
System.out.printf("count=%d, sum=%d\n", count, sum);
System.out.println("------------------------");
// => continue 사용 후
count = 0;
sum = 0;
while (count < 100) {
count++;
if (count % 2 == 1)
continue; // 다음 문장을 실행하지 않고 즉시 조건 검사로 이동한다.
sum += count;
}
System.out.printf("count=%d, sum=%d\n", count, sum);
}
}
count=100, sum=2550
------------------------
count=100, sum=2550
- break
package com.eomcs.lang.ex06;
//# 흐름 제어문 - break와 continue 활용
//
public class Exam0322 {
public static void main(String[] args) {
int count = 0;
int sum = 0;
// 1부터 100까지의 카운트를 하는데 단 합은 50까지만 계산한다.
// => break 사용 전
count = 0;
sum = 0;
while (count < 100) {
count++;
if (count > 50) // 50을 넘어가면 합을 수행하지 않지만 100까지 계속 반복한다.
continue; // 50까지 더한 후 밑에 합을 실행하지 않고 위에 while (count < 100) { count++; 로 돌아갑니다.
sum += count;
}
System.out.printf("count=%d, sum=%d\n", count, sum);
System.out.println("------------------------");
// => break 사용 후
count = 0;
sum = 0;
while (count < 100) {
count++;
if (count > 50)
break; // 즉시 반복문을 종료하고 나간다.
sum += count; // 50까지 증감
}
System.out.printf("count=%d, sum=%d\n", count, sum);
}
}
count=100, sum=1275
------------------------
count=51, sum=1275
중복된 반복문 탈출)
라벨명을 주어 라벨 안에 소속된 문장만 나가도록 합니다.
라벨명: 반복문1 { 반복문2 {break 라벨명;}}
라벨 문법:
라벨: 문장;
라벨: {문장1, 문장2, ...}
public class Exam0331 {
public static void main(String[] args) {
int x = 2, y = 1;
myloop:
while (x <= 9) {
while (y <= 9) {
System.out.printf("%d * %d = %d\n", x, y, x * y);
if (x == 5 && y == 5)
break myloop; // myloop 라벨에 소속된 문장을 나간다.
y++;
}
System.out.println();
x++;
y = 1;
}
System.out.println("종료!!");
System.out.println("-----------------------------");
}
}
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
3 * 1 = 3
3 * 2 = 6
3 * 3 = 9
3 * 4 = 12
3 * 5 = 15
3 * 6 = 18
3 * 7 = 21
3 * 8 = 24
3 * 9 = 27
4 * 1 = 4
4 * 2 = 8
4 * 3 = 12
4 * 4 = 16
4 * 5 = 20
4 * 6 = 24
4 * 7 = 28
4 * 8 = 32
4 * 9 = 36
5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
종료!!
do ~ while 반복문)
while문은 조건을 먼저 검사하기 때문에 조건식에 맞지 않으면 반복 수행이 한 번도 일어나지 않습니다. 하지만 do ~ while문은 {} 안의 문장을 무조건 한 번 수행한 후에 조건식을 검사합니다. 즉, 조건이 만족하는지 여부를 마지막에 검사하는 것입니다. 따라서 중괄호 안의 문장을 반드시 한 번 이상 수행해야 할 때 while문 대신 do ~ while문을 사용합니다.
정리하자면,
# do ~ while
- 최소 한 번은 반복한다.
- 한 번 이상 반복하면 do ~ while
- 0 번 이상 반복하면 while
do
문장1;
while (조건);
do {
문장1;
문장2;
문장3;
} while (조건);
public class Exam0340 {
public static void main(String[] args) {
int i = 0;
// 1부터 10까지 출력하기
do
System.out.println(++i);
while (i < 10);
System.out.println("---------------------");
// 여러 개의 문장을 반복할 때는 블록으로 묶어라!
i = 0;
do {
i += 1;
System.out.println(i);
} while (i < 10);
}
}
1
2
3
4
5
6
7
8
9
10
---------------------
1
2
3
4
5
6
7
8
9
10
#4 흐름제어문 : for 반복문
반복문 중에서 가장 많이 사용하는 반복문이 for문 입니다. for문은 while문이나 do-while문보다 구조가 조금 더 복잡합니다. 왜냐하면 반복문을 구현하는 데 필요한 여러 요소(변수의 초기화식, 조건식, 증감식 등) 를 함께 작성하기 때문입니다. 처음에는 for문이 좀 낯설겠지만, 익숙해지면 어떤 조건부터 어떤 조건까지 반복 수행하는지 한눈에 알아볼 수 있어 편리합니다.
문법은 아래와 같습니다.
for (변수선언 및 초기화; 조건; 증감문) 문장;
for (변수선언 및 초기화; 조건; 증감문) {문장1; 문장2; ...}
public class Exam0410 {
public static void main(String[] args) {
// for 문의 전형적인 예
for (int i = 1; i <= 5; i++) // i 가 5보다 작거나 같으면 참, 아니면 거짓, 참이면 증감
System.out.println(i);
// 실행 순서
// 1) 변수초기화 => int i = 1
// 2) 조건 => i <= 5
// 3) 문장 => System.out.print(i + " ")
// 4) 변수증가문 => i++
// 조건이 참인 동안 2 ~ 4를 반복한다.
// for 문에서 선언한 변수는 그 for 문 안에서만 사용할 수 있다.
// System.out.println(i); // 컴파일 오류!
}
}
1
2
3
4
5
for 반복문 : 증감문 제거)
public class Exam0411 {
public static void main(String[] args) {
// for (변수선언 및 초기화; 조건; 증감문) 문장;
// for (변수선언 및 초기화; 조건; 증감문) {문장1; 문장2; ...}
for (int i = 1; i <= 5; ) {
System.out.println(i);
i++;
}
}
}
1
2
3
4
5
for 반복문 : 변수 선언 및 초기화 문장 제거)
public class Exam0412 {
public static void main(String[] args) {
// for (변수선언 및 초기화; 조건; 증감문) 문장;
// for (변수선언 및 초기화; 조건; 증감문) {문장1; 문장2; ...}
int i = 1;
for ( ; i <= 5; ) {
System.out.println(i);
i++;
}
// for 문을 종료한 후에도 i 변수를 사용할 수 있다.
System.out.println(i);
}
}
1
2
3
4
5
6
for 반복문 : 조건문 제거)
public class Exam0413 {
public static void main(String[] args) {
// for (변수선언 및 초기화; 조건; 증감문) 문장;
// for (변수선언 및 초기화; 조건; 증감문) {문장1; 문장2; ...}
int i = 1;
for ( ; ; ) {
if (i > 5)
break;
System.out.println(i);
i++;
}
}
}
1
2
3
4
5
for 반복문의 초기화 변수)
public class Exam0420 {
public static void main(String[] args) {
// for 문 안에 선언된 변수는 for 문을 나가는 순간 제거된다.
for (int i = 1; i <= 5; i++)
System.out.println(i);
// 그래서 다음과 같이 i 변수의 값을 조회하려 하면
// 컴파일 오류가 발생한다.
// System.out.println(i); // 컴파일 오류!
System.out.println("----------------------");
// 반복문을 종료한 뒤라도 해당 변수의 값을 사용하고 싶으면,
// 다음과 같이 반복문 밖에 변수를 선언하라!
int x;
for (x = 1; x <= 5; x++)
System.out.println(x);
System.out.printf("x = %d\n", x);
}
}
1
2
3
4
5
----------------------
1
2
3
4
5
x = 6
for 반복문의 초기화 변수2)
ublic class Exam0421 {
public static void main(String[] args) {
// 변수초기화 시키는 문장에 여러 개의 변수를 선언 할 수 있다.
// 변수 증가문에 여러 개의 문장을 작성할 수 있다.
for (int i = 1, j = 3, k = 5; i <= 10; i++, j--, k += 2)
System.out.printf("(%d,%d,%d) ", i, j, k);
System.out.println();
}
}
(1,3,5) (2,2,7) (3,1,9) (4,0,11) (5,-1,13) (6,-2,15) (7,-3,17) (8,-4,19) (9,-5,21) (10,-6,23)
for 중첩 반복문)
반복문 안에 또 다른 반복문을 중첩해서 사용하는 경우가 종종 있습니다.
public class Exam0430 {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + " ");
}
System.out.println();
}
}
}
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9 10
for 중첩과 break)
break문을 사용하면 모든 반복문을 빠져나오는 것이 아니고 break문을 감싸고 있는 반복문만 빠져나옵니다.
public class Exam0431 {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + " ");
if (j == 5)
break; // break 소속된 현재 반복문을 멈춘다.
}
System.out.println();
}
}
}
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
for 중첩과 continue)
continue문은 반복문과 함께 자주 쓰입니다. 반복문 안에서 continue문을 만나면 이후의 문자은 수행하지 않고 for문의 처음으로 돌아가 증감식을 수행합니다.
public class Exam0433 {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
for (int j = 1; j <= i; j++) {
if(j % 2 == 0)
continue; // 다음 줄로 가지 않고 '변수증가문'으로 이동한다.
System.out.print(j + " ");
}
System.out.println();
}
}
}
1
1
1 3
1 3
1 3 5
1 3 5
1 3 5 7
1 3 5 7
1 3 5 7 9
1 3 5 7 9
for( ; ; ) 와 배열)
public class Exam0440 {
public static void main(String[] args) {
// String[] names = new String[5];
// names[0] = "홍길동";
// names[1] = "임꺽정";
// names[2] = "유관순";
// names[3] = "윤봉길";
// names[4] = "안중근";
// String[] names;
// names = new String[] {"홍길동", "임꺽정", "유관순", "윤봉길", "안중근"};
// 배열 변수 선언과 동시에 배열 초기화를 실행할 때는 new String[] 을 생략할 수 있다.
String[] names = {"홍길동", "임꺽정", "유관순", "윤봉길", "안중근"};
for (int i = 0; i < names.length; i++)
System.out.println(names[i]);
}
}
홍길동
임꺽정
유관순
윤봉길
안중근
for( ; ; ) 와 배열2)
public class Exam0442 {
public static void main(String[] args) {
String[] names = {"홍길동", "임꺽정", "유관순", "윤봉길", "안중근"};
// 증가치 조정
for (int i = 0; i < names.length; i += 2) {
System.out.println(names[i]);
}
}
}
홍길동
유관순
안중근
for( : ) 와 배열)
- 배열 전체를 반복하거나 컬렉션 객체(java.util.Iterable 구현체) 전체를 반복할 때 유용한다.
- 배열의 일부만 반복할 수 없다.
- 배열의 값을 다룰 때 인덱스를 사용할 필요가 없어 편리하다.
문법:
for (변수 선언 : 배열, Iterable 구현체) 문장1;
for (변수 선언 : 배열, Iterable 구현체) { 문장1; 문장2; ...}
- 변수의 타입은 배열이나 Iterable 구현체의 항목 타입과 같아야 한다.
- 반복문을 돌 때 마다 항목을 값을 꺼내 변수에 담는다.
public class Exam0450 {
public static void main(String[] args) {
String[] names = {"홍길동", "임꺽정", "유관순", "윤봉길", "안중근"};
// 배열의 처음부터 끝까지 값을 꺼내는 것이라면
// 다음의 for 문법을 사용하라! 아주 편하다!
// for (배열에서 꺼낸 값을 저장할 변수 선언 : 배열주소) 문장;
for (String name : names)
System.out.println(name);
// String name; 다음과 같이 for문을 사용할 경우 변수 선언을 바깥에 둘 수 없습니다.
// for (name : names) // 컴파일 오류!
// System.out.println(name);
}
}
홍길동
임꺽정
유관순
윤봉길
안중근
for 반복문과 컬렉션)
list.size(); 는 list.add(); 하여 넣은 수 만큼의 크기로 확인하면 됩니다.
import java.util.ArrayList;
public class Exam0460 {
public static void main(String[] args) {
// 배열은 같은 타입의 값만 보관할 수 있지만
// 컬렉션은 다른 타입의 값도 보관할 수 있다.
//
// 배열은 크기가 고정되지만,
// 컬렉션은 크기가 가변적이다.
ArrayList list = new ArrayList();
list.add("홍길동");
list.add(3.14f);
list.add(true);
list.add(365);
for (int i = 0; i < list.size(); i++)
System.out.println(list.get(i));
}
}
홍길동
3.14
true
365
for 반복문과 컬렉션2)
import java.util.ArrayList;
public class Exam0470 {
public static void main(String[] args) {
// 제네릭 적용
ArrayList<String> list = new ArrayList<>();
list.add("홍길동");
list.add("임꺽정");
list.add("유관순");
list.add("안중근");
list.add("윤봉길");
list.add("김원봉");
list.add("김구");
// String 이 아닌 값은 넣을 수 없다.
// list.add(3.14f); // 컴파일 오류
// list.add(true); // 컴파일 오류
// list.add(365); // 컴파일 오류
for (int i = 0; i < list.size(); i++)
System.out.println(list.get(i));
}
}
홍길동
임꺽정
유관순
안중근
윤봉길
김원봉
김구