[Java] JCF - Set, Map

 1. Set 

- 일차원 배열처럼 생성됨

- 중복값을 저장하지 않고, 검색의 기능이 없음 (List와의 차이점, 값을 얻을 수 없음)

- 입력되는 값은 순차적으로 입력되지 않음

 

- 사용법)

1) 생성 : Set<E> set = new HashSet<E>();

           Set<String> set = new HashSet<String>();

2) 값 할당 : 중복값을 저장하지 않고 순차적으로 입력되지도 않음

               set.add(값);

3) 크기 : set.size();

4) 값 삭제 : 값의 내용과 일치하는 element를 삭제함

set.remove(값);

set.clear(); // 모든 방의 값 삭제

5) 값 얻기 : 값을 얻기 위한 객체 사용(Iterator)

> set에서 Iterator에게 제어권을 할당해야 함 (List도 사용가능)

    Iterator<E> ita = set.iterator(); // Set의 element 개수를 알 수 없으므로 while 사용

    while( ita.hasNext() ) { // 5-1. 요소가 존재하는지?

    ita.next() // 5-2. 값을 얻고, 포인터를 다음 요소로 이동}

6) 배열로 복사

6-1) Generic으로 선언된 데이터형을 사용하여 배열 선언

           String[] arr = new String [ set.size() ];

6-2) 복사

           set.toArray(arr);

 

 2. Map 

- KVP (Key Value Pair) : 키와 값의 쌍(entry)으로 이루어진 데이터형

- 이차원 배열처럼 생성

- entry는 비순차적

- 키를 가지고 값을 검색하는 일

- 키는 유일하나 값은 중복될 수 있음

- 같은 키가 입력되면 기존의 key에 덮어씀

- 구현 클래스 중 HashTable, HashMap, Properties 등이 자주 사용되는 구현 클래스임

• HashTable : Key를 사용하여 값을 얻을 때 사용
             MultiThread에서 동시접근 불가(느림)
             initial capacity : 11 (11개의 행이 만들어짐)
• HashMap : Key를 사용하여 값을 얻을 때 사용
  MultiThread에서 동시접근 가능(빠름)
  initial capacity : 16 (16개의 행이 만들어짐)

>> HashTable과 HashMap은 데이터가 전체 크기에 약 75%가 채워져 있을 때 빠른 검색을 함

 

- 사용법)

1) 객체화 : Map<K,V> map = new 구현클래스<K,V>();

     Map<String,String> map = new HashMap<String,String>();

     Map<String,String> map = new HashTable<String,String>();

2) 값 할당 : entry는 순서대로 들어가지 않음. 같은 키가 입력되면 기존의 키에 덮어씀

     map.put(“A”,”에이”);

3) 특정 키 존재 여부 : boolean b = map.containsKey(“키”);

4) 값 얻기 : 데이터형(Generic) 값 = map.get(“키”);

5) 삭제 : map.remove(“키”); // 키에 해당하는 entry 삭제

                map.clear(); // 모든 entry 삭제

6) 모든 키 얻기 : map의 검증용도 (Set과 iterator 활용) / map에 뭐가 들어있는지 확인하겠다!

           Set<E> set = map.keySet();

           Set<String> set = map.keySet();

           Iterator<String> ita = set.iterator();

           String key="";

           while (ita.hasNext()) {

                       key=ita.next();

                       System.out.println("키:" + key + " / 값:" + map.get(key));           }

7) 크기 : map.size(); // intial capacity가 아니라 entry의 크기

---

# 오늘의 코딩 #

- Set과 Map 특성 확인하기

 

#먼저 Set!

package test;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/**
 * Set의 사용 : 값은 중복되지 않고, 검색 기능이 없음. 데이터는 순차적으로 입력되지 않음
 * 
 * @author user
 */
public class UseSet {

	public UseSet() {
		// 1. 객체화 : Set<E> set = new HashSet<E>();
		Set<String> set = new HashSet<String>();
		// 2. 값 할당 : set.add("값"); 순서x 중복x
		set.add("1.주헌");
		set.add("2.기현");
		set.add("3.형원");
		set.add("4.셔누");
		set.add("5.민혁");
		set.add("5.민혁"); // 동일값 추가해도 반영안됨

		// 3. 크기
		System.out.println(set.size());
		System.out.println(set);

		// 4. 값 얻기 : set은 검색기능이 없어서 값을 얻을 수 없으므로
		// Iterator를 사용하여 값을 얻어와야 함
		// Iterator의 객체 생성, 제어권을 할당한 후 포인터 이동으로 값 얻을 수 있음
  		Iterator<String> ita = set.iterator();
		
		while(ita.hasNext()) {//요소가 존재하면 반복시킴
			System.out.println(ita.next()); //값을 얻고 포인터를 다음으로 이동
		}//end while
		
		// 배열로 복사
		// set의 크기로 배열 생성
		String[] arr = new String[set.size()];
		// 복사
		set.toArray(arr);
		
		//삭제
		set.remove("2.기현");
		System.out.println("set 객체 : " + set);
		
		// java.util.Arrays 클래스를 사용하면 배열에 대한 여러가지 작업 수행 가능
		System.out.println("배열 객체 : " + Arrays.toString(arr));

	}// UseSet

	public static void main(String[] args) {

		new UseSet();

	}// main

}// class

# 출력 결과 #

5
[3.형원, 4.셔누, 1.주헌, 2.기현, 5.민혁]
3.형원
4.셔누
1.주헌
2.기현
5.민혁
set 객체 : [3.형원, 4.셔누, 1.주헌, 5.민혁]
배열 객체 : [3.형원, 4.셔누, 1.주헌, 2.기현, 5.민혁]

 

# 이제 Map!

package test;

import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * KVP(Key Value Pair)로 이루어진 데이터형
 * Key 유일, 값 중복가능
 * key를 사용하여 값을 얻는 일
 * @author user
 */
public class UseMap {

	/**
	 * HashMap : 16개의 행이 생성. 키를 검색할 때 데이터가 약 75%가 채워져 있을 때 가장 빠름
	 */
	public void useHashMap() {
		//1. 생성 : Map<K,V> map = new HashMap<K,V>();
		Map<String,String> map = new HashMap<String,String>();
		System.out.println(map + "/" + map.size()); // initial capa가 아니라 entry의 크기
		
		//2. 값 할당 : map.put(키,값); // 비순차적으로 입력됨
		map.put("A","세심하다. 친절하다"); 
		map.put("B","성질더럽다.");
		map.put("AB","싸이코");
		map.put("O","우유부단");
		map.put("A","소심"); // entry를 입력할 때 키가 중복된다면 이전 키에 덮어씀
		map.put("K","기름");
		System.out.println(map + "/" + map.size()); // initial capa가 아니라 entry의 크기

		//3. 값 삭제 (행이 줄어듦)
		map.remove("K");
		System.out.println(map + "/" + map.size()); // initial capa가 아니라 entry의 크기
		
		//4. 키가 존재하는지?
		System.out.println(map.containsKey("a"));
		
		//5. 값 얻기
		System.out.println(map.get("AB"));
		
		//6. 모든 키 얻기 : 맵의 검증 용도
		Set<String> set = map.keySet();
		Iterator<String> ita = set.iterator();
		
		String key="";
		while (ita.hasNext()) {
			key=ita.next();
			System.out.println("키:" + key + " / 값:" + map.get(key));
		}//end while
		}//useHashMap
	
	public static void main(String[] args) {

		UseMap um = new UseMap();
		um.useHashMap();
		
	}//main
}//class

- HashMap을 쓰든 HashTable을 쓰든 똑같음

 

# 출력 결과 #

{}/0
{A=소심, AB=싸이코, B=성질더럽다., K=기름, O=우유부단}/5
{A=소심, AB=싸이코, B=성질더럽다., O=우유부단}/4
false
싸이코
키:A / 값:소심
키:AB / 값:싸이코
키:B / 값:성질더럽다.
키:O / 값:우유부단