[Day26] Java 26 - HashMap, Hashtable, Properties, Collections, 제네릭 (클래스,인스턴스,와일드카드)

[Day26] Java 26 [9/15]

HashMap과 Hashtable

1) Map 인터페이스를 구현한 컬렉션 클래스

2) key + value 한쌍으로 저장/읽기 == 엔트리( Entry )

3) Hash : [해싱 기법]을 사용하기 때문에 [많은 양의 데이터]를 [검색]할 때 성능의 뛰어나다.

4) Hashtable ( 구 ) < 권장 HashMap( 신 )

동기화 O X

스레드 안전 X

Vector ArrayList

5) key 중복 X

value 중복 O

HashMap<String, String>   hm = new HashMap<>();
hm.put("kenik", "이창익");
hm.put("hong", "홍길동");
hm.put("hong", "홍기수");  // 새로 추가된 엔트리로 처리.
		
System.out.println(  hm  );

HashMap<String, Student > hm = new HashMap< >();

hm.put( "ss5001" , new Student("ss5001", "홍길동" ));  // X
hm.put( "ss5001" , new Student("ss5001", "이재민" ));
// null 키로 사용할 수 있다 + 1번 사용 ( 중복 허용 X )
hm.put( null, new Student(null, "허정연" ));  // X
hm.put( null, new Student(null, "엄태혁" ));		
//  value 중복 허용한다. 
hm.put( "ss5002" , new Student("ss5001", "이재민" ));  // X

// System.out.println( hm );

// 학번( key ) 이 "ss5003" 학생 존재 유무 확인 
boolean isExist = hm.containsKey(  "ss5001" );
System.out.println(  isExist ); // true
// hm.containsValue(hm)

if(  hm.containsKey(  "ss5001" ) ) {
	// value           =  Student  객체 얻어와 출력.
	// key를 알때 value 어떻게 얻어오나? 
	Student v = hm.get( "ss5001" );
	System.out.println( v );
}

// 1. 모든 key 값을 얻어와서 출력 - keySet() 메서드   ( 시험 )
Set<String>  ks =  hm.keySet();

Iterator<String> ir = ks.iterator();
while (ir.hasNext()) {
	String key =  ir.next();
	Student v = hm.get(key);
	System.out.printf(" key=%s - value=%s  \n", key, v );
}

// 2. 모든 value 값을 얻어와서 출력	   
Collection<Student>  vc = hm.values();

Iterator<Student> ir2 =   vc.iterator();
while (ir2.hasNext()) {
	Student s =  ir2.next();
	System.out.println( s );
}

// 3. 모든 key- value 출력               엔트리(entry)(k+v)  ( 시험 )
Set<Entry<String, Student>>  es = hm.entrySet();

Iterator<Entry<String, Student>>  ir3 =  es.iterator();
while (ir3.hasNext()) {
	Entry<String, Student> entry =  ir3.next();
	String key = entry.getKey();
	Student value = entry.getValue();
	System.out.printf(" key=%s - value=%s  \n", key, value );
}

LinkedHashMap<String, ArrayList<Member>> ht = new LinkedHashMap<>();
		
// 팀명을 저장하고 있는 배열X, ArrayList 
ArrayList<String> tnList = new ArrayList<>();
tnList.add("자바++");  // tnList.get(0)
tnList.add("목숨걸고");
tnList.add("가보자고");
tnList.add("Dev");
		
ArrayList<Member> team1 = new ArrayList<>();
team1.add(new Member("이재민", 90));
team1.add(new Member("강새암", 70));
team1.add(new Member("김지훈", 80));
		
ArrayList<Member> team2 = new ArrayList<>();
team2.add(new Member("권재현", 88));
team2.add(new Member("노용준", 56));
team2.add(new Member("박혜은", 80));
team2.add(new Member("엄택혁", 80));
	
ArrayList<Member> team3 = new ArrayList<>();
team3.add(new Member("김가율", 90));
team3.add(new Member("문혜빈", 70));
		 
ht.put(  tnList.get(0)  , team1 );
ht.put(  tnList.get(1)  , team2 );
ht.put(  tnList.get(2)  , team3 );
	   
Set<Entry<String, ArrayList<Member>>> es= ht.entrySet();
Iterator<Entry<String, ArrayList<Member>>>  ir = es.iterator();
	   
int no = 1;
while (ir.hasNext()) {
	Entry<String, ArrayList<Member>> entry =  ir.next();
	String teamName = entry.getKey();
	ArrayList<Member> mList = entry.getValue();
	System.out.printf("%d조 - %s ( %d명 )\n", no++, teamName, mList.size());
	// 
	Iterator<Member> ir2 = mList.iterator();
	int seq = 1;
	while (ir2.hasNext()) {
		Member m =   ir2.next();
		System.out.printf( "\t\t %d번 - %s\n", seq++,  m );
	} // while
} // while

class Member{
	String name;
	int score;
	
	public Member(String name, int score) {
		super();
		this.name = name;
		this.score = score;
	}

	@Override
	public String toString() {
		return "Member [name=" + name + ", score=" + score + "]";
	} 
}

해싱

1) 해싱 ? 해시 함수를 이용해서 (해시테이블에) 데이터를 저장하고 검색하는 기법.

해싱 구조 = 배열 + 링크드 리스트의 조합

2) 해시 함수 ? 데이터를 저장할 곳을 알려준다.

대량의 데이터 중에 원하는 데이터를 빠르게 검색할 수 있다.

3) 해싱을 구현한 클래스 : HashSet, HashMap, Hashtable 등등

* 예를들면 주민번호의 경우 해싱된 배열 칸(연도별로 해싱된 값이 배열에 저장되어있음) 에 가서 링크드 리스트로 연결된 것들 중에서 값을 찾는다!

* 배열을 사용하는 이유는 인덱스처럼 활용하기 위해서 (링크드 리스트로 구현될 경우 수정삭제는 빠르지만 접근이 느리기 때문에 X)

TreeMap

1) entry( key + value )

2) Tree 구조 - 정렬, 검색, 범위 검색 성능 빠르다.

TreeMap<String, Integer> tm = new TreeMap<String, Integer>();

// tm.ceilingEntry(null);
// tm.floorEntry(null)
// tm.firstEntry();
// tm.lastEntry();

// tm.get(key)
// tm.entrySet();

// tm.subMap(null, null)  부분 검색
// tm.headMap(null);
// tm.tailMap(null);

tm.put("a", 1);
tm.put("b", 2);
tm.put("c", 3);

// tm.entrySet();

Properties 컬렉션 클래스

1) Hashtable의 자식 클래스

2) key, value 모두 String 이다.

3) 유용한 메서드

프로그램 애플리케이션의 - "환경설정" 값 저장/읽기에 주로 사용

4) setProperty() / getProperty()

5) 파일의 확장자 : .properties

// Hashtable<String, String>
/* [ 오라클 DBMS 연결할 때 사용되는 환경 설정값. ]

*       key              value
String className = "oracle.jdbc.driver.OracleDriver";        fullname
String url       = "jdbc:oracle:thin:@localhost:1521:xe";    서버
String user      = "scott";                                  계정(사용자)
String password  = "tiger";		                             계정의 비밀번호
*/	
		
Properties  prop = new Properties();
		
prop.setProperty( "className", "oracle.jdbc.driver.OracleDriver" );
prop.setProperty( "url" , "jdbc:oracle:thin:@localhost:1521:xe" );
prop.setProperty( "user", "scott" );
prop.setProperty( "password",  "tiger"  );
// prop.put(key, value)     X	가능은 하지만 쓰지 않음 (부모가 해쉬테이블이니)	
// prop.get(key)            X
		
System.out.println(  prop.getProperty("className") );
System.out.println(  prop.getProperty("url") );
System.out.println(  prop.getProperty("user") );
System.out.println(  prop.getProperty("password") );
		
// C:\Class\WorkSpace\JavaClass\javaPro
String path =  System.getProperty("user.dir");
//System.out.println( path );
// 파일로 저장 -> 파일명.properties (보통 properties클래스 자료형으로 파일을 저장할때)
String fileName = path +"\\src\\com\\util\\jdbcXML.properties";

/*
try ( FileWriter fw = new FileWriter(fileName) ) {
	String content = String.format("%s=%s", "className",  prop.getProperty( "className"));
	fw.write(   content   +"\r\n"  );
	content = String.format("%s=%s", "user",  prop.getProperty( "user"));
	fw.write(   content  + "\r\n"  );
	
	System.out.println( "END");
} catch (Exception e) {
	e.printStackTrace();
}
*/	

try ( FileWriter fw = new FileWriter(fileName) ) {	
	// 환경설정값들을 직접 저장 코딩.  X
    String comments = ">  Oracle JDBC Configuration <";
    prop.store(fw, comments);
			
	System.out.println( "END");
} catch (Exception e) {
	e.printStackTrace();
}

* prop 메서드 (prop.store) 쓰면됨!! 자동으로 저장됨

.properties 파일 읽어오기

String path =  System.getProperty("user.dir"); 
String fileName = path +"/src/com/util/jdbcXML.properties";
		
try ( FileReader fr = new FileReader(fileName);
		BufferedReader br = new BufferedReader(fr)) {
	
		String line = null;
		Properties prop  = new Properties();
	
		while(  (line= br.readLine() ) != null ) {			
			// # 주석처리 제외 
			if( !line.startsWith("#") ) {
				System.out.println(  line );
				String [] kv = line.split("=");
				String key = kv[0];
				String value = kv[1];
				prop.setProperty(key, value);
			} // if
		} // while
			
		System.out.println(  prop );	
} catch (Exception e) {
	e.printStackTrace();
}

더 쉬운법! (prop.load 사용하면됨) Reader 객체인 fr 만 넣어주면 자동으로 읽어옴

String path =  System.getProperty("user.dir"); 
String fileName = path +"\\src\\com\\util\\jdbc.properties";
		
Properties prop  = new Properties();
		
//  prop.store(null, fileName);  // ****
try (FileReader fr = new FileReader(fileName); ) {	
	prop.load( fr );                     // ****
	System.out.println(  prop ); 		
} catch (Exception e) {
	e.printStackTrace();
}

XML로 저장하기! prop.storeToXML

Properties  prop = new Properties();
		
prop.setProperty( "className", "oracle.jdbc.driver.OracleDriver" );
prop.setProperty( "url" , "jdbc:oracle:thin:@localhost:1521:xe" );
prop.setProperty( "user", "scott" );
prop.setProperty( "password",  "tiger"  ); 
		
String path =  System.getProperty("user.dir"); 
String fileName = path +"\\src\\com\\util\\jdbcXML.properties"; 
		
try ( FileOutputStream fos = new FileOutputStream(fileName)  ) {	 
	String comments = ">  Oracle JDBC Configuration <";
    prop.storeToXML(fos, comments);		
	System.out.println( "END");
} catch (Exception e) {
	e.printStackTrace();
}

아까 prop.load로 얻어온 prop 객체의 모든 키값을 얻어와서 출력(확인)

String path =  System.getProperty("user.dir"); 
String fileName = path +"\\src\\com\\util\\jdbc.properties";	
// Hashtable 컬렉션 클래스 (부모)
Properties prop  = new Properties();		 
try (FileReader fr = new FileReader(fileName); ) {			
	prop.load( fr );                     
	System.out.println(  prop ); 			
} catch (Exception e) {
	e.printStackTrace();
}
// 1. Properties   모든 키값을 얻어와서 출력(확인)
//   ㄱ. prop.keySet();
// value = prop.getProperty(key)

//   ㄴ. 658  표 11-20 Properties 생성자 + 메서드 
//         propertyNames() :  모든 키(key) 가 담긴 열거자( enumeration) 을 반환하는 메서드
Enumeration<String>   en =  (Enumeration<String>) prop.propertyNames();
while (en.hasMoreElements()) {
	String key = en.nextElement();
	System.out.println( key );
}

System : 시스템 환경설정값을 가지고있는 Properties 객체! key값을 통해 value 얻어올수있다.

// String path =  System.getProperty("user.dir"); 
// 시스템의 환경설정값을 가지고 있는 객체 .
Properties  prop = System.getProperties();
		
Enumeration<String>   en =  (Enumeration<String>) prop.propertyNames();
while (en.hasMoreElements()) {
	String key = en.nextElement();
	System.out.printf("%s=%s\n",  key  , prop.getProperty(key) );
}

properties에서 읽어와서 값 가공

String path =  System.getProperty("user.dir"); 
String fileName = path +"\\src\\days26\\input.txt";	
		
// key=value
Properties p = new Properties();
p.load( new FileReader(fileName) );
		
String name =  p.getProperty("name");
String data =  p.getProperty("data");  // "9,1,5,2,8,13,26,11,35,1"
String [] datas = data.split(",\\s*"); //,로 나눠주고 s=공백이있어도좋고없어도좋고 * 마지
int max, min , tot = 0;
double avg;
		
max = min = Integer.parseInt(datas[0]);
		
for (int i = 0; i < datas.length; i++) {
		tot += Integer.parseInt(datas[i]);
		int value =  Integer.parseInt(datas[i]);
	  
		if( max < value ) {
				max = value;
		}else if( min > value ) {
                min = value;				  
		}	  
}
		
avg = (double)tot / datas.length;
System.out.printf("이름 : %s\n", name);
System.out.printf("합계 : %d\n", tot);
System.out.printf("평균 : %.2f\n", avg);

Collections

Collecion클래스를 다룰 수 있는 Collections 클래스

ArrayList , HashMap 동기화 처리 X + 동기화 처리 하고 싶다..

synchronized 키워드 = 스레드 + 동기화 처리

[synchronized]Collection()

[synchronized]List()

[synchronized]Set()

[synchronized]Map()

등등

Vector , Hashtable 동기화 처리 O

2) 변경 불가 컬렉션 만들기.

[unmodifiable]Collection()

[unmodifiable]List()

[unmodifiable]Set()

[unmodifiable]Map()

3) 싱글톤 컬렉션 만들기 - 단 하나의 객체만을 저장하는 컬렉션

[singleton]List()

[singleton]Map()

4) 한 타입의 객체만 저장하는 컬렉션 만들기

[checked]Collection();

[checked]List();

[checked]Set();

import static java.util.Collections.*; 하면 바로사용가능

List  list = new ArrayList();

//Collections.addAll( list , 3,5,2,4,1 );
addAll( list , 3,5,2,4,1 );	

//int [] m = { 3,5,2,4,1};
// addAll(list, m);  // T...args 가변인자
				
sort(list);  // asc
sort(list, reverseOrder());  // desc
		
shuffle(list);  // [2, 4, 1, 3, 5]   [3, 2, 4, 1, 5]
System.out.println(  list );
		
//fill(list, -1); 동일한 값 채워넣음
		
int index = binarySearch(list, 3); // 인덱스 반환
System.out.println( index ); // 없으면 -6

int max = (int) max(list);

1. 제네릭( Generics )

* ㄱ. JDK1.5 처음 도입

* ㄴ. JDK1.8 처음 도입 - 람다식

* ㄴ. 컴파일 할 때 타입 결정해 주는 기능

* ? 다양항 타입(자료형)의 객체 -> 메서드(), 컬렉션 클래스에 다룰 때

* 이유 ? 1) 객체 타입의 안전성

* 2) 형변환 번거로움을 줄일 수 있다.

* 2. 제네릭 장점

* 1) 타입의 안정성

* 2) 타입체크 + 형변환 생략 -> 코드 간결.

// "제네릭 클래스" 선언

// 1) Box<T> : Box 제네릭 클래스

// 2) Box : 원시 타입

// 3) T : 타입 변수 또는 타입 매개변수 ( T 타입문자 )

// E element

// K key

// V value

// T type

// 등등 맘대로 이름 주면

// 1) 타입 안정성

Box<Integer> box1 = new Box<Integer>(3.14);
Box<Integer> box1 = new Box<Integer>(14);

int value = box1.getValue();

Box<Double> box2 = new Box<Double>(3.14);
double value2 = box2.getValue();  // 형변환 필요 X

// 컴파일 시 T 결정

class Box<T>{

	// field
	private T value;  

	// constructor
	public Box(T value) {
		super();
		this.value = value;
	}

	// getter, setter
	public T getValue() {
		return value;
	}

	public void setValue(T value) {
		this.value = value;
	}    
}

제네릭의 제한

* 제네릭 클래스 선언

* class Box<T>{

* 스태틱 멤버 사용 가능 ?

* static T value;

* static int compare( T t1, T t2){}

* T [] toArray(){

* T [] temp = new T[10]; // 제네릭 배열

* return temp;

* }

* 1. 제네릭의 제한 ?

* 1) 스태틱 멤버는 사용(선언)할 수 없다.

* 2) new T[10] 제네렉 배열은 사용할 수 없다.

* 즉, new, instanceof 연산자 사용하는 배열 X

* */

제네릭 클래스의 객체 생성과 사용

Box2<Fruit>  fruitBox = new Box2<Fruit>();
fruitBox.add( new Fruit());
fruitBox.add( new Apple());
fruitBox.add( new Grape());		
System.out.println(  fruitBox );  // [과일, 사과, 포도]
		
// Type mismatch: cannot convert from Box2<Grape> to Box2<Apple>
// Box2<Apple>  appleBox = new Box2<Grape>();
		
// The method add(Fruit) in the type Box2<Fruit> is not applicable for the arguments (Toy)
// fruitBox.add(  new Toy() );

ArrayList<Integer>  list = new ArrayList<Integer>();
list.add(100);
// list.add( 3.14);

// 과일  클래스 
class Fruit  implements Eatable{    public String toString() { return "과일"; 	}  }
class Apple extends Fruit{ 	public String toString() {		return "사과";	}}
class Grape extends Fruit{ 	public String toString() {		return "포도";	}}

// 장난감
class Toy{    public String toString() { return "장난감"; 	}  }

// 제네릭 클래스 선언
class Box2<T>{
	ArrayList<T> list = new ArrayList<T>();
	void add(T item) {  list.add(item); }
	T get(int idx) {  return this.list.get(idx) ;  }
	int size() { return this.list.size(); }
	public String toString() { return list.toString(); }
}

-> Fruit이 제네릭으로 들어가면 Apple, Grape 인스턴스 모두 집어넣기 가능

제한된 제네릭 클래스 (이건 앞의 제한이랑 다름)

인스턴스 생성할 때

public class Ex14 {
	public static void main(String[] args) {
		// 과일상자 - 사과, Grape
		//               - 장난감                   X 제한
		FruitBox<Apple> fbox = new FruitBox<>();
		FruitBox<Grape> gbox = new FruitBox<>();
		
		// 사용할 수  없다. 
		// FruitBox<Toy> tbox = new FruitBox<>();   // 제한 	
	} // main
} // class

interface Eatable{}

// 타입 제한 -  Fruit 클래스 상속 and Eatable 인터페이스를 구현한 클래스(타입)으로 제한
class FruitBox<T extends Fruit  & Eatable>{   // T 타입을 제한합니다.     제한된 제네릭 클래스	
	ArrayList<T> list = new ArrayList<T>();
}

-> 객체 생성할 때 제네릭 T의 자료형을 제한할 수 있다는 말임 (클래스, 인터페이스 가능)

public class Ex02 {

	public static void main(String[] args) {

		FruitBox<Apple> appleBox = new FruitBox<>();
		Juice appleJuice = Juicer.makeJuice(appleBox);
		
		
		FruitBox<Grape> grapeBox = new FruitBox<>();
		/// The method makeJuice(FruitBox<Apple>) in the type Juicer
		// is not applicable for the arguments 
		Juice grapeJuice = Juicer.makeJuice(grapeBox);

		/*
		p 686 제일 하단 설명. 
		Collections.sort(null);
		@SuppressWarnings("unchecked")
	    public static <T extends Comparable<? super T>> void sort(List<T> list) {
	        list.sort(null);
	    }
	    */
		
		
		// p 687 제네릭 타입의 형변환
		// p 689 제네릭 타입의 제거
		// ArrayList  list = new ArrayList();  // 호환성
	} // main

} // class

class Fruit{ public String toString() { return "과일"; }  }
class Apple extends Fruit { public String toString() { return "사과"; }  }
class Grape extends Fruit{ public String toString() { return "포도"; }  }

class FruitBox<T extends Fruit >{  // 제한된 제네릭 클래스 
	ArrayList<T> list = new ArrayList<T>();
}

// 쥬스
class Juice{}

// 쥬스 만드는 기계 + 사람
class Juicer{
	
	/*
	// 오버로딩 X == 중복 함수  X
	// 과일상자 -> 쥬스 만드는 메서드 

	*/
	
	/*
	// 와일드 카드 사용 - 매개변수 구현(선언)
	static Juice makeJuice( FruitBox<? extends Fruit>  box ) {
		return new Juice();
	}
	*/
	
	// 제네릭 메서드로 선언
	static <T extends Fruit> Juice makeJuice( FruitBox<T>  box ) {
		return new Juice();
	}
}

와일드 카드 (=?, 물음표)

<? extends T> : T와 그 자손들만 가능

<?> == <? extends Object> : 모든 타입이 가능, 제한 없음

<? super T> : T와 그 조상들만 가능

// 자동 업캐스팅
// Employee emp = new Regular();
		
Vector<Regular>  v1 = new Vector<Regular>();
v1.add(new Regular());
v1.add(new Regular());
v1.add(new Regular()); 
		
// Type mismatch: cannot convert from Vector<Regular> to Vector<Employee>
// Vector<Employee>  v2 = v1;
		
Vector<?  extends  Employee>  v2 = v1;
		
// v2.addAll(    Collection<? extends Employee > c )
	
// Collection c 
// ArrayList<Temp> list -> List -> Collection
		
ArrayList<Temp>  list = new ArrayList<Temp>();
list.add(new Temp());
list.add(new Temp());
list.add(new Temp());
		
// v2.addAll( list );

저작자표시

'👨‍💻 Web Development > Java' 카테고리의 다른 글

[Day28] Java 28 - 보조스트림, File 객체 (0)	2022.09.20
[Day27] Java 27 - Enum, 어노테이션, 입출력(I/O), 문자/바이트 스트림 (0)	2022.09.20
[Day25] Java 25 - PriorityQueue, ListIterator, Arrays메서드, HashSet, LinkedHashSet, TreeSet (0)	2022.09.18
[Day24] Java 24 - 컬렉션 프레임워크(JCF), ArrayList, Vector, Iterator/enumerator, LinkedList, Stack, Queue (0)	2022.09.17
[Day23] Java 23 - java.time활용 (0)	2022.09.17

[Day26] Java 26 - HashMap, Hashtable, Properties, Collections, 제네릭 (클래스,인스턴스,와일드카드)

[Day26] Java 26 [9/15]

'👨‍💻 Web Development > Java' 카테고리의 다른 글

전체 카테고리

블로그 인기글

티스토리툴바

[Day26] Java 26 [9/15]

'👨‍💻 Web Development > Java' 카테고리의 다른 글

전체 카테고리

최근 글

최근댓글

블로그 인기글

티스토리툴바