힘내보자

public class practice_everyday13 {
	public static void main(String[] args) {
		
		// 배열
		// 같은 자료형의 데이터의 여러개의 값을 저장할 수 있는 공간
		
		// 배열 선언
		int[] arr;
		
		// 배열 할당

		int[] arr1 = new int[3]; // 방법1 : 주로 Java에서 사용
		int arr2[] = new int[3]; // 방법2 : 주로 C에서 사용
		
		// 배열 초기화
		// 1)인덱스
		// 2)중괄호 {}
		// 3)for문 이용
		
		// 1)인덱스
		arr1[0] = 1;
		arr1[1] = 2;
		arr1[2] = 3;
		
		System.out.println(arr1[0]); // 1
		System.out.println(arr1[1]); // 2
		System.out.println(arr1[2]); // 3
		
		
		// 2)중괄호 {}
		int[] arr3 = {1,2,3};
//		int arr3[] = {1,2,3}; // error
		for(int i=0; i<arr3.length; i++) {
			System.out.print(arr3[i]+ " "); // 1 2 3
		}
		System.out.println();
		
		// 3)for문
		// 초기화할 값에 ‘규칙’이 존재할 경우 사용가능
		int[] arr4 = new int[3];
		for(int i=0; i<arr4.length; i++) {
			arr4[i] = i+3;
			System.out.print(arr4[i]+" ");
		}
		System.out.println();
		
		// 배열 수정(크기 변경)?
		int size = 5;
		int[] dArr = new int[size];
		System.out.println("dArr길이:"+dArr.length);
		System.out.println("dArr주소:"+dArr);// [I@6d06d69c
		dArr = new int[5]; // 같은 배열 길이
		System.out.println(dArr); // [I@7852e922 주소값이 다르다
		dArr = new int[4]; // 배열길이 4로 수정. 과연 주소값이 같을까?
		System.out.println(dArr); // [I@4e25154f
		// 전부 다른 주소값이 나왔다. 보이기에는 길이가 수정된 것처럼 보이나
		// 실제로는 새로 만든 값으로 대체시킨 것
		
		
		// 배열 삭제
		// 배열 삭제 = null
		dArr = null;
		// 배열에 null을 넣게되면 기존 주소값이 null로 바뀌면서 연결된 값도 끊어지면서
		// 사실상 삭제 효과가 나타난다
        
       }
}

1-1. // add(E e):boolean

1-2. add(int index, E element):void

2. size()

3.remove()
remove(int index):E
remove(Object o):boolean

4. set()
set(int index, E e):E
== replace 대체

5. get() 
get(int index):E

 6. contains(Object) : boolean
해당 객체를 포함한지 true/false반환

7. indexOf(Object o): int 
해당 객체의 인덱스번호 반환
해당 값이 없을경우 -1 반환

8. equals(Object o):boolean
지정된 객체와 목록이 같은지 비교

9. clear()
clear():void

10. isEmpty():boolean

package MVC.controller;
import java.util.ArrayList;
import MVC.model.vo.pModelVo05;
public class pController05 {
	
	// List
	// ArrayList
	public void pList() {
		
		ArrayList<pModelVo05> al = new ArrayList<>();
		
		// e :제네릭에 지정 받은 타입을 그대로 쓰겠다. 
		// o : 안에 뭘 받아올지 모르니까 다 받을 수 있게 오브젝트로 쓰겠다. 엘레멘트로 타입을 지정할 필요가 없다
		
		// 1-1. // add(E e):boolean
		al.add(new pModelVo05("과일",5000));
		al.add(new pModelVo05("스낵 ",1500));
		System.out.println(al.add(new pModelVo05("껌",1500))); // true
		System.out.println(al); // [과일[5000원], 과자[1500원]]
		
		// 1-2. add(int index, E element):void
		al.add(3, new pModelVo05("쌀",50000)); // 마지막3번이 아닌 더 뒤4로 하니 길이 에러
		System.out.println(al); // [과일[5000원], 스낵 [1500원], 껌[1500원], 쌀[50000원]] 
//		System.out.println(al.add(3, new pModelVo05("믈",500))); // void 즉 없는 값을 출력하라해서 에러
		
		// 2. size()
		System.out.println(al.size()); // 4
		
		al.add(new pModelVo05("계란",6000)); // 자동 길이추가
		System.out.println(al); // [과일[5000원], 스낵 [1500원], 껌[1500원], 쌀[50000원], 계란[6000원]]
		
		
		// 3.remove()
		// remove(int index):E
		// remove(Object o):boolean
		System.out.println("=====remove=====");
		al.remove(0); // 과일 삭제
		System.out.println(al.remove(0)); // 스낵 [1500원] // 스낵삭제
		System.out.println(al); // 껌[1500원], 쌀[50000원], 계란[6000원]]
		
		al.remove(new pModelVo05("껌",1500)); // 작동x. 모델에서 오버라이딩 안했기 때문
		System.out.println(al); // [껌[1500원], 쌀[50000원], 계란[6000원]]
		// 모델 오버라이딩 후 			// [쌀[50000원], 계란[6000원]]
		
		System.out.println(al.remove(new pModelVo05("쌀",50000))); // true // 쌀 삭제
		
		pModelVo05 pm = new pModelVo05("계란",6000);
		System.out.println(al.remove(pm)); // true
		System.out.println(al); // []
		al.add(new pModelVo05("물",500));
		al.add(new pModelVo05("요거트",1000));
		System.out.println(al); // [물[500원], 요거트[1000원]]
		
		// 4. set()
		// set(int index, E e):E
		// == replace 대체
		System.out.println(al.set(1, new pModelVo05("커피",1500))); // 요거트[1000원]  // 바꿔진 엘리먼트값 출력
		al.set(1, new pModelVo05("커피",1500)); 				
		System.out.println(al); // [물[500원], 커피[1500원]]
		
		
		// 5. get() 
		// get(int index):E
		System.out.println(al.get(1)); // 커피[1500원]
		System.out.println(al.get(0)); // 물[500원]
		
		// 6. contains(Object) : boolean
		// 해당 객체를 포함한지 true/false반환
		System.out.println(al.contains(new pModelVo05("물",500))); // true
		System.out.println(al.contains(new pModelVo05("물",0))); // false
		
		
		// 7. indexOf(Object o): int 
		// 해당 객체의 인덱스번호 반환
		// 해당 값이 없을경우 -1 반환
		System.out.println(al.indexOf(new pModelVo05("물",500))); // 0
		System.out.println(al.indexOf(new pModelVo05("커피",1500))); // 1
		System.out.println(al.indexOf(new pModelVo05("커피",500))); // -1 // 없을경우-1반환
		
		
		// 8. equals(Object o):boolean
		// 지정된 객체와 목록이 같은지 비교
		System.out.println(al);  // [물[500원], 커피[1500원]]
		System.out.println(al.equals(new pModelVo05("물",500))); // false //[물[500원], 커피[1500원]]와 비교해서 false
		System.out.println(al.equals(new pModelVo05("커피",1500))); //al인 [물[500원], 커피[1500원]]와 비교 하니 false
		
		System.out.println(new pModelVo05("물",500).equals(new pModelVo05("물",500))); // true
		System.out.println(new pModelVo05("커피",1500).equals(new pModelVo05("커피",1500))); // true


		// 9. clear()
		// clear():void
		al.clear();
		System.out.println(al); // []
		
		// 10. isEmpty():boolean
		System.out.println(al.isEmpty()); // true
		
		System.out.println("=====ArrayList<string>=====");
		
		ArrayList<String> aList = new ArrayList<>();
		aList.add(new String("인내"));
		aList.add(new String("노력"));
		System.out.println(aList.remove(new String("인내")));
		System.out.println(aList);
//		aList.equals(new String("인내"));
		System.out.println(aList.equals(new String("인내")));
		
		
	}	
		
}

package MVC.model.vo;


public class pModelVo05 {


	private String flavor;
	private int price;
	
	public pModelVo05() {}
	public pModelVo05(String flavor, int price) {
		super(); // 안써도 됨. 자동완성해서 생긴것. 원래는 생성자를 불러올 때 부모생성자를 불러오고 시작함. 
		this.flavor = flavor;   // 그래야 자식 객체를 만들 때 부모 객체 생성자를 만들기 때문
		this.price = price;
	}
	
	// getter / setter
	public String getFlavor() {
		return flavor;
	}
	public int getPrice() {
		return price;
	}
	public void setFlavor(String flavor) {
		this.flavor = flavor;
	}
	public void setPrice(int price) {
		this.price = price;
	}
	
	// toString
	@Override
	public String toString() {
		return flavor+"["+price+"원]";
	}
		
	
	@Override
	public boolean equals(Object obj) {
		// 객체 비교
		if (this == obj) { // this는 주소값 비교할려고 넣은 것
			return true;
		}
		if(obj == null) {
			return false;
		}
		if(getClass() != obj.getClass()) { // 내 클래스 정보와 상대방의 클래스 정보가 같은지 비교
			return false;
		}
		
		pModelVo05 other = (pModelVo05)obj; // 다운캐스팅 : obj->Snack
		if(flavor == null) {      // other는 레퍼런스 변수
			if(other.flavor != null) { 
				return false;
			}
		}else if(!flavor.equals(other.flavor)) { // 이름에 대한 비교
			return false;
		}
		
		if(price != other.price) { // 목록에 대한 비교
			return false;
		}
		return true;
	}
	
	@Override
	public int hashCode() {
		final int PRIME = 31; // 컴퓨터가 이해하기 좋은 숫자가 31이라함
		int result = 1;
		
		result = PRIME * result + (flavor == null ? 0 : flavor.hashCode()); // 내 해쉬코드가 아니라 스트링의 해쉬코드를 가져오는 것
		result = PRIME * result + price; // 형이 안맞아서 에러나니 캐스팅 또는 소수점 없게끔 계산
		
		return result;
	}	
	
	
}

SELECT 컬럼명 -- 조회하고자 하는 컬럼명 기술
FROM 테이블명 -- 조회하고자 하는 컬림이 포함된 테이블명 기술
WHERE 조건식; -- 행을 선택하는 조건 기술, 조건을 만족하는 행만 반환
                     -- 조건식 복수로 붙여서 사용가능. 복수라도 WHERE절 한개만 기술

비교연산자

>, <, >=, <=, = ,!= 

크다, 작다, 크거나 같다
같다 : =
같지않다 : != , ^= , <>

컬럼 별칭

컬럼명  AS 별칭 / 컬럼명 AS “별칭” / 컬럼명 별칭 / 컬럼명 “별칭”

별칭 : "" 

리터럴(literal)

값 자체

싱글쿼테이션( ' ' )

오라클에서는 문자,문자열,데이트 상관없이 다 싱글쿼테이션(’ ‘)으로 감싸준다

-- 컬럼 별칭
-- 컬럼명  AS 별칭 / 컬럼명 AS “별칭” / 컬럼명 별칭 / 컬럼명 “별칭”



/*
리터럴(literal)
값 자체 ‘ ‘

오라클에서는 문자,문자열,데이트 상관없이 다 싱글쿼테이션(’ ‘)으로 감싸준다
데이터 타입에 상관없이 별칭(””) 외에는 다 싱글쿼테이션으로 감싼다
*/ 

-- EMPLOYEE 테이블에서 직원의 직원 번호, 사원명, 급여, 단위 조회
SELECT EMP_NO, EMP_NAME, SALARY, '원' "단위 : 원"
FROM EMPLOYEE;
SELECT EMP_NO, EMP_NAME, SALARY, '@' "원"
FROM EMPLOYEE;


-- 별칭 : "" 
-- 리터럴을 싱글쿼테이션으로 처리한다 : ' '
-- '원'이라는 컬럼을 보여주고 싶지않으면 더블쿼테이션""으로 단위써주자



-- EMPLOYEE테이블에서 직원의 직급 코드 조회
SELECT EMP_ID, '직급코드' AS 직급코드
FROM EMPLOYEE;

SELECT EMP_NAME, EMAIL
FROM EMPLOYEE
WHERE EMAIL LIKE 'b%';
-- 결과 : 방명수 bang ns@kh.kr


-- 결과 : 없음
-- 리터럴은 대소문자 철저히 구별하기에 대문자 BANG으로 시작하는 EMAIL이 없어서 안나온 것



-- EMPLOYEE 테이블에서 직원의 부서 코드를 중복 없이 조회
SELECT DISTINCT JOB_CODE
FROM EMPLOYEE;

-- DISTINCT는 한번만 쓸 수 있다
--SELECT DISTINCT DEPT_CODE, DISTINCT DEPT_CODE -- error
--FROM EMPLOYEE;
SELECT DISTINCT DEPT_CODE, JOB_CODE -- 콤마로 두 컬럼을 묶으면 두 컬럼의 조건이  
FROM EMPLOYEE;                      -- AND조건으로 교집합 된 것만 중복 제거한다



/*
SELECT 컬럼명 -- 조회하고자 하는 컬럼명 기술
FROM 테이블명 -- 조회하고자 하는 컬림이 포함된 테이블명 기술
WHERE 조건식; -- 행을 선택하는 조건 기술, 조건을 만족하는 행만 반환
             -- 조건식 복수로 붙여서 사용가능. 복수라도 WHERE절 한개만 기술


--비교연산자
>, <, >=, <=, = ,!= 

크다, 작다, 크거나 같다
같다 : =
같지않다 : != , ^= , <>
*/

--EMPLOYEE테이블에서 부서코드가 'D9'인 직원의 이름, 부서코드 조회
SELECT EMP_NAME, DEPT_CODE
FROM EMPLOYEE
WHERE DEPT_CODE = 'D9';


-- '' 없이 D9만 쓰면 컬럼으로 인지하게 됨
-- 'd9'라고 써도 안됨. 리터럴은 대소문자 구분



--급여가 4000000이상인 직원의 이름, 급여 조회
SELECT EMP_NAME, SALARY
FROM EMPLOYEE
WHERE SALARY >= 4000000;




-- EMPLOYEE테이블에서 부서코드가 D9이 아닌 사원의 사번, 이름, 부서코드조회
SELECT EMP_NO, EMP_NAME, DEPT_CODE
FROM EMPLOYEE
--WHERE DEPT_CODE != 'D9';
WHERE DEPT_CODE <> 'D9';
WHERE DEPT_CODE ^= 'D9';


-- EMPLOYEE 테이블에서 퇴사 여부가 N인 직원을 조회하고 근무 여부를 재직중으로 표시
-- 사번,이름, 고용일, 근무여부 조회
SELECT EMP_ID, EMP_NAME, HIRE_DATE, '재직중' "근무여부"
FROM EMPLOYEE
WHERE ENT_YN = 'N';

SELECT : 데이터 조회
RESULT SET : SELECT구문으로 데이터를 조회한 결과물

ex) 해당 조건에 맞지않는 결과값이 없으면 0행으로 나올 수도 있다

SELECT 컬럼명

FROM 테이블명  // 조회하고자 하는 컬럼이 포함된 테이블명 기술

SELECT 컬럼명 FROM 테이블명;

컬럼의 산술 연산

-- EMPLOYEE 테이블의 사번,이름,급여 조회
SELECT EMP_ID, EMP_NAME,SALARY
FROM EMPLOYEE;


--EMPLOYEE 테이블의 모든 정보 조회
SELECT EMP_ID, EMP_NAME,EMP_NO,EMAIL,PHONE,DEPT_CODE,JOB_CODE,
        SAL_LEVEL,SALARY,BONUS,MANAGER_ID,HIRE_DATE,ENT_DATE,ENT_YN
FROM EMPLOYEE;

SELECT * FROM EMPLOYEE;

/*
-- 실습 문제 --
1.JOB 테이블의 모든 정보 조회
2.JOB 테이블의 직급 이름 조회
3.DEPARTMENT 테이블의 모든 정보 조회
4.EMPLOYEE 테이블의 직원명, 이메일, 전화번호, 고용일 조회
5.EMPLYEE 테이블의 고용일, 사원이름, 월급 조회
*/

--1.JOB 테이블의 모든 정보 조회
-- 방법1
SELECT * FROM JOB;


-- 방법2
SELECT JOB_CODE, JOB_NAME FROM JOB;

--2.JOB 테이블의 직급 이름 조회
SELECT JOB_NAME FROM JOB;

--3.DEPARTMENT 테이블의 모든 정보 조회
-- 방법1
SELECT * FROM DEPARTMENT;
-- 방법2
SELECT DEPT_ID, DEPT_TITLE, LOCATION_ID FROM DEPARTMENT;

--4.EMPLOYEE 테이블의 직원명, 이메일, 전화번호, 고용일 조회
SELECT EMP_NAME, EMAIL, PHONE, HIRE_DATE FROM EMPLOYEE;
--5.EMPLYEE 테이블의 고용일, 사원이름, 월급 조회
SELECT HIRE_DATE, EMP_NAME,SALARY FROM EMPLOYEE;



--컬럼 값 산술 연산
--EMPLOYEE테이블에서 직원명, 연봉 조회(연봉 = 급여*12)
SELECT EMP_NAME, SALARY, SALARY*12 "연봉" 
FROM EMPLOYEE;

--EMPLOYEE테이블에서 직원명, 연봉, 보너스를 추가한 연봉 조회
-- 방법1
SELECT EMP_NAME, SALARY*12 "연봉", (SALARY+SALARY*BONUS)*12 AS 보너스 
FROM EMPLOYEE;
--  수식에 NULL이 있으면 결과값에 NULL이 나옴 
-- 방법2
SELECT EMP_NAME 이름, SALARY*12 "연 봉", (SALARY+SALARY*BONUS)*12 AS "보너스"
FROM EMPLOYEE;

/*
------------실습문제------------
1.EMPLOYEE테이블에서 이름, 연봉, 총수령액(보너스포함), 실수령액(총수령액-(연봉*세금3%)) 조회
2.EMPLOYEE테이블에서 이름, 고용일, 근무일수(오늘 날짜 - 고용일) 조회 
 - 오늘날짜 SYSDATE
*/
--(SALARY+SALARY*BONUS)*12
SELECT EMP_NAME, SALARY*12 연봉, SALARY*(1+BONUS)*+12 "총 수령액", 
        (SALARY*(1+BONUS)*12)-(SALARY*12*0.03) AS 실수령액
FROM EMPLOYEE;

SELECT EMP_NAME, HIRE_DATE, SYSDATE - HIRE_DATE AS "근무 일수"
FROM EMPLOYEE;

package MVC.controller;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

import MVC.model.vo.pModelVo04;

public class pController04 {
	
	// Map
	// {key=value} 형식으로 출력됨 // map도 중괄호{} 찍혀서 나온다
	public void pMap() {
		
		// 1.HashMap
		// 2.TreeMap
		
		
		// 1.HashMap
		// put(K key, V value):V
		// 반환타입 : value
		System.out.println("===HashMap===");
		
		HashMap<String, pModelVo04> hmap = new HashMap<>();
		
		hmap.put(new String("블루베리류"), new pModelVo04("블루베리",100)); // 순서x
		hmap.put(new String("사과류"), new pModelVo04("아오리",200));
		System.out.println(hmap);	// {사과류=아오리[200원], 블루베리류=블루베리[100원]}
		System.out.println(hmap.put(new String("참외류"), new pModelVo04("참외",300))); // null
		System.out.println(hmap.put(new String("1"), new pModelVo04("1",300))); 	// null
		System.out.println(hmap);		// {사과류=아오리[200원], 블루베리류=블루베리[100원], 참외류=참외[300원]}
		
		
		
		// 2.containsKey(Object key)
		// 키나 값이 들어가 있는지를 확인하는 메소드
		// containsKey(Object key):boolean	
		// containsValue(Object value):boolean	
		
		hmap.containsKey(new String("블루베리류"));
		System.out.println(hmap);   // {사과류=아오리[200원], 1=1[300원], 블루베리류=블루베리[100원], 참외류=참외[300원]}
		System.out.println(hmap.containsKey(new String("블루베리류")));// true
		
		hmap.containsValue(new pModelVo04("블루베리",100));
		System.out.println(hmap.containsValue(new pModelVo04("블루베리",100))); // false
		System.out.println(hmap.containsValue(new pModelVo04("블루베리",100))); // true    // model에서 오버라이딩 후 true
		
		
		// 3.get()
		// get(Object key) : v
		// key값에 맞는 'value값 반환'
		hmap.get(new String("참외류"));
		System.out.println(hmap.get(new String("사과류"))); // 아오리[200원]
		System.out.println(hmap.getClass()); // class java.util.HashMap
		System.out.println(hmap); // {사과류=아오리[200원], 1=1[300원], 블루베리류=블루베리[100원], 참외류=참외[300원]}
		
		System.out.println("===4.remove()======");
		// 4-1.remove(Object key):V
		System.out.println(hmap.remove("1")); // 1[300원]
		System.out.println(hmap); // {사과류=아오리[200원], 블루베리류=블루베리[100원], 참외류=참외[300원]}
		
		// 4-2.remove(Object key, Object value):default boolean
		hmap.remove(new String("블루베리류"),new pModelVo04("블루베리",100));
		System.out.println(hmap.remove(new String("블루베리류"),new pModelVo04("블루베리",100)));//false
		System.out.println(hmap); // {사과류=아오리[200원], 참외류=참외[300원]} 오버라이딩 적용
		

		
		// 5.keySet() & entrySet()
		System.out.println("===keySet() & entrySet()======");
		
		// keySet()
		// keySet():Set<K>
		// 맵에 있는 key들을 set에 담아 반환
		
		// 방법1
		System.out.println(hmap.keySet()); // [사과류, 참외류]
		
		// 방법2
		// set의 [] 없이 안에 값만 뽑고 싶다면 방법2 사용
		Set<String> sset = hmap.keySet();
		Iterator<String> is = sset.iterator();
		while(is.hasNext()) {
			String s = is.next();
			System.out.print(s+" "); // 사과류  참외류 
		}
		System.out.println();
		
		
		// entrySet()
		// entrySet():Set<Map.Entry<K,V>>
		// map에 있는 entry들을 set 담에 반환(키와 값의 쌍을 set에 담아 반환)
		// entry 의미 : 키와 값을 묶은 것(키와 값의 쌍)
		
		// 방법1
		System.out.println(hmap.entrySet());//[사과류=아오리[200원], 참외류=참외[300원]]
		
		// 방법2
		// set의 [] 없이 안에 값만 뽑고 싶다면 방법2 사용
		Set<Entry<String,pModelVo04>> eset = hmap.entrySet();
		Iterator<Entry<String,pModelVo04>> it_eset = eset.iterator();
		while(it_eset.hasNext()){
			Entry<String, pModelVo04> a = it_eset.next();
			System.out.print(a+" ");  		// 사과류=아오리[200원] 참외류=참외[300원] 
		}									
		System.out.println();
		
		
		// size():int
		System.out.println(hmap.size()); // 2
		
		
		
		// TreeMap
		System.out.println("===TreeMap1===");
		
		TreeMap<String,pModelVo04> treeM = new TreeMap<>();
		
		treeM.put(new String("TreeMap"),new pModelVo04("Map",1));
		System.out.println(treeM.put(new String("TreeMap"),new pModelVo04("Map",1)));//Map[1원]
		System.out.println(treeM); // {TreeMap=Map[1원]}
		
		// putAll()
		// putAll(Map<? extends K,? extends V> m):void
		// 다른 맵의 값을 추가
		treeM.putAll(hmap);
		System.out.println(treeM); // {TreeMap=Map[1원], 사과류=아오리[200원], 참외류=참외[300원]}
		
		// remove(Object key):V
		System.out.println(treeM.remove(new String("참외류"))); // 참외[300원]
		System.out.println(treeM); // {TreeMap=Map[1원], 사과류=아오리[200원]}
		
		// replace(K key, V oldValue, V newValue):boolean
		treeM.replace(new String("TreeMap"),new pModelVo04("Map",1), new pModelVo04("맵",2)); 
		System.out.println(treeM); // {TreeMap=맵[2원], 사과류=아오리[200원]}
		
		// remove(Object key, Object value):boolean
		System.out.println(treeM.remove(new String("사과류"),new pModelVo04("아오리",200))); // true 오버라이딩 적용
		treeM.remove(new String("사과류"),new pModelVo04("아오리",200));
		System.out.println(treeM); // {TreeMap=맵[2원]}
		
		

		
	}	
		
}

1)put(K key, V value):V

2)containsKey(Object key):boolean

3)containsValue(Object value):boolean

4)get(Object key) : v

5)keySet():Set<K>

6)entrySet():Set<Map.Entry<K,V>>

// 1.HashMap
		// put(K key, V value):V
		// 반환타입 : value
		HashMap<String,pModelVo03> hm = new HashMap<>();
		hm.put("힘", new pModelVo03("아자아자",1));			
		hm.put("내", new pModelVo03("으샤으샤",2)); 
		hm.put("라", new pModelVo03("으랴차차",3));
		System.out.println(hm.put("힘", new pModelVo03("아자아자",1))); // 아자아자[1원]
		System.out.println(hm); // 순서x
		System.out.println(hm); // {내=으샤으샤[2원], 힘=아자아자[1원], 라=으랴차차[3원]}
		
		
		// 2.containsKey(Object key)
		// 키나 값이 들어가 있는지를 확인하는 메소드
		// containsKey(Object key):boolean	
		// containsValue(Object value):boolean	
		
		boolean a = hm.containsKey("힘"); // 키값 확인
		System.out.println(a);
		System.out.println(hm.containsKey("내"));
		
		System.out.println(hm.containsValue(new pModelVo03("아자아자",2))); // 밸류값 확인
		System.out.println(hm.containsValue(new pModelVo03("아자아자",1))); // 새객채 주소값다름
		// 모델 클래스에서 오버라이딩 후 결과창 true
		
		// 3.get()
		// get(Object key) : v
		// key값에 맞는 'value값 반환'
		System.out.println(hm.get("힘"));
		System.out.println(hm.get("내"));
		System.out.println(hm.get("라"));
		
		
		// keySet() & entrySet()
		
		// keySet()
		// keySet():Set<K>
		// 맵에 있는 key들을 set에 담아 반환
		System.out.println(hm.keySet()); // [내, 힘, 라]
		
		
		
		// 다른방법
		Set<String> ks = hm.keySet(); // ketSet이 메소드라 제네릭 안붙임
		System.out.println(ks.iterator()); // java.util.HashMap$KeyIterator@6d06d69c
		Iterator<String> it = ks.iterator();
		System.out.println(it); // java.util.HashMap$KeyIterator@7852e922
		while(it.hasNext()) {
			String key = it.next();
			System.out.println("keySet : "+key);
		}
		
		
		
		// entrySet()
		// entrySet():Set<Map.Entry<K,V>>
		// map에 있는 entry들을 set 담에 반환(키와 값의 쌍을 set에 담아 반환)
		// entry 의미 : 키와 값을 묶은 것(키와 값의 쌍)
		System.out.println("=====entrySet=====");
		System.out.println(hm.entrySet()); // [내=으샤으샤[2원], 힘=아자아자[1원], 라=으랴차차[3원]]
		
		// 다른방법
		Set<Entry<String,pModelVo03>> es = hm.entrySet();
		es.iterator();
		Iterator<Entry<String,pModelVo03>> it2 = es.iterator();
		while(it2.hasNext()) {
			Entry<String,pModelVo03> en = it2.next();
			System.out.print(en+" "); // 내=으샤으샤[2원] 힘=아자아자[1원] 라=으랴차차[3원] 
		}
		System.out.println();