1. 목표
(1) 다양한 연산자에 대해서 학습하고 사용방법을 익힙니다.
(2) 조건문과 반복문을 통해 프로그램의 문맥을 구성하는 방법을 배웁니다.
(3) 배열로 연속된 데이터들을 효율적으로 저장하고 관리하는 방법을 배웁니다.
(4) 다차원 배열로 좀더 복잡한 데이터를 저장하고 관리하는 방법을 배웁니다.
(5) 컬렉션으로 연속된 데이터들을 더욱 효율적으로 저장하고 관리하는 방법을 배웁니다.
(6) 여러 컬렉션들의 기능을 익히고 적절하게 사용하는 방법을 배웁니다.
2. 연산자
계산할 때 계산의 대상이 되는 것이 피연산자 이며, 계산의 목적이 되는 것이 연산자입니다.
ex . 연사자의 종류
int x = 5;
int y = 10;
int z = x + y; // 5(피연산자) +(연산자) 10(피연산자) 계산
System.out.println(z); // 출력값 : 15가장 기본적인 연산자의 구조 입니다.
package week02;
public class W02 {
public static void main(String[] args) {
// 사칙연산 : +,-,*, /, %
System.out.println(4 + 2); //6
System.out.println(4 - 2); //2
System.out.println(4 * 2); //8
System.out.println(4 / 2); //2
System.out.println(5 / 2); //2
System.out.println(2 / 4); //0
System.out.println(4 % 2); //0
System.out.println(5 % 2); //1
// 우선순위 연산
System.out.println(2 + 2 * 2); // 6
System.out.println((2 + 2) * 2); // 8
System.out.println(2 + (2 * 2)); // 6
int a = 20;
int b = 10;
int c;
int d;
// 덧셈
c = a + b;
System.out.println(c);
// 뺄셈
c = a - b;
System.out.println(c);
// 곱셈
c = a * b;
System.out.println(c);
// 나눗셈(몫)
c = a / b;
System.out.println(c);
// 나눗셈(나머지)
c = a % b;
System.out.println(c);
}
}산술 연산자의 기본 예제입니다. 산술 연산자는 +, -, *, /, %, <<, >> 등이 존재합니다.
package week02;
public class W03 {
// 비교연산자 예제
public static void main(String[] args) {
System.out.println(10 > 9); // 10이 9보다 크니? : 응(true)
System.out.println(10 >= 9); // 10이 9보다 크거나 같니? 응(ture)
System.out.println(10 < 9); // 10이 9보다 작니? 아니(false)
System.out.println(10 <= 9); // 10이 9보다 크거나 작니? 아니(false)
System.out.println(10 >= 10); // 10이 10이랑 같니? 응(true)
System.out.println(10 == 9); // 10은 9랑 같니? 아니(false)
System.out.println(10 != 10); // 10은 10이 아니니? 아니(false)
System.out.println(10 != 9); // 10은 9가 아니니? 응(true)
}
}
비교 연산자의 기본 예제입니다. 비교 연산자는 >, <, >=, <=, ==, != 등이 존재합니다.
package week02;
public class W04 {
// 논리연산자
// 비교 연산의 결과값으로 받을 수 있는 boolean 값을 연결하는 연산자
// 조건을 연결 하였을 때 boolean 값들을 조합하여 참(true) 또는 거짓 (false) 값인 boolean 값을 출력
// &&(AND), ||(OR), !(NOT)
public static void main(String[] args) {
boolean flag1 = true;
boolean flag2 = true;
boolean flag3 = false;
System.out.println(flag1);
System.out.println(flag2);
System.out.println(flag3);
// (1) 피 연산자 중 하나라도 true이면 true => 또는 (OR : ||)
System.out.println("-----------------");
System.out.println(flag1 || flag2);
System.out.println(flag1 || flag2 || flag3);
// (2) 피 연산자 중 모두 true이면 true => 그리고(AND : &&)
System.out.println("-----------------");
System.out.println(flag1 && flag2);
System.out.println(flag1 && flag2 && flag3);
// (3) AND
System.out.println("AND--------------");
System.out.println((5 > 3) && (3 > 1));
System.out.println((5 > 3) && (3 < 1));
// (4) OR
System.out.println("OR---------------");
System.out.println((5 > 3) || (3 > 1));
System.out.println((5 > 3) || (3 < 1));
System.out.println((5 < 3) || (3 < 1));
// System.out.println(1 < 3 < 5); 불가능하다.
// 논리 부정 연산자(! : NOT)
System.out.println("NOT----------------");
System.out.println(!flag1);
System.out.println(!flag3);
System.out.println(!(5 == 5));
System.out.println(!(5 == 3));
}
}
논리 연산자의 기본 예제입니다. 논리 연산자는 &&(AND), ||(OR), !(NOT) 등이 존재합니다.
한번 확인해 보시고 출력결과로 확인 하시기 바랍니다.
출력결과 :
package week02;
public class W05 {
// 대입연산자
public static void main(String[] args) {
// 변수를 바로 연산해서 그 자리에서 저장하는(대입하는) 연산자
// =(기본연산자), +=, -=, *= .....(복합대입연산자)
// ++ : += 1
// -- : -= 1
// 기본 대입 연산자
int number = 10;
number = number + 2;
System.out.println(number);
number = number - 2;
System.out.println(number);
number = number * 2;
System.out.println(number);
number = number / 2;
System.out.println(number);
number = number % 2;
System.out.println(number);
System.out.println("----------------");
// 복합 대입 연산자
number = 10;
number += 2; //12
System.out.println(number);
number -= 2; //10
System.out.println(number);
number *= 2; //20
System.out.println(number);
number /= 2; //10
System.out.println(number);
number %= 2; //0
System.out.println(number);
// ++, --
System.out.println("----------------");
number++;
System.out.println(number);
// number = number + 1;
number--;
System.out.println(number);
// number = number - 1;
}}
대입 연산자의 기본 예제입니다. 비교 연산자는 =, ++, -- 등이 존재합니다.
package week02;
public class W06 {
public static void main(String[] args) {
// 대입연산자에서 주의해야 할 점!
// ++, --
int a = 10;
int b = 10;
// int val = ++a + b--; //a는 먼저 대입 했기때문에 11이 b는 뒤에 대입했기때문에 10이 출력된다.
// System.out.println(val); //21
int val = ++a + --b;
System.out.println(a); //a를 먼저 대입하면 결과값에 11을 현재 출력하고
System.out.println(b); //b를 먼저 대입하면 결과값에 9을 현재 출력한다.
System.out.println(val); //++a는 이미 1이 증가됐으니 그대로 11, b는 먼저 선언된 구문으로 인해 이제 9가 출력된다.
}
}대입 연산자의 주의 사항입니다. 왼쪽은 기본예제, 오른쪽은 주의 사항의 출력결과입니다.
출력결과 :
package week02;
public class W07 {
public static void main(String[] args) {
// 기타 연산자
// (1) 형변환 연산자
int intNumber = 93 + (int)98.8;
System.out.println(intNumber);
double doubleNumber = (double)93 + 98.8;
System.out.println(doubleNumber);
// (2) 상항 연산자
// 비교연산자와 항상 함께 쓰인다.
// 비교연산자의 결과 : true or false -> 이 결과의 값에 따라 결정되는 무언가!
// 조건 ? 참 : 거짓
int x = 1;
int y = 9;
boolean b = (x == y) ? true : false;
System.out.println(b);
String s = (x != y) ? "정답" : "오답";
System.out.println(s);
int max = (x > y) ? x : y;
System.out.println(max);
int min = (x < y) ? x : y;
System.out.println(min);
// (3) instance of(3주차 -> 클래스, 객체)
// 피 연산자가 조건에 명시된 클래스의 객체인지 비교하여
// 맞으면 -> true
// 틀리면 -> false
}
}기타 연산자의 기본 예제입니다. 기타 연산자는 (type), ? :, instance of 등이 존재합니다.
출력결과 :
package week02;
public class W08 {
public static void main(String[] args) {
// 연산자 우선순위 : 산술 > 비교 > 논리 > 대입
// - 연산자 여러개가 함께 있는 연산을 계산할때는 우선순위가 있습니다.
// - 위 우선순위에 따라서 최종적인 응닶이 결정됩니다.
// 단, 괄호로 감싸주면 괄호안의 연산이 최우선순위로 계산됩니다.
int x = 2;
int y = 9;
int z = 10;
boolean result = x < y && y < z;
System.out.println(result);
System.out.println("------------");
result = x + 10 < y && y < z;
System.out.println(result);
System.out.println("------------");
result = x + 2 * 3 > y;
System.out.println(result);
System.out.println("------------");
result = (x + 2) * 3 > y;
System.out.println(result);
System.out.println("------------");
}
}연산자 우선순위에 대한 기본 예제입니다.
출력결과 :
package week02;
// 주의 사항) 연산 전에 피연산자의 타입을 일치시키는 것
// - 두 피연산자의 타입을 같게 일치시킨다. (둘중에 저장공간 크기가 더 큰 타입으로 일치
// - 피연산자의 타입이 `int` 보다 작은 `short` 타입이면 `int`로 변환
// - 피연산자의 타입이 `long` 보다 작은 `int`, `short` 타입이면 `Long`으로 변환
// - 피연산자의 타입이 `float`보다 작은 `long`, `int`, `short` 타입이면 `float`으로 변환
// - 피연산자의 타입이 `double` 보다 작은 `float`, `long`, `int`, `short` 타입이면 `double`으로 변환
// - 이처럼, 변수 여러 개를 연산했을 때 결괏값은 피연산자 중 표현 범위가 가장 큰 변수 타입을 가지게 됩니다.
public class W09 {
public static void main(String[] args) {
short x = 10;
int y = 20;
int z = x + y;
long lx = 30L;
Long lz = z + lx;
float fx = x;
float fy = y;
float fz = z;
System.out.println(lz);
System.out.println(fx);
System.out.println(fy);
System.out.println(fz);
}
}연산전의 피연산자의 주의사항에 해당하는 예제입니다.
출력결과 :
package week02;
// - 비트연산
// - Bit 는 0, 1 둘중의 하나의 값만을 저장하는 컴퓨터가 저장(표현)가능한 가장 작은 단위
// - 컴퓨터의 가장작은 단위인 Bit이기 때문에 연산중에서 Bit 연산이 제일 빠름
// - 물론 이전에 배운대로 0,1 값으로 산술연산을 하거나, 비교연산을 할 수 있지만 비트 연산을 통해 자리수를 옮길수도 있음
// - 이처럼 Bit의 자리수를 옮기는 것을 비트 연산이라고 합니다.
// '<< (왼쪽으로 자리수 옮기기), '>>' (오른쪽으로 자리수 옮기기)
// - 0,1 은 2진수 값이기 때문에,
// - 자리수를 왼쪽으로 옮기는 횟수만큼 2의 배수로 곱셉이 연산되는것과 동일합니다.
// - 자리수를 오른쪽으로 옮기는 횟수만큼 2의 배수로 나눗셈이 연산되는것과 동일합니다.
public class W10 {
public static void main(String[] args) {
System.out.println(3 << 2); // 0011 << 2만큼 이동시켜 1100 = 12
System.out.println(3 << 1); // 0011 << 1만큼 이동시켜 0110 = 6
}
}비트연산자의 해당하는 기본 예제입니다. 주석을 통해 문제를 해결하실 수 있습니다.
3. if문 (조건문)
Java 프로그래밍에서 특정 조건에 따라 다른 연산을 수행하고 싶을 때 조건문을 사용합니다.
또는, 특정 조건에 따라 반복해서 동일한 연산을 수행하고 싶을 때 반복문을 사용합니다.
-
조건문 : “물이 끓으면 강불에서 약불로 줄여주세요.”
- “물이 끓으면”이 조건이 만족하면 “약불로 줄이는” 연산을 수행하는 조건문입니다.
-
반복문 : “하얗게 색이 변하기 전까지 계속 저어주세요.”
- “하얗게 색이 변하기 전” 조건이 만족할 동안 “저어주세요” 연산을 반복하는 반복문입니다.
-
특정 조건에 따라 다른 연산을 수행하고 싶을 때 사용하는 문맥입니다.
-
기본적인 조건에 따른 연산을 수행하기 위해
if(조건){ 연산 }형태로 사용합니다. -
if의 소괄호() 안의 조건이 boolean 값 true를 만족하면 중괄호 {} 안의 연산을 수행합니다.
if문의 기본 예제
package week02;
public class W11 {
public static void main(String[] args) {
// boolean flag = true;
//
// if (1 != 1) {
// // ture인 경우
// System.out.println("값이 true입니다.");
// }
// else{
// // false인 경우
// System.out.println("값이 false입니다.");
// }
// 조건문
int number = 1;
if (number == 1) {
System.out.println("number값은 1입니다.");
} else if (number == 2) {
System.out.println("number값은 2입니다.");
} else {
System.out.println("number값은 모르는 값입니다.");
}
}
}if(조건문)의 기본 예제입니다. 조건에 따라 알맞은 값이 출력되도록 if, else if, else로 조건을 설정하면 그 조건에 맞게 결과값을 출력합니다.
package week02;
public class W12 {
public static void main(String[] args) {
// 중첩 if문
boolean flag = true;
int number = 2;
if (flag) {
if (number == 1) {
System.out.println("flag값은 true고, number값은 1입니다.");
} else if (number == 2) {
System.out.println("flag값은 true고, number값은 2입니다.");
} else {
System.out.println("flag값은 true고, number값은 모르겠습니다.");
}
} else {
if (number == 1) {
System.out.println("flag값은 false이고, number값은 1입니다.");
} else if (number == 2) {
System.out.println("flag값은 false이고, number값은 2입니다.");
} else {
System.out.println("flag값은 false이고, number값은 모르겠습니다.");
}
}
}
}if문 사이에 if문을 넣어 중첩 if문을 만들 수 있습니다.
System.out.println("flag값은 true고, number값은 2입니다."); 조건에 맞게 이 부분이 출력됩니다. for문을 작성 할 때는 습관이 중요한데
if(조건1) {
}else if (조건2) {
}else {이 형태를 많이 반복하고 숙달하는게 좋습니다. 그리고 else if의 경우 여러개 사용해도 무관하니 else문 이후 else if else if else if, else 이런식으로 구문을 작성 하시는게 좋습니다.
돌발 퀴즈 ! (중요)
Java에서 scanner를 사용 하려면 어떻게 해야 할까요?
정답 : main 단에 Scanner sc = new Scanner(System.in);
int passNum = sc.nextInt();
를 적고main단 위에 import java.util.Scanner;를 적어야 사용 가능합니다!
(추가 문제) 두 개의 값을 비교하는 메서드를 사용 할려면 어떻게 해야 할까요?
정답 : Objects.equals(좌, 우)를 사용해야 하고
main단 위에 import java.util.Objects;를 적어야 사용 가능합니다!
package week02;
import java.util.Objects;
import java.util.Scanner;
public class W13 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// A에게 값 입력 받기
System.out.println("A 입력 : ");
String aHand = sc.nextLine();
// B에게 값 입력 받기
System.out.println("B 입력 : ");
String bHand = sc.nextLine();
// 두 개의 값을 비교하는 메서드 -> Objects.equals(좌, 우) : 좌 우가 같은 경우 true, 다른경우 false
if (Objects.equals(aHand, "가위")) {
if (Objects.equals(bHand, "가위")) {
System.out.println("A와 B는 비겼습니다.");
} else if (Objects.equals(bHand, "바위")) {
System.out.println("B가 이겼습니다.");
} else if (Objects.equals(bHand, "보")) {
System.out.println("A가 이겼습니다.");
} else {
System.out.println("B가 이상한 값을 입력했습니다.");
}
} else if (Objects.equals(aHand, "바위")) {
if (Objects.equals(bHand, "가위")) {
System.out.println("A가 이겼습니다.");
} else if (Objects.equals(bHand, "바위")) {
System.out.println("A와 B는 비겼습니다.");
} else if (Objects.equals(bHand, "보")) {
System.out.println("B가 이겼습니다.");
} else {
System.out.println("B가 이상한 값을 입력했습니다.");
}
} else if (Objects.equals(aHand, "보")) {
if (Objects.equals(bHand, "가위")) {
System.out.println("B가 이겼습니다.");
} else if (Objects.equals(bHand, "바위")) {
System.out.println("A가 이겼습니다.");
} else if (Objects.equals(bHand, "보")) {
System.out.println("A와 B는 비겼습니다.");
} else {
System.out.println("B가 이상한 값을 입력했습니다.");
}
} else {
System.out.println("A가 이상한 값을 입력했습니다.");
}
}
}
위 스캐너와 오브젝트 이퀄스, if문을 사용하여 가위바위보 예제를 작성 할 수 있습니다.
4. switch문 (조건문)
switch 문은 case 문과 함께 사용하며 if문 보다 좀 더 가독성이 좋은 조건문 표현식입니다.
-
switch(피연산자){ case(조건): (연산) }이러한 형태로 많이 쓰입니다. -
switch 피연산자가case 조건을 만족하면case:뒤에 명시되어 있는 연산을 수행합니다. -
case(조건): (연산)은 여러 개를 설정할 수 있습니다.- 각 case의 연산문 마지막에는
break;를 꼭 넣어줘야 합니다!! break;문은 해당 case의 연산문이 끝났다는 것을 알려주어 switch 문을 종료시켜줍니다.
- 각 case의 연산문 마지막에는
-
차이점1. 복합 조건
- if 문은 복합 조건을 지원합니다.
- 복합 조건 : 괄호
()안에 조건 여러 개를 지정하여 조건문을 수행할 수 있습니다.
- 복합 조건 : 괄호
- switch 문은 피연산자 한 개에 대한 조건만 지원합니다.
- if 문은 복합 조건을 지원합니다.
-
차이점2. 코드 중복
- if 문은 상대적으로 코드 중복이 많습니다.
- switch 문은 코드 중복이 적습니다.
package week02;
public class W14 {
public static void main(String[] args) {
int month = 8;
String monthString = "";
// switch문
switch (month) {
//case~~~~ 연산
case 1:
monthString = "1월";
break;
case 2:
monthString = "2월";
break;
case 3:
monthString = "3월";
break;
case 4:
monthString = "4월";
break;
case 5:
monthString = "5월";
break;
case 6:
monthString = "6월";
break;
case 7:
monthString = "7월";
break;
case 8:
monthString = "8월"; //해당하는 값이므로 case 8이 실행됩니다.
break; // 출력결과는 8월 입니다 case가 실행되고 break를 만났으니 종료
case 9:
monthString = "9월";
break;
case 10:
monthString = "10월";
break;
case 11:
monthString = "11월";
break;
case 12:
monthString = "12월";
break;
default:
monthString = "알 수 없음";
}
System.out.println(monthString);
}
}
switch문의 기본 예제입니다. 각 case에 따라 해당하는 값에 경우 break가 되어 조건을 수행합니다. 하지만 break가 없으면 계속해서 진행됨으로 break를 사용해야합니다. 그리고 마지막 case문에는 default: 을 입력해 줘야합니다.
5. for문(반복문)
- 특정 조건에 따라 연산을 반복해서 수행하고 싶을 때 사용하는 문맥입니다.
for(초기값;조건문;증가연산){ (연산) }형태로 사용합니다.- 특정 조건은
초기값과조건문을 통해서 정의합니다. - 반복할 때마다 값을 증가시키려면
증가연산을 정의합니다. 초기값이조건문을 만족할 때까지(연산)을 수행하면서 회차마다증가연산을 수행합니다.
package week02;
public class W15 {
public static void main(String[] args) {
// for문
// (초기값 ; 조건문 ; 증가연산)
// for (int i =0; i < 4 ;i++) {
// System.out.print(i + " 번째 출력!");
// }
// 출력결과 : 0 1 2 3
// 향상된 for문
// 기존 : for문 안에 3개의 표현이 들아거죠 -> (초기값; 조건문 ; 증가연산)
// 향상된 for문 : 2개로 줄여줌 (변수 : 배열명)
// int[] numbers = {3, 6, 9, 12, 15};
// for (int number: numbers) {
// System.out.print(number + " ");
// }
// }
// 출력결과 : 3 6 9 12 15
int[] numbers = {3, 6, 9, 12, 15};
for (int i = 0; i < numbers.length; i++) {
System.out.print(numbers[i] + " ");
}
}
}
// 출력결과 : 3 6 9 12 15for문의 기본 예제입니다. for문은 무한루프에 빠지지않고 구문을 끝낼 수 있게 명확하게 조건문을 작성해야합니다.
6. while, do-while문(반복문)
- for 문과 동일하게 특정 조건에 따라 연산을 반복해서 수행하고 싶을 때 사용하는 문맥입니다.
- 다만, 초기값 없이 조건문만 명시하여 반복합니다.
while(조건문){ (연산) }형태로 사용합니다. (while 문)- 위처럼 while 문으로 사용하면 조건문을 만족해야지만 연산이 반복 수행됩니다.
- 한번 반복할 때마다 조건문을 체크해서 조건문이 불만족(false) 이면 반복을 중단합니다.
do { (연산) }while(조건문)형태로도 사용합니다. (do-while 문)- 위처럼 do-while 문으로 사용하면 최초 1회 연산 수행 후 조건문을 체크하여 더 반복할지 결정합니다.
- 반복하게 된다면 그 이후에는 한번 반복할 때마다 조건문을 체크해서 조건문이 불만족(false) 이면 반복을 중단합니다.
package week02;
public class W16 {
public static void main(String[] args) {
// int number = 0; //초기값 설정
//
// // number < 3 인 동안~~
// while (number < 3) {
//
// number++;
// System.out.println(number + "출력!");
// }
//
// 출력결과 : 1출력!
// 2출력!
// 3출력!
// do ~ while
// int number = 4;
// do {
// // 이 로직을 먼저 수행하겠다!
// System.out.println(number + "출력!"); // 따라서 4출력!이 선행이되어 출력되고
// } while (number < 3); // 조건이 넘어간 while문은 수행 되지 않는다.
//
// 출력결과 : 4출력!
// break(깨부시다)
// 가장 가까운 블록의 for문 또는 while, switch문을 중단!
// int number = 0;
// while (number < 3) {
// number++;
// if (number == 2) {
// break;
// }
// System.out.println(number + "출력!");
// }
//
// 출력결과 : 1출력!
// for (int i=0; i<10; i++){
// System.out.println("i:" + i);
// if(i == 2){
// break;
// }
// for (int j=0; j<10; j++){
// System.out.println("j:" + j);
// if(j == 2){
// break; //위 if문의 조건이 수행되면 if문을 빠져 나와 다시 상단부터 수행한다.
// }
// }
// }
//
//
//
// 출력결과 :
// i:0
// j:0
// j:1
// j:2
// i:1
// j:0
// j:1
// j:2
// i:2
// continue
int number = 0;
while (number < 3){
number++;
if (number == 2){
continue; //위 if문의 조건이 수행되면 수행하지않고 바로 하위 단을 실행한다.
}
System.out.println(number + "출력!");
}
}
}
// 출력결과 :
// 1출력!
// 3출력!while문과 do~while문에 해당하는 예제입니다. 추가로 break와 continue의 기능도 사용하여 작성 하였습니다.
package week02;
import java.util.Scanner;
public class W17 {
public static void main(String[] args) {
// 입력받는 단을 제외하고 출력
Scanner sc = new Scanner(System.in);
int passNum = sc.nextInt(); // 출력을 제외할 구구단수 값
// 구구단 작성
for (int i=2; i<=9; i++){
if (i == passNum){
continue;
}
for (int j=1; j<=9; j++){
System.out.println(i + "곱하기" + j + "는" +(i*j) +"입니다." );
}
System.out.println();
}
}
}for문과 if문을 적절히 사용하여 99단을 작성한 예시입니다. 조건문을 추가하여 출력하고싶지 않은 단은 생략 할 수 있도록 설정 하였습니다.
7. 배열
Java 프로그래밍에서 여러 개의 변수를 분류통 같은 곳에 모아서 저장하고 싶을 때 기본적으로는 “배열”이라는 변수에 저장(표현) 합니다.
분류통이라고 표현한 이유는 여러 개의 값들을 한꺼번에 넣거나 하나씩 넣을 수도 있고, 꺼낼 때는 하나씩 꺼낼 수 있기 때문입니다.
즉, 변수들을 담을 수 있는 분류통 중에서 가장 기본이 되는 분류통이 배열입니다. 배열 = []
참고로, 분류통은 자료구조라는 이름으로 불립니다
형식 : int[] intArray = new int[3]; // 초기값 {0,0,0}
타입 [] 변수 = new (변수의 크기)
추가로, 배열은 생성될 때 각 타입별 초기값으로 초기화되어 채워집니다.
- 예를 들어, int는 0, boolean 은 false, String 은 null 값과 같은 초기값이 정해져 있습니다.
package array;
public class Arr01 {
public static void main(String[] args) {
// 배열 생성
int [] intArray = new int[3]; // {0,0,0}
boolean[] boolArray= new boolean[3]; // {false, false, false}
String[] stringArray = new String[3]; //{"", "", ""}
// 배열 선언 먼저! -> 나중에 초기화
int [] intArray2;
intArray2 = new int[3]; // {0, 0, 0}
// 생성한 배열을 '순회' -> 배열의 값을 하나씩 뽑아서 조회한다.
// (1) 단건 조회
System.out.println(intArray[1]);
System.out.println("-----------");
// (2) 다건 조회(important!)
// length : 길이를 구하는 메서드
for (int i=0; i<intArray.length; i++){
System.out.println(intArray2[i]);
}
}
}배열의 기본 형식에 대해 설명하고 있습니다. 새로운 메서드인 length을 사용하여 for문의 범위를 정할 수 있고, 배열을 생성 했을 때 기본적으로 들어가는 초기값에 대한 예제입니다.
package array;
import java.util.Arrays;
public class Arr02 {
public static void main(String[] args) {
// 초기화
// 1. 배열에 특정값 대입해서 선언
// int[] intArr = {10, 20, 30, 40, 50};
// String[] stringArray = {"a", "b", "c", "d"};
// 2. for문을 통해서 대입
// for (int i = 0; i < intArr.length; i++) {
// intArr[i] = i;
// }
// 다건 출력
// for (int i = 0; i < intArr.length; i++) {
// System.out.println(intArr[i]);
// }
출력결과 :
10
20
30
40
50
// 향상된 for문을 사용한 배열
// int[] intArr = {10, 20, 30, 40, 50};
//
// for (int item: intArr) {
// System.out.println(item);
// }
출력결과 :
10
20
30
40
50
// 배열의 주소를 모두 같은 값으로 초기화
int[] intArr = {10, 20, 30, 40, 50};
Arrays.fill(intArr, 1);
for (int item: intArr){
System.out.println(item);
}
}
}
출력결과 :
1
1
1
1
1배열의 특징에 따라 다건 출력을 할 수 있게 하는 방법과 향상된 for문을 사용하여 배열을 출력하는 방법, 배열의 주소를 같은 값으로 초기화하는 배열의 예제입니다.
package array;
public class Arr03 {
public static void main(String[] args) {
// 얕은 복사의 예
// int[] a = {1, 2, 3, 4};
// int[] b = a;
//
// b[0] = 3; //b를 바꾸면 a의 값이 변경이된다.
//
// System.out.println(a[0]);
// 출력결과 : 3
// 깊은 복사
// int[] a = { 1, 2, 3, 4 };
// int[] b = new int[a.length];
//
// for (int i = 0; i < a.length; i++) {
// b[i] = a[i]; // 깊은 복사
// }
//
// b[0] = 3; // b 배열의 0번째 순번값을 3으로 수정했습니다. (1 -> 3)
//
// System.out.println(a[0]); // 출력 1 <- 깊은 복사를 했기때문에 a 배열은 그대로 입니다.
// 츨력결과 : 1
}
}
얕은 복사와 깊은 복사의 기본 예제 입니다.
package array;
import java.util.Arrays;
public class Arr04 {
public static void main(String[] args) {
int[] a = { 1, 2, 3, 4 };
int[] b = Arrays.copyOf(a, a.length);
a[3] = 0;
System.out.println(a[3]); // Arrays.copyOf(a, a.length); 으로 인해 a는 값이 변경되었지만
System.out.println(b[3]); // b는 변경되지 않음
}
}Arrays.copyOf(a, a.length);을 사용하여 배열의 부분만 편집 할 수 있는 예제 입니다.
package array;
public class Arr05 {
public static void main(String[] args) {
//문자(char / 1byte), 문자열(string)
// string = char[]
// 기본형 변수 vs 참조형 변수
// 1. 기본형 변수는 소문자로 시작, 반면 참조형 변수는 대문자로 시작함
// -Wrapper class에서 기본형 변수를 감싸줄 때(boxing), int -> Integer
// 2. 기본형 변수는 값을 자체를 저장, 참조형 변수는 별도의 공간에 값을 저장 후 그 주소를 재정의함(= 주소형 변수)
// char < String(훨씬 더!)
// string 가지고 있는 기능이 너무 많아서...!!!!!
// Wrapper class와도 상당히 비슷..! -> 기본형 변수가 가지고 있는 기능이 제한 -> 다양한 기능을 제공하는 wrapper을 감행으로써, 추가기능을 더함
//String 기능 활용 에시
String str = "ABCD";
// (1) length
int strLength = str.length(); // 문자열의 길이를 출력
System.out.println(strLength); // 출력결과 : 4
// (2) charAt(int index)
char strChar = str.charAt(1); // 문자열의 1번째 값 출력
System.out.println(strChar); // 출력결과 : B
// (3) substring(int fromIdx, toIdx)
String strSub = str.substring(0, 3); // 0~3 전까지의 문자열을 출력한다.
System.out.println(strSub); // 출력결과 : ABC
// (4) equals(string shr)
String newStr = "ABCD";
boolean strEqual = newStr.equals(str);
System.out.println(strEqual); // 출력결과 : ture
// (5) toCharArray() : String -> char[]
char[] strCharArray = str.toCharArray();
// (6) 반대로 char[] -> string -> char
char[] charArray = {'A','B','C'};
String CharArryString = new String(charArray);
System.out.println(CharArryString); // ABC
}
}
기본형 변수와 참조형 변수를 사용하는 스트링 배열의 기본 예제입니다.
8. 다차원 배열
package array;
public class Arr06 {
public static void main(String[] args) {
// 반복문을 통한 초기화
int[][] array = new int[2][3]; // 최초 선언
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println("출력값 =>" + i + "," + j);
array[i][j] = 0; // i, j 는 위 노란색 네모박스 안에있는 숫자를 의미하며 인덱스 라고 부릅니다.
// 출력결과 :
// 출력값 =>0,0
// 출력값 =>0,1
// 출력값 =>0,2
// 출력값 =>1,0
// 출력값 =>1,1
// 출력값 =>1,2
}
}
}
}반복문을 통해 다차원 배열을 생성하는 기본 예제 입니다.
package array;
//
public class Arr07 {
// public static void main(String[] args) {
// 가변배열
// int[][] array = new int[3][]; // [] 이부분을 비워 가변배열로 생성
// 배열 원소마다 각기 다른 크기로 지정
// array[0] = new int[2];
// array[1] = new int[4];
// array[2] = new int[1];
// 중괄호로 초기화를 아예 해버릴 때도 가능함!!
// int[][] array2 = {
// {10, 20}
// {10, 20, 30, 40}
// {10}
// }
// }
//}
}가변배열의 기본 예제입니다.
package array;
public class Arr08 {
public static void main(String[] args) {
// 최대값 구하기
int[] arr = {3, 2, 1, 5, 1};
// 최대값 초기화 세팅
int max = arr[0];
// 최대값 구하기 로직
for (int num: arr){
if (num > max){
max = num;
}
}
System.out.println("최대값은 =>" + max);
}
}배열을 통해 최대값을 출력할 수 있는 예제 입니다.
9. 컬렉션
- Java에서 컬렉션 은 배열보다 다수의 참조형 데이터를 더 쉽고 효과적으로 처리할 수 있는 기능을 많이 가지고 있습니다.
- 컬렉션 기능 : 크기 자동 조정/ 추가/ 수정/ 삭제/ 반복/ 순회/ 필터/ 포함 확인 등….
- 컬렉션 종류
Collection에는List,Set,Queue,Map이 있습니다.List: 순서가 있는 데이터의 집합 (데이터 중복 허용) - 배열과 비슷Queue: 빨대처럼 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합- First In First Out : 먼저 들어간 순서대로 값을 조회할 수 있다.
Set: 순서가 없는 데이터의 집합 (데이터 중복 허용 안 함) - 순서 없고 중복 없는 배열Map: 순서가 없는 (Key, Value) 쌍으로 이루어진 데이터의 집합 (Key값 중복 허용 안 함)
(1) List
-
리스트 선언 방법
import java.util.ArrayList;
ArrayList inList = new ArrayList(); -
linked 리스트 선언 방법
import java.util.LinkedList;
LinkedList LinkedList = new LinkedList();
public class Col1 {
public static void main(String[] args) {
// List
// 순서가 있는 데이터의 집합 => Array(최초 길이를 알아야 함)
// 처음에 길이를 몰라도 만들 수 있음!
// 1) Array -> 정적 배열
// 2) List(ArrayList) -> 동적배열(크기가 가변적으로 늘어난다.)
// - 생성 시점에 작은 연속된 공간을 요청해서 참조형 변수들을 담아놓는다.
// - 같이 추가될 때 더 큰 공간이 필요하면 더 큰 공간을 받아서 저장하니깐. 상관없다!!
ArrayList<Integer> intList = new ArrayList<Integer>(); // 선언 + 생성
intList.add(99);
intList.add(15);
intList.add(3);
System.out.println(intList.get(2));
// 2번째 있는 값(15)을 바꿔보자.
intList.set(1, 10); //1번 배열의 있는 값은 10으로 변경
System.out.println(intList.get(1)); //따라서 1번 배열에 있는 10이 출력됨
// 삭제
intList.remove(0); // 0번 배열의 있는 값을 삭제한다.
System.out.println(intList.get(0)); // 따라서 실행하면 1번 인덱스에 있는 값이 출력됨
// 클리어
System.out.println("클리어 전");
System.out.println(intList.toString());
System.out.println("클리어 후");
intList.clear(); // 리스트의 모든 값을 초기화 한다.
System.out.println(intList.toString()); // toString은 리스트의 현재 상태를 보여주는 명령어
}
}컬렉션의 기능 및 세팅 방법에 대한 예제 입니다.
출력결과 :
package collection;
import java.util.LinkedList;
public class Col2 {
public static void main(String[] args) {
// linked list
// 메모리에 남는 공간을 요청해서 여기 저기 나누어서 실제 값을 담아놔요.
// 실제 값이 있는 주소값으로 목록을 구성하고 저장하는 자료구조.
// 기본적 기능은 -> ArrayList와 동일!
// LinkedList는 값 -> 여기 저기 나누어서 : 조회하는 속도가 "느리다..."
// 값을 추가하거나, 삭제할 때는 빠릅니다.
LinkedList<Integer> linkedList = new LinkedList<Integer>();
linkedList.add(5);
linkedList.add(10);
linkedList.add(3);
System.out.println(linkedList.get(0));
System.out.println(linkedList.get(1));
System.out.println(linkedList.get(2));
System.out.println(linkedList.toString()); // 이렇게 조합할 때는 arraylist보다 속도가 현저히 느리다.
linkedList.add(200); // 추가하면 맨 뒤 배열에 추가가 됩니다.
System.out.println(linkedList.toString());
linkedList.add(2, 4); // 2번 배열의 값이 있는데 추가하면 2번 자리에 값이 추가되고 기존 2번부터 끝까지 다른 값을 밉니다.
System.out.println(linkedList.toString());
linkedList.set(1, 30); //수정
System.out.println(linkedList.toString());
linkedList.remove(1);
System.out.println(linkedList.toString());
linkedList.clear();
System.out.println(linkedList.toString());
}
}
Linked 컬렉션의 기능 및 세팅 방법에 대한 예제입니다.
출력결과 :
(2) Stack
package collection;
import java.util.Stack;
public class Col3 {
public static void main(String[] args) {
// Stack
// 수직으로 값을 쌓아놓고, 넣었다가 뺀다. FIFO(Basket)
// push, peak, pop
// 최근 저장된 데이터를 나열하고 싶거나, 데이터의 중복 처리를 막고 싶을 때 사용
Stack<Integer> intStack = new Stack<Integer>(); // 선언 및 생성
intStack.push(10); // 스택의 형식으로 처음에 추가한 것이 가장 마지막에 출력됨
intStack.push(15);
intStack.push(1);
// 다 지워질 때 까지 출력
while(!intStack.isEmpty()){
System.out.println(intStack.pop());
}
// 다시 추가
intStack.push(10);
intStack.push(15);
intStack.push(1);
// peek
System.out.println(intStack.peek());
System.out.println(intStack.size());
}
}스택의 기본 예제 입니다.
출력결과 :
(3) Queue
package collection;
import java.util.LinkedList;
import java.util.Queue;
public class Col4 {
public static void main(String[] args) {
// Queue : FIFO
// add, peek, poll
// Queue : 생성자가 없는 인터페이스 <-
Queue<Integer> intQueue = new LinkedList<>(); // queue를 선언, 생성
intQueue.add(1); //큐의 형식으로 처음에 추가한 것이 가장 처음에 출력됨
intQueue.add(5);
intQueue.add(9);
while (!intQueue.isEmpty()) {
System.out.println(intQueue.poll());
}
intQueue.add(1);
intQueue.add(5);
intQueue.add(9);
intQueue.add(10);
// peek
System.out.println(intQueue.peek());
System.out.println(intQueue.size());
}
}
큐의 기본 예제입니다.
출력결과 :
(4) Set(집합)
package collection;
import java.util.HashSet;
import java.util.Set;
public class Col5 {
public static void main(String[] args) {
// Set(집합) : 순서 없고, 중복 없음!!
// 순서가 보장되지 않는 대신 중복을 허용하지 않도록 하는 프로그램에서 사용할 수 있는 자료구조
// Set -> 그냥 쓸 수도 있음. 그러나, HashSet, TreeSet 등으로 응용해서 같이 사용 가능
// Set은 생성자가 없는 껍데기라서 바로 생성 할 수 없음!!!
// 생성자가 존재하는 HashSet을 이용해서 -> Set을 구현해 볼 수 있음!!
Set<Integer> intSet = new HashSet<Integer>(); // 선언 및 생성
intSet.add(1);
intSet.add(12);
intSet.add(5);
intSet.add(9);
intSet.add(1);
intSet.add(12);
for (Integer value: intSet){
System.out.println(value);
}
//contains
System.out.println(intSet.contains(2));
System.out.println(intSet.contains(5));
}
}
Set의 기본 예제입니다.
(5) Map
package collection;
import java.util.HashMap;
import java.util.Map;
public class Col6 {
public static void main(String[] args) {
// Map : key - value pair -> 중요!
// key라는 값으로 unique하게 보장이 되야 함
// Map -> HashMap, TreeMap으로 응용!
Map<String, Integer> intMap = new HashMap<>();
// 키 값
intMap.put("일", 11);
intMap.put("이", 12);
intMap.put("삼", 13);
intMap.put("삼", 14); // 중복 key
intMap.put("삼", 15); // 중복 key
intMap.put("삼", 16); // 중복 key
// key 값 전체 출력(향상된 for문)
for (String key : intMap.keySet()) {
System.out.println(key);
}
// value 값 전체 출력(향상된 for문)
for (Integer key : intMap.values()) {
System.out.println(key);
}
System.out.println(intMap.get("삼"));
}
}
Map의 기본 예제입니다.
10. 최종 문제
1) 자료구조 요리 레시피 메모장 만들기
입력값 :
저장할 자료구조명을 입력합니다. (List / Set / Map)
내가 좋아하는 요리 제목을 먼저 입력합니다.
이어서 내가 좋아하는 요리 레시피를 한 문장씩 입력합니다.
입력을 마쳤으면 마지막에 “끝” 문자를 입력합니다.
2) 작성한 코드
package array;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Arr09 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Set<String> stringSet = new HashSet<>(); // 문자열을 저장할 수 있는 Set
System.out.print("제목 입력 : ");
String title = sc.nextLine(); // 제목을 입력 받는다.
System.out.println("제목: " + title);
System.out.println("추가할 요리 레시피를 한 문장씩 입력해 주세요 ('끝' 입력 시 종료):");
while (true) { //반복문을 시작한다.
String recipe = sc.nextLine(); // 한 줄 입력받기
if (recipe.equals("끝")) {
break; // "끝" 입력 시 종료
}
stringSet.add(recipe); // Set에 입력받은 문자열 추가
}
System.out.println("저장된 요리 레시피:");
System.out.println(stringSet); // Set에 저장된 문자열 출력
}
}3) 출력결과
4) 최종 회고
다양한 예제를 보며 풀 수 있는 문제가 많았지만 int,string 등 과 같은 형식에 따라 스캐너, 배열 선언부터 막 힐 수 있다고 느꼈습니다. 따라서, 스캐너와 배열의 형식에 따라 외워야 할 점을 모아 봤습니다.
Set<Integer>는 정수형 데이터만 저장할 수 있는 Set이므로,
add() 메서드에 숫자(Integer 타입)만 추가할 수 있습니다.
Set<String>은 문자열 데이터만 저장할 수 있는 Set이므로,
add() 메서드에 문자열(String 타입)만 추가할 수 있습니다
nextInt(), nextDouble() 등은 특정 타입의 값을 읽거나 공백 이전의 단어 하나만을 읽습니다.
nextLine(): 사용자 입력으로 “치킨 파스타 레시피”와 같은 제목을 받을 때, 이 문장 전체를 한 줄로 읽어옵니다.
next(): 공백이 있으면 첫 단어까지만 읽습니다. 예를 들어, “치킨 파스타 레시피”를 입력하면 “치킨”만 읽습니다.
따라서 "제목 입력"처럼 한 줄 전체로 받는 게 더 자연스러운 경우에는 nextLine()을 사용합니다.
반갑습니다.