package etc;
import java.text.SimpleDateFormat;
import java.util.Date;
publicclassTimeClass01{
publicstaticvoidmain(String[] args){
long time = System.currentTimeMillis();
System.out.println( time ); // 1708317469108// 시간을 가져온 값을 사람이 확인할 수 있게 포맷팅 해야함// SimpleDataFormat 클래스를 선언하여 형식을 지정
SimpleDateFormat si = new SimpleDateFormat("yyyy년 MM월 dd일 aa hh시 mm분 ss초");
// 객체화할때 포맷할 시간을 넣어주면 String 형태로 시간이 반환된다
String s = si.format(time);
System.out.println(s);
// 2024년 02월 19일 오후 01시 40분 33초// Date 라는 클래스로도 시간을 불러올 수 있다
Date date = new Date();
System.out.println(date); // Mon Feb 19 13:40:33 KST 2024
System.out.println(si.format(date)); // 동일하게 포맷팅을 사용할 수 있다// 2024년 02월 19일 오후 01시 40분 33초
}
}
시간을 불러와서 사용할 수 있는 클래스
Tread.sleep()
package etc;
import java.util.Date;
publicclassSleepClass01{
publicstaticvoidmain(String[] args){
for( int i=0; i<5; i++ ) {
System.out.println(i + " : " + new Date());
try {
Thread.sleep( 2000 ); // 2 초를 기다렸다가 다음 코드를 진행
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("시작");
long start = System.currentTimeMillis();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("종료");
System.out.println("사용 시간 : " + (end - start) / 1000);
}
}
package constructor;
classTestClass01{
publicTestClass01(){
// 생성자는 객체를 만들때 자동으로 호출
System.out.println("생성자 실행");
}
publicvoidtest(){
System.out.println("test 호출");
}
}
publicclassEx01{
publicstaticvoidmain(String[] args){
// 객체 생성, 생성자가 호출되어 자동으로 실행된다// "생성자 실행" 문구 출력
TestClass01 t = new TestClass01();
}
}
생성자는 객체가 생성될때 자동으로 호출된다
package constructor;
classTestClass02{
private String officeName;
// 생성자publicTestClass02(String officeName){
System.out.println("생성자 실행");
this.officeName = officeName;
// 생성자에서 초기화
}
// setterpublicvoidsetOfficeName(String officeName){
this.officeName = officeName;
}
// getterpublic String getOfficeName(){
returnthis.officeName;
}
}
publicclassEx02{
publicstaticvoidmain(String[] args){
String name = "나의 회사";
TestClass02 t = new TestClass02(name);
// 객체를 만들때 생성자가 자동으로 호출,,,,,// officeName 이 생성자의 코드에서 초기화 됨 - 생성자는 초기화하는 목적으로 사용// ( 즉, setter 를 사용할 필요가 없음 )// t.setOfficeName(name); // setter 호출
System.out.println(t.getOfficeName()); // getter 호출
}
}
생성자를 사용하는 이유
package constructor;
classTestClass03{
private String name, addr;
privateint age;
// 생성자 선언// setter 를 사용하지 않고 생성자를 통해 초기화publicTestClass03(String name, String addr, int age){
this.name = name;
this.addr = addr;
this.age = age;
System.out.println("생성자를 통한 초기화");
}
// getter / setter 생성public String getName(){
return name;
}
publicvoidsetName(String name){
this.name = name;
}
public String getAddr(){
return addr;
}
publicvoidsetAddr(String addr){
this.addr = addr;
}
publicintgetAge(){
return age;
}
publicvoidsetAge(int age){
this.age = age;
}
}
publicclassEx03{
publicstaticvoidmain(String[] args){
TestClass03 t = null; // = new TestClass03();// System.out.println(t);// t.setAddr("aaa");
String name = "홍길동";
String addr = "산골짜기";
int age = 20;
t = new TestClass03(name, addr, age);
// t.setName(name);// t.setAddr(addr);// t.setAge(age);
System.out.println("이름 : " + t.getName());
System.out.println("주소 : " + t.getAddr());
System.out.println("나이 : " + t.getAge());
}
}
setter 를 사용하면 멤버변수의 갯수가 많아지면 많아질수록 코드가 길어지는데, 이때 생성자를 사용하여 간단하게 초기화를 시킬 수 있다
생성자 오버로딩
package constructor;
classTestClass04{
publicTestClass04(int num){
System.out.println("매개변수 받는 생성자");
}
// 생성자를 선언하는 순간 기본 생성자는 자동으로 소멸되기 때문에// 생성자를 선언 후 기본 생성자가 필요하다면 따로 선언해줘야 한다publicTestClass04(){
System.out.println("기본 생성자 실행");
}
// 메소드 오버로딩publicvoidtest(){
System.out.println("test 호출");
}
publicvoidtest(int num){
System.out.println(num + " test 호출");
}
}
publicclassEx04{
publicstaticvoidmain(String[] args){
TestClass04 t = null;
t = new TestClass04(20); // 매개변수 받는 생성자
t = new TestClass04(); // 기본 생성자 실행// 오버로딩된 메소드 호출// t.test(); // test 호출// t.test(20); // 20 test 호출
}
}
생성자를 선언하면 기본 생성자는 소멸하기 때문에 무조건 기본 생성자는 선언해주는 것이 오류 예방에 좋다
package this_;
classTest01{
publicint num = 12345;
publicvoidtest(){
int num = 303030;
System.out.println("this : " + this); // this 는 자기 자신에 대한 정보를 의미 ( 클래스의 위치 )
System.out.println("this : " + this.num); // 12345
System.out.println("num : " + num); // 303030// this 를 사용하지 않으면 현재 지역에서 먼저 해당 값을 찾아서 출력한다// this 를 사용하면 자신 클래스 위치에서 부터 해당 값을 찾아서 하위로 내려온다
}
}
publicclassEx01{
publicstaticvoidmain(String[] args){
Test01 t = new Test01();
System.out.println(" main : " + t); // Test01 클래스가 저장되어 있는 위치 값 반환
System.out.println("main num : " + t.num); // Test01 클래스 하위의 num 메소드를 반환하여 실행
t.test(); // Test01 클래스가 저장되어 있는 위치로 접근하여 해당 클래스 하위의 test() 메소드를 실행// this : this_.Test01@2133c8f8// this : 12345// num : 303030
}
}
this 의 사용법과 의미
은닉화
package set_get;
classTest01{
// 접근 제어자 private 을 사용하여 인스턴스 변수 num 을 은닉화 시킴 ( 외부 접근을 허용하지 않음 )privateint num = 12345;
publicvoidtest(int n){
// private 은 외부에서는 접근이 불가하지만 내부에서는 접근이 가능!!!
num = n;
}
publicinttest2(){
return num;
}
}
publicclassEx01{
publicstaticvoidmain(String[] args){
Test01 t = new Test01();
t.test(1000); // 인스턴스 변수인 num 에 직접 접근하지는 못하지만 메서드를 이용하여 같은 클래스에 접근하여 값을 변경
System.out.println(t.test2()); // 마찬가지로 출력도 메서드를 사용하여 private 값에 접근하여 값을 출력
}
}
은닉화 하는 방법
( 은닉화의 문제점은 값에 접근하고 값을 가져오는데 최소 메소드가 2개씩 필요..... 메소드를 많이 만들다보니 메소드의 이름이 규격화되지 않아 헷갈리게 된다...... )
( getter / setter 를 사용하여 해당 메소드를 규격화 하였음....!!! )
getter / setter
package set_get;
classTest02{
privateint num, age; // 접근 제어자 private 을 사용하여 외부에서 접근을 금지publicvoidsetNum(int n){ // set
num = n;
}
publicintgetNum(){ // getreturn num;
}
publicvoidsetAge(int a){ // set
age = a;
}
publicintgetAge(){ // getreturn age;
}
}
publicclassEx02{
publicstaticvoidmain(String[] args){
Test02 t = new Test02();
t.setNum(3); // set 을 사용하여 priavte 인스턴스 변수에 접근 및 변경
t.setAge(20); // set 을 사용하여 priavte 인스턴스 변수에 접근 및 변경int num = t.getNum(); // get 을 사용하여 인스턴스 변수에 접근int age = t.getAge(); // get 을 사용하여 인스턴스 변수에 접근
System.out.println(num + ", " + age); // 3, 20 출력
}
}
get / set 메소드 생성 및 사용
package set_get;
classTest02{
privateint num, age; // 접근 제어자 private 을 사용하여 외부에서 접근을 금지publicintgetNum(){
return num;
}
publicvoidsetNum(int num){
this.num = num;
// this 를 사용하여 최상단 자기 자신의 클래스부터 num 이라는 변수를 찾아서 사용// this.num 을 사용함으로써 클래스 내의 인스턴스 변수인 num 을 의미한다고 명시// 이후 우항의 num 은 매개변수로 받아온 num 이 대입된다
}
publicintgetAge(){
return age;
}
publicvoidsetAge(int age){
this.age = age;
// this 를 사용하여 최상단 자기 자신의 클래스부터 num 이라는 변수를 찾아서 사용// this.age 을 사용함으로써 클래스 내의 인스턴스 변수인 age 를 의미한다고 명시// 이후 우항의 age 는 매개변수로 받아온 age 가 대입된다
}
}
publicclassEx02{
publicstaticvoidmain(String[] args){
Test02 t = new Test02();
t.setNum(3); // setter 를 사용하여 priavte 인스턴스 변수에 접근 및 변경
t.setAge(20); // setter 를 사용하여 priavte 인스턴스 변수에 접근 및 변경int num = t.getNum(); // getter 를 사용하여 인스턴스 변수에 접근int age = t.getAge(); // getter 를 사용하여 인스턴스 변수에 접근
System.out.println(num + ", " + age); // 3, 20 출력
}
}
java 는 getter / setter 를 자동 생성할때 setter 의 매개변수를 실제 변수의 이름으로 생성하게 되는데 이때, 변수명이
서로 같아지게 되므로 this 를 사용하여 자신이 속한 클래스의 인스턴스 변수임을 선언하여 사용한다.
package overloading;
classTestClass01{
publicvoidsumFunc(){
System.out.println("매개변수 없는 sumFunc");
}
publicvoidsumFunc(int a, int b){
System.out.println("매개변수가 있는 sumFunc");
System.out.println(a + b);
}
publicvoidsumFunc(String a, String b){
System.out.println(a + b);
}
}
publicclassEx01{
publicstaticvoidmain(String[] args){
TestClass01 t= new TestClass01();
t.sumFunc(); // 매개변수가 존재하지 않는 sumFunc 메소드를 호출
t.sumFunc(10, 20); // int 자료형 두 개가 매개변수로 존재하는 sumFunc 메소드를 호출
t.sumFunc("안녕", "하세요"); // String 자료형 두 개가 매개변수로 존재하는 sumFunc 메소드를 호출
}
}
매개변수의 갯수에 따라 동일한 메소드 명이라고 하더라도 호출되는 메소드가 다르다
( 만약 오버로딩이 불가능하다면, 동작은 동일하게 하지만 매개변수의 숫자가 달라질때마다 메소드의 이름을 계속 다르게 생성해야하기 때문에 오버로딩을 사용한다 )
변수의 종류
변수의 종류
package variable;
classTest01{
publicinttest1(){ // test1 범위 생성int num = 100; // test1 의 지역변수
System.out.println("test1 : " + num);
return num;
}
publicvoidtest2(int num){ // test2 범위 생성
System.out.println("num : " + num);
}
}
publicclassEx01{
publicstaticvoidmain(String[] args){
Test01 t = new Test01();
int a = t.test1(); // test1 메소드의 지역변수를 return 값으로 받아와서 변수에 저장
t.test2(a); // 저장한 변수를 test2 메소드에 매개변수로 전달하여 사용
String name = "홍길동"; // main 의 지역 변수if(true) {
String n = "1111"; // if 문의 지역 변수
name = "김개똥";
}
// main > if// if 문의 지역 변수를 main 에서 사용할 수 없기 때문에 오류 발생// System.out.println(n);
System.out.println(name);
}
}
지역변수와 변수의 범위
package variable;
classTest02{
publicint num; // 인스턴스 변수 선언publicvoidtest1(){
num = 100; // 인스턴스 변수의 값을 변경 ( 같은 클래스 내에서 가능 )
System.out.println("test1 : " + num);
}
publicvoidtest2(){
// 상위의 num 이라는 클래스 변수가 존재하기 때문에 해당 변수 num 을 사용
System.out.println("test2 : " + num);
}
}
publicclassEx02{
publicstaticvoidmain(String[] args){
Test02 t = new Test02();
// 객체를 생성할때는 클래스 변수, 인스턴스 변수, 메소드 명을 가지고 객체가 생성된다// 이때 생성된 객체는 상속받은 클래스의 메소드 내의 지역변수는 가지고 태어나지 않으며// 클래스 변수와 메소드 명만 가지고 태어난 후 메소드를 사용할 때// 메소드 내에 선언된 지역변수를 호출하여 사용한뒤 메소드 사용이 끝나면 해당 지역변수는// 다시 폐기처리된다.
t.test1();
t.test2();
}
}
클래스 변수와 지역변수의 차이
package variable;
publicclassVariable{
int instanceVariable; // 인스턴스 변수 - 클래스를 호출하여 인스턴스화 시켜야 사용할 수 있다staticint classVariable; // 클래스 변수 - 클래스를 호출하여 인스턴스화 시키지 않아도 사용할 수 있다publicintmethod(){
int localVariable = 0; // 지역 변수 - 메소드가 실행될때 사용할 수 있다return localVariable;
}
publicstaticvoidmain(String[] args){
// 클래스 변수는 객체를 호출하여 인스턴스화 하지 않아도 바로 사용이 가능하다
Variable.classVariable = 1;
System.out.println(Variable.classVariable);
// 인스턴스 변수는 객체를 호출하여 인스턴스화 해야 사용이 가능하다
Variable variableTest = new Variable();
variableTest.instanceVariable = 2; // 인스턴스화 한 뒤에야 변수 호출이 가능
System.out.println(variableTest.instanceVariable);
// int num = variableTest.method();
System.out.println(num);
}
}
인스턴스 변수, 클래스 변수, 지역 변수의 차이
객체 - 틀
인스턴스 - 틀로 찍어낸 상품
클래스 변수는 인스턴스화 시키지 않아도 클래스에 접근할 수 있으면 호출할 수 있는 변수이다.
인스턴스 변수는 객체를 호출하여 인스턴스화 시킨 뒤 호출할 수 있는 변수이다.
즉, 인스턴스 변수는 같은 클래스 내에서는 바로 접근이 가능하기 때문에 같은 클래스 내부의 메소드에서 많이 사용되는 변수의 경우
인스턴스 변수로 선언하여 사용하며, 클래스 변수는 다른 파일들에서 동일한 변수 값을 많이 사용해야하는 경우 클래스 호출만으로
변수를 사용하기 위해 사용된다.
package variable;
classTest04{
publicint num; // 인스턴스 변수publicstatic String msg = "연습"; // 클래스 변수
}
publicclassEx04{
publicstaticvoidmain(String[] args){
System.out.println("변경 전 : " + Test04.msg); // 클래스 변수 호출
Test04.msg = "1111"; // 클래스 변수 변경
System.out.println(Test04.msg); // 변경된 클래스 변수 호출
Test04 t = new Test04(); // 인스턴스 생성
t.num = 100; // 인스턴스 변수 호출 및 변경
}
}
클래스 변수와 인스턴스 변수
클래스 변수와 인스턴스 변수
package variable;
classTest07{
publicstaticfinal String KOREA = "대한민국";
publicstaticint num;
static {
num = 12345;
}
}
publicclassEx07{
publicstaticvoidmain(String[] args){
System.out.println(Test07.KOREA);
System.out.println(Test07.num);
// final 로 KOREA 변수 값을 상수화 시켰기 때문에 변경 불가// Test07.KOREA = "미국";
}
}
static - 호출하지 않아도 미리 생성
final - 상수화
실습 예제
실습 예제
예제 풀이
package variable;
publicclassMainClass{
publicstaticvoidmain(String[] args){
TestClass test = new TestClass();
test.input();
test.operate();
test.printData();
}
}
MainClass
package variable;
import java.util.Scanner;
publicclassTestClass{
public String name, grade;
publicint kor, eng, math, sum;
publicdouble avg;
// 입력 메소드publicvoidinput(){
Scanner sc = new Scanner(System.in);
System.out.print("이름을 입력하세요 : ");
name = sc.next();
System.out.print("국어 점수를 입력하세요 : ");
kor = sc.nextInt();
System.out.print("영어 점수를 입력하세요 : ");
eng = sc.nextInt();
System.out.print("수학 점수를 입력하세요 : ");
math = sc.nextInt();
}
// 연산 메소드publicvoidoperate(){
sum = kor + eng + math;
avg = (double)sum / 3;
if(avg > 90) grade = "A";
elseif(avg > 80) grade = "B";
else grade = "C";
}
// 출력 메소드publicvoidprintData(){
System.out.println("이름 : " + name);
System.out.printf("국 : %d, 영 : %d, 수 : %d\n", kor, eng, math);
System.out.println("합 : " + sum);
System.out.println("평균 : " + avg);
System.out.println("등급 : " + grade);
}
}
같은 패키지 내의 TestCalss01 클래스를 tc 라는 객체에 담아서 해당 클래스 내의 변수를 사용한다생성된 tc 객체의 변수를 불러와서 사용한 모습TestClass01 클래스 내 age 변수의 접근 제한자를 private 으로 변경하니 같은 패키지내에서도 접근이 불가 ( private 은 같은 클래스 내에서만 접근이 가능하다 )
메소드 ( method )
메소드 ( method )
TestClass02 클래스를 MainClass02 클래스에서 객체로 생성하여 TestClass02 클래스의 메소드를 사용
TestClass03 클래스를 TestClass03 자료형의 t 라는 객체로 생성하여 해당 객체의 .test() 메소드를 실행
sumFunc 메소드를 실행할 때 main 에서 입력받은 num 값을 sumFunc 메소드로 전달하여 코드를 진행한뒤 출력
반환 타입을 int 로 변경하여 return 으로 int 값을 main 으로 다시 넘겨준 모습
메소드를 사용할때 입력과 출력(return)의 자료형을 잘 맞춰주는 것이 중요하다
입력, 연산, 출력 부분을 모두 메소드화 시킨 모습
void 는 return 값이 존재하지 않지만 return 뒤에 값을 지정하지 않고 사용은 가능하다, i 가 3일때 return 을 만나서 아래 "test1 종료" 문구가 출력되지 않은 모습이다
package class_;
import java.util.ArrayList;
import java.util.Scanner;
publicclassTestMethod3{
public ArrayList<Integer> inputNum(){
// 수를 무한대로 입력받는 부분
Scanner sc = new Scanner(System.in);
ArrayList<Integer> nums = new ArrayList<>();
while(true) {
System.out.print("수를 입력하세요(종료:0) >>> ");
int num = sc.nextInt();
if(num == 0) break;
nums.add(num);
}
// 숫자를 저장한 List 를 반환return nums;
}
public ArrayList<Integer> even3(ArrayList<Integer> a){
// List 배열의 수가 3의 배수인지 확인하는 메소드
ArrayList<Integer> even3 = new ArrayList<Integer>();
for(int i : a) {
if (i%3 == 0) {
// 3의 배수라면 even3 이라는 List 에 값 추가
even3.add(i);
}
}
// 3의 배수가 담긴 List 인 even3 을 returnreturn even3;
}
publicvoidprintEven3(ArrayList<Integer> a){
System.out.println("- 3의 배수 목록 -");
for (int i : a) {
System.out.print(i + " ");
}
}
}
package set;
import java.util.ArrayList;
import java.util.HashSet;
publicclassEx01{
publicstaticvoidmain(String[] args){
HashSet<String> set = new HashSet<>();
set.add("라면");
set.add("김밥");
set.add("순대");
set.add("라면");
ArrayList<String> arr = new ArrayList<>();
arr.add("라면");
arr.add("김밥");
arr.add("순대");
arr.add("라면");
// ArrayList 와 차이점 : 중복이 발생되지 않는다, 데이터가 순서대로 저장되지 않는다
System.out.println(set); // [김밥, 순대, 라면]
System.out.println(arr); // [라면, 김밥, 순대, 라면]
}
}
Set 사용법과 List 와 차이점
package baseball;
import java.util.HashSet;
publicclassEx02{
publicstaticvoidmain(String[] args){
HashSet<String> set = new HashSet<>();
set.add("111");
set.add("222");
set.add("333");
System.out.println("set : " + set); // set : [111, 222, 333]
set.remove("111");
System.out.println("삭제 set : " + set); // 삭제 set : [222, 333]
}
}
Set 컬렉션에 자료 추가 및 삭제
package set;
import java.util.ArrayList;
import java.util.Iterator;
publicclassEx04{
publicstaticvoidmain(String[] args){
ArrayList<String> arr = new ArrayList<>();
arr.add("일");
arr.add("이");
arr.add("삼");
System.out.println("arr : " + arr);
/*
Interator : 반복자 ( 배열 형식의 데이터로 만든다 )
- hasNext : 다음 위치에 값이 있으면 true, 없으면 false
- next : 다음 위치로 이동 후 값을 얻어옴
baf : 데이터의 시작을 의미
eaf : 데이터의 끝을 의미
it => [ baf, 일, 이, 삼, eaf ]
*/
Iterator<String> it = arr.iterator();
System.out.println(it.hasNext()); // baf 값의 다음 값이 존재하는지 여부 확인
System.out.println(it.next()); // 다음 값인 "일" 로 이동 후 값을 꺼내옴
System.out.println(it.next()); // 다음 값인 "이" 로 이동 후 값을 꺼내옴
System.out.println(it.next()); // 다음 값인 "삼" 으로 이동 후 값을 꺼내옴
System.out.println(it.hasNext()); // 현재 위치에서 다음 값이 존재하는지 여부 확인// 다음 값이 없기 때문에 false 출력
System.out.println(it.next()); // 다음 값이 없기 때문에 이동할 수 없으며 console 오류 출력
}
}
Iterator
package set;
import java.util.HashSet;
import java.util.Iterator;
publicclassEx05{
publicstaticvoidmain(String[] args){
HashSet<String> set = new HashSet<>();
set.add("111");
set.add("222");
set.add("333");
System.out.println("set : " + set); // set : [111, 222, 333]
Iterator<String> it;
it = set.iterator();
// it 를 Iterator 자료형으로 변경// Set 컬렉션은 순서가 존재하지 않는다 ( index 가 존재하지 않는다 )// 그러므로 내부의 값에 접근하기 위해 Iterator 컬렉션으로 변경하여 사용한다// Iterator 컬렉션으로 변경하게 되면// it => [ baf, 111, 222, 333, eaf ]// 위와 같이 배열의 값의 맨 처음(baf)과 맨 뒤(eaf) 값이 추가된다.// 첫 위치는 baf 에서부터 출발하며 .hasNext() 메소드를 사용하여 다음 위치인// "111" 의 값이 존재하는지 확인하고// .next() 메소드를 사용하여 다음 위치로 이동 및 해당 위치의 값을 출력한다// 현재 위치에서 다음 값이 존재하지 않을때까지 반복while(it.hasNext()) {
System.out.println(it.next());
// 111// 222// 333
}
System.out.println("종료!!!");
}
}
Iterator 사용하여 set 의 저장값 출력
( set 에는 순서인 인덱스가 존재하지 않기 때문에 Iterator 컬렉션으로 변환하여 내부의 저장값에 접근한다 )
MAP
Map
package map;
import java.util.HashMap;
publicclassEx01{
publicstaticvoidmain(String[] args){
HashMap<String, String> map = new HashMap<>();
map.put("num", "100");
map.put("name", "홍길동");
map.put("선풍기", "1000만원");
System.out.println(map); // {num=100, name=홍길동, 선풍기=1000만원}// .get(키) 메소드로 해당 키에 대한 값을 가져온다
System.out.println(map.get("num")); // 100
System.out.println(map.get("선풍기")); // 1000만원
System.out.println(map.get("없는 키")); // null// 입력한 키가 존재하지 않으면 null 값을 반환한다
}
}
map 사용법
package map;
import java.util.HashMap;
publicclassEx02{
publicstaticvoidmain(String[] args){
HashMap<String, Integer> map = new HashMap<>();
map.put("num", 100);
map.put("age", 10);
System.out.println(map); // {num=100, age=10}// 출력 시 저장값인 Integer 형으로 출력됨
System.out.println(map.get("num")); // 100// 출력 값인 Integer 형으로 변수를 지정하여 출력 값을 저장int num = map.get("age");
System.out.println(num); // 10// 키 값이 있는지 .containsKey() 메소드로 확인
System.out.println( map.containsKey("age") ); // true// 저장 값이 있는지 .containsValue() 메소드로 확인
System.out.println( map.containsValue(2000) ); // false// 이미 존재하는 키를 입력하면 키가 중복되는 대신// 기존 키의 값이 변경됨// map 은 키 중복이 불가능, 값은 중복이 가능하다
map.put("age", 12345);
System.out.println( map ); // {num=100, age=12345}// 삭제
map.remove("age");
System.out.println( map ); // {num=100}
}
}
map 에 값 추가, 삭제, 값이 있는지 확인
package map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
publicclassEx03{
publicstaticvoidmain(String[] args){
HashMap<String, String> map = new HashMap<>();
map.put("이름", "홍길동");
map.put("나이", "20");
System.out.println(map); // {이름=홍길동, 나이=20}// .keySet() : 키만 출력
System.out.println( "key set : " + map.keySet() ); // key set : [이름, 나이]// .values() : 값만 출력
System.out.println( "values : " + map.values() ); // values : [홍길동, 20]// .keySet() 의 값은 반환 자료형이 Set 이기 때문에 Set 컬렉션 자료형에 담아준다
Set<String> set = map.keySet();
System.out.println(set); // [이름, 나이]// map 의 키를 저장한 set 의 값에 접근하기 위해 Iterator 컬렉션으로 다시 저장// it => [ baf, 이름, 나이, eaf ]
Iterator<String> it = set.iterator();
for( ; it.hasNext(); ) {
// System.out.println(it.next());// 이름// 나이
String key = it.next();
System.out.println( key + " : " + map.get(key) );
// 이름 : 홍길동// 나이 : 20
}
System.out.println("종료!!!");
}
}
map 의 키로 값에 접근하는 방법
Wrapper Class
Wrapper Class
List, Set, Map 클래스를 사용하는 경우 자바의 기본 자료형을 사용할 수 없으므로
Wrapper Class 를 사용하여 기본 자료형의 값을 저장한다.
package baseball;
import java.util.ArrayList;
publicclassEx02{
publicstaticvoidmain(String[] args){
// int 자료형은 List에 담을 수 없음// ArrayList<int> arr = new ArrayList<>();//Wrapper Class 를 사용하여 자바의 기본 자료형을 List, Set, Map 에 담는다
ArrayList<Integer> arr = new ArrayList<>();
}
}
실습 예제
코드 실행 예시
실습 풀이
package test;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Scanner;
publicclasstest1{
publicstaticvoidmain(String[] args){
Scanner sc = new Scanner(System.in);
HashMap<String, Integer> menu = new HashMap<>();
int choice = 0;
String addMenu = null;
int addPrice = 0;
while(choice != 3) {
// 메인 출력
System.out.print("1. 메뉴 등록\n2. 메뉴별 가격 보기\n3. 종 료\n>>> ");
choice = sc.nextInt();
// 1. 메뉴 등록if(choice == 1) {
System.out.print("추가할 메뉴 이름 >>> ");
addMenu = sc.next();
System.out.print(addMenu + " 가격 >>> ");
addPrice = sc.nextInt();
menu.put(addMenu, addPrice);
}
// 2. 메뉴 출력if(choice == 2) {
// key 를 set 으로 변형 후 바로 iterator 컬렉션으로 변환
Iterator<String> strMenu = (menu.keySet()).iterator();
System.out.println("===== 메뉴판 =====");
// 메뉴 출력while(strMenu.hasNext()) {
String key = strMenu.next();
System.out.println(key + " : " + menu.get(key));
}
System.out.println("=================");
// 가격 수정,메뉴 삭제, 나가기 출력
System.out.println("1.가격 수정 2.메뉴 삭제 3.나가기");
int menuEdit = 0;
System.out.print(">>> ");
menuEdit = sc.nextInt();
// 가격 수정 구현if(menuEdit == 1) {
System.out.print("가격 수정할 메뉴 입력 >>> ");
String editName = null;
editName = sc.next();
if(menu.containsKey(editName)) {
System.out.print("수정할 금액 입력 >>> ");
int editPrice = 0;
editPrice = sc.nextInt();
menu.put(editName, editPrice);
System.out.println(editName + "의 가격을 " + editPrice + "로 변경 완료!!");
}else {
System.out.println("해당하는 메뉴가 존재하지 않습니다.");
}
}
// 메뉴 삭제 구현if(menuEdit == 2) {
System.out.print("삭제할 메뉴를 입력해주세요 >>> ");
String removeMenu = null;
removeMenu = sc.next();
if(menu.containsKey(removeMenu)) {
menu.remove(removeMenu);
System.out.println(removeMenu + "가 삭제되었습니다.");
}else {
System.out.println("해당 메뉴가 존재하지 않습니다.");
}
}
}
}
System.out.println("프로그램을 종료합니다.");
}
}
- 이해해야할 부분 -
메뉴를 출력하는 부분에서 map 컬렉션에 저장된 key 를 추출할때 map 컬렉션의 .keySet() 메소드를 사용하여 key 를 반환받게 되는데 이때 .keySet() 메소드의 반환 값이 set 컬렉션이므로( 순서가 없기 때문에 index 도 존재하지 않아서 저장 값에 접근할 수 없음 ) 이 값을 다시 iterator 컬렉션으로 변환하여 key 에 접근할 수 있게 변환한 뒤 key 들을 변수로 저장하여 사용한다
