국비 교육 26일차 - 라이브러리활용(Vector, Map, Generics...)

오늘한 내용은 비교적 어렵지 않은 내용들이었고, 주로 원래 배운 개념들에서 조금 다른 응용을 가지고 있는 것들이었다. 먼저 어제 배운 ArrayList 와 같은 List이지만 동기화로 저장되는 Vector를 배웠다. 

 

package com.sist.main;
/*
 * 	java.lang
 * 	=========
 * 		Object => 모든 클래스를 모아서 관리 (모든 데이터형을 받을 수 있다)
 * 				  형변화
 * 				  Object obj=new String()
 * 				  String str=(String)obj;
 * 				 => 자바에서 제공하는 메소드 중에 클래스를 리턴형으로 갖는 경우
 * 					모든 메소드가 Object로 넘어감 (형변환 필요)
 * 					ArrayList => 저장된 값을 읽어 온다
 * 								public Object get(int index) => (String)list.get(0)					  
 * 
 * 		String => 웹, 모바일, 윈도우 => 문자열로 처리
 * 		Wrapper => Integer, Double, Boolean => 문자열을 변환
 * 				 parseInt() parseDouble() parseBoolean
 * 		StringBuffer => 파일에 저장된 문자열이 길 경우 => append
 * 	java.util
 * 	=========
 * 		StringTokenizer : 구분문자로 문자열을 자른다 (split-배열로 잘라옴)
 * 						  =================== 영화, 맛집, 여행 => 이미지가 여러개 나옴, 이미지명
 * 		Date : 시스템의 날짜 = 오라클
 * 		Calendar : 달력 (날짜 조작)
 * 		SimpleDateFormat, MessageFormat(웹=> layout), ChoiceFormat(switch, if문으로 대체할 수 있음)
 * 		
 * 		자료구조
 * 		List : ArrayList(데이터베이스), Vector(네트워크), LinkedList, Stack
 * 			   
 * 		Set : Hashset, TreeSet
 * 			  ======= 중복없는 데이터를 저장	
 * 
 * 		Map : HashMap, HashTable, Properties => session(서버), cookie, request, response
 * 			  =======
 * 				Spring, MyBatis
 * 		
 * 		==> 형변환이 없이 Collection - 데이터형을 통일화 (제네릭스) <TYPE>
 * 		==> 메소드 구분, 클래스 찾기 (인덱스) => if대신 사용할 수 있는 것 - 어노테이션		
 */
// Vector: 네트워크 (ip, port) => Socket => 동기화 
/*
 * 	java.util => import를 반드시 사용 => import java.util.Vector, import java.util.*;
 * 
 * 	Vector: 동기화 => 데이터수집(10000개의 레시피 => 15만개 정도의 데이터) => Thread
 * 	======
 * 	List => 순서가 있다, 중복 데이터 저장이 가능
 * 			======== 인덱스 번호
 * 			자료구조 : CURD(저장, 수정, 읽기, 삭제)
 * 				= 읽기 (데이터를 가지고 온다) => get(인덱스번호), elementAt(인덱스)
 * 				= 저장 => add(), addElement() 
 * 				= 수정 => set(), setElement()
 * 				= 삭제 => remove(), removeElementAt()
 * 				= 갯수 => size()
 * 
 * 				public interface List
 * 				{
 * 					add();
 * 					set();
 * 					remove();
 * 					size();
 * 					get();
 * 				}
 * 				public class Arraylist implements List
 * 				{
 * 					add(){};
 * 					set(){};
 * 					remove(){};
 * 					size(){};
 * 					get(){};
 * 				}
 * 				public class Vector implements List
 * 				{
 * 					add(){};
 * 					set(){};
 * 					remove(){};
 * 					size(){};
 * 					get(){};
 * 				}
 * 				public class LinkedList implements List
 * 				{
 * 					add(){};
 * 					set(){};
 * 					remove(){};
 * 					size(){};
 * 					get(){};
 * 				}
 * 
 * 				List list = new ArrayList();
 * 				List list = new Vector();
 * 				List list = new LinkedList();
 * 
 */	
import java.util.*;

public class MainClass {

	public static void main(String[] args) {
	Vector vec=new Vector(); // 일반 클래스
	// add() 한개씩 첨부, addAll()
	Collections.addAll(vec, "이제노", "황런쥔", "박지성", "종천러"); // 뒤의 데이터를 앞의 주소값에 한번에 저장하라
	Collections.sort(vec);
	// Collections - 전체를 모아서 한번에 처리가 가능함
	System.out.println(vec.size());
	for(int i=0; i<vec.size(); i++)
	{
		String name=(String)vec.get(i);
		System.out.println(name);
	}
	

	}

}

ArrayList와 마찬가지로 add(). get(), size(), set(), remove() 의 메소드를 활용해서 데이터를 추가, 읽기, 수정, 지우기 등등을 구현할 수 있다. 쓰는 방법은 거의 똑같다. 

 

반면 HashSet은 컬랙션이긴 하지만 데이터의 중복을 허락하지 않는다. 그렇기 때문에 자동으로 데이터의 중복을 걸러준다. 

 

package com.sist.main;
import java.util.*;
/*
 * 	T => Type ArrayList<Integer>
 * 	E => Element Vector<String>
 * 	K => Key 	Map<String, Integer>
 * 	V => Value	
 * 
 * 	1, "", 10.9, new A(), 10, new B(), "", 3
 */
public class MainClass2 {

	public static void main(String[] args) {
		/*
		 * CURD
		 * C => Create => add() 
		 * U => Update => set()
		 * R => Read => get()
		 * D => Delete => remove()
		 */
		Vector vec=new Vector();
		
		//추가 => Object 
		//영화 장르
		
		vec.add("액션영화");
		vec.add("드라마");
		vec.add("멜로");
		vec.add("코미디");
		vec.add("판타지");
		vec.add("SF");
		vec.add("애니메이션");
		vec.add("멜로");
		vec.add("코미디");
		vec.add("판타지"); // 인덱스 번호로 저장했기 때문에 데이터가 중복되어도 괜찮음
		
		HashSet set=new HashSet();
		for(int i=0; i<vec.size(); i++)
		{
			String genre=(String)vec.get(i);
			set.add(genre);
			
		}
		System.out.println(set); // [코미디, 판타지, SF, 드라마, 멜로, 애니메이션, 액션영화] - 중복이 없어짐

		/*System.out.println("======== 저장된 장르 ========");
		System.out.println("장르:"+vec.size());
		// 출력
		for(int i=0; i<vec.size(); i++)
		{
			String genre=(String)vec.elementAt(i);
			System.out.println(genre);
		}
		
		// 수정
		System.out.println("======== 데이터 수정 ========");
		vec.setElementAt("호러", 9); //vec.set
		
		
		// 출력
		for(int i=0; i<vec.size(); i++)
		{
			String genre=(String)vec.elementAt(i);
			System.out.println(genre);
		}
		
		System.out.println("======== 데이터 삭제 =======");
		vec.removeElementAt(8);
		for(int i=0; i<vec.size(); i++)
		{
			String genre=(String)vec.elementAt(i);
			System.out.println(genre);
		}
		
		System.out.println("======== 전체 삭제 =======");
		vec.removeAll(vec);
		System.out.println("장르 갯수:"+vec.size());*/
		
		
		
	}

}

LinkedList역시 배웠는데, 앞으로 나올일이 거의 없다고 해서 그냥 블로그에 적지는 않겠다..

 

그 다음에는 Properties에 대해 배웠는데 잘 생각이 안난다.... 아 지금 보니까 아직 제대로 배운건 아닌거 같다. 

일단  컬렉션 중 Map은 웹에서 많이 사용되고, key 와 value 값을 같이 저장해준다. 

js에서의 Object와 똑같다. 그래서 아 이런식으로 유사한 점이 있구나 하고 이해했다. 

 

package com.sist.main;
/*
 * 	Map, Properties 
 * 	===============
 * 	Map => 두가지 저장 (key, value) : 클래스를 저장, SQL문장 저장, 웹과 관련된 클래스들
 * 	==
 * 	1. 저장 => put()
 * 	2. 읽기 => get(key) => value을 얻어 온다.
 * 
 * 	java.util.*
 * 	Map => Interface
 * 	=== HashMap
 * 	
 */
import java.util.*;
public class MainClass {

	public static void main(String[] args) throws Exception {
		HashMap map=new HashMap();
		map.put("id", "admin"); 
		map.put("pwd", "1234");
		map.put("name", "renjun");
		map.put("sex", "남자"); // 키(중복할 수 없다). 값(중복할 수 있다)
		map.put("sex", "여자");

		// 값 읽기
		System.out.println("ID:"+map.get("id"));
		System.out.println("PWD:"+map.get("pwd"));
		System.out.println("NAME:"+map.get("name"));
		System.out.println("SEX:"+map.get("sex")); // 여자로 나옴
		// 오류가 나는 것은 아님, 그냥 마지막값으로 덮어씌워지는 것
		
		
		
	}

}

 

예제 연습해 보다가 새롭게 출력하는 메소드를 찾아냈다. 

 

import java.util.*;
public class MainClass {

	public static void main(String[] args) throws Exception {
		HashMap map=new HashMap();
		map.put("id", "renjun");
		map.put("aka", "pureboy");
		map.put("age", "secret");
		
		System.out.println(map.entrySet());
		
		
		
	}

entrySet()이라는 메소드인데, 이걸 사용해서 출력해준 결과는 아래와 같다. 

key값과 value값을 한번에 가져오는거 같다. 일단 두개가 일치해서 세트로 오긴하는데, 순서대로 출력되는게 아니라 랜덤으로 나오는거 같다. 그리고 형태를 보니 리턴값은 배열인거 같은데... 

 

js할때도 항상 key값이 필요한 순간들이 있었는데, 왠지 자바할때도 마찬가지 일것 같다는 생각이 든다. 

일단 뭐 차차 알아가게 되겠지만.

 

package com.sist.main;

import java.util.HashMap;

interface I
{
	public void display();
}

// 상위 클래스인 I로 하나로 묶어줌 - 관련된 클래스를 묶어서 한개의 이름으로 제어
class A implements I
{
	public void display()
	{
		System.out.println("A:display Call...");
	}
}
class B implements I
{
	public void display()
	{
		System.out.println("B:display Call...");
	}
}
class C implements I
{
	public void display()
	{
		System.out.println("C:display Call...");
	}
}
class Container
{
	HashMap map=new HashMap();
	public Container()
	{
		// 클래스를 저장
		map.put("a", new A()); // 클래스의 주소값을 저장해주는 것, 메모리를 한번 저장하면 바뀌지 않고 여러번 사용 가능 = 싱글턴
		map.put("b", new B());
		map.put("c", new C());
	}
	public I getBean(String key)
	{
		return (I)map.get(key);
	}
}
public class MainClass3 {

	public static void main(String[] args) {
		
		Container con=new Container();
		I i = con.getBean("a");
		i.display(); //A:display Call...
		System.out.println("i="+i);

		i = con.getBean("b");
		i.display(); // B:display Call...
		System.out.println("i="+i);
		
		i = con.getBean("c");
		i.display(); // C:display Call...
		System.out.println("i="+i);
		
		i = con.getBean("a");
		i.display(); //A:display Call...
		System.out.println("i="+i); // 주소가 같음 
		
	}

}

tkd상위 클래스인 인터페이스 I 를 이용해서 하나로 묶어준다. 그리고 Container 클래스에서 HashMap을 사용해서 각각의 클래스들의 주소값을 map의 value값으로 저장해줬다. 

 

getBean이라는 메소드가 정확히 무엇인지 아직은 모르겠으나, key값을 통해 map에 있는 value값들을 호출하는 역할을 하는거 같다. 그래서 아래 main에서 실행시켜주면 각각의 결과값들을 얻을 수 있다. 

 

그 다음은 제네릭스에 대해 배웠다. 

책에 있는 정의를 그대로 가져다 쓰자면

 

"다양한 타입의 객체들을 다루는 메소드나 컬렉션 클래스에 컴파일 시의 타입 체크를 해주는 기능이다. 객체의 타입을 컴파일 시에 체크하기 때문에 객체의 타입 안정성을 높이고 형변환의 번거로움이 줄어든다."

 

한마디로 컬렉션에서 같은 데이터형끼리만 묶어줄 수 있도록 하는 기능이다. 

이렇게 되면 형변환을 안시켜줘도 된다는 장점이 있고, 같은 데이터형끼리 묶여있기 때문에 제어가 쉽다. 

package com.sist.main;
/*
 * 	제네릭스 : 데이터형을 통일해서 사용
 * 	형식) <className> => 자바에서 제공하는 컬렉션의 모든 데이터형이 Object로 되어있음 
 * 		=> Object를 다른 데이터형으로 변환
 * 		장점:
 * 			1. 데이터형의 안정성
 * 			2. 형변환이 없고 소스가 간결하다
 * 		예) ArrayList<String> 
 * 			ArrayList<int> => (X) ArrayList<Integer>
 * 			ArrayList<MovieVO> 
 * 		public class ArrayList<T>
 * 		{
 * 			T t;
 * 			public ArrayList()
 * 			{
 * 				if(제네릭스가 없는 경우)
 * 				{
 * 					T=Object	
 * 				}
 * 			}
 * 			public void add(T t)
 * 			{
 * 			
 * 			}
 * 			public T get(int index)
 * 			{
 * 			}
 * 			public void set(int index, T t)
 * 			{
 * 			}
 * 		}
 * 
 * 		ArrayList<String> => T => String으로 변경되어 들어옴
 */
class Box<T> // T=> 타입 (클래스 이름 들어가야함)
{
	T item;
	public void setItem(T item)
	{
		this.item=item;
	}
	public T getItem()
	{
		return item;
	}
}
/*
 * 	T => Type (type=class)
 * 	E => Element (값)
 * 	K => Key
 * 	V => Value
 */
public class MainClass {

	public static void main(String[] args) {
		
		Box box=new Box();
		Box<String> box1=new Box<String>();
		String s=box1.getItem();
	}

}

<String> 이렇게 컬렉션을 만들때 뒤에 붙여주면, 그 컬렉션안에는 String 데이터형만 저장이 된다. 

데이터 형은 우리가 만든 class 들과 같은 참조형 데이터들도 포함이 되기 때문에, 나중에 프로그램을 짤때 이것을 잘 활용해주면, Object 로 받아서 형변환을 꼭해줘야 하는 일이 발생하지 않게 된다. 

 

package com.sist.main;
import java.util.*;
// 제네릭스는 컬렉션에서만 사용
/*
 * ArrayList<>, Vector<>, LinkedList<> Map<K,V> => 데이터를 통일(관련된 데이터만 묶어서 저장 후 사용)
 */
class A 
{
	
}
public class MainClass2 {

	public static void main(String[] args) {
		
		ArrayList<String> list =
					new ArrayList<String>();
		// 저장
		list.add("jeno");
		list.add("renjun");
		
		// read value
		String name1=list.get(0);
		String name2=list.get(1);
		
		System.out.println(name1);
		System.out.println(name2);
		
		
		ArrayList<Integer> list2=new ArrayList<Integer>();
		list2.add(55);
		list2.add(52);
		
		int weight1=list2.get(0);
		int weight2=list2.get(1);
		
		System.out.println("weight of "+name1+":"+weight1);
		
		ArrayList<A> list5=new ArrayList<A>();
		
	}

}

이렇게 지정해주면 add() 메소드를 쓸때 뒤에 String. Integer와 같은 지정된 데이터 형들만 써줄 수 있다. 

일단은 이렇게만 이해하라고 알려주셔서 믿고 갑니다...

 

그 다음은 annotation에 대해서 배웠는데, 솔직히 처음엔 도대체 무슨말인지 아예 이해를 못했다. 

근데 예제를 쓰는걸 보고 대충 이런거겠구나 감을 잡긴했다. 

 

package com.sist.main;
import java.util.*;
// annotation -> 구분자(인덱스) : 기능은 없다 => if문 대신 사용한다
/* 자바에서는 거의 없다 : 라이브러리(spring, mybatis)에서 사용됨
 * 자동화 처리
 * 사용법: @AAA
 * 	
 * 1. 클래스
 * 2. 메소드
 * 3. 매개변수
 * 4. 생성자
 * 5. 멤버변수
 * 
 * 	@Type
 * 	public class className
 * 	{
 * 		@Field
 * 		BoardVO vo;
 * 		@Constructor
 * 		public 생성자()
 * 		{
 * 		}
 * 
 * 		@Mehtod
 * 		public void setA(@Parameter A a)
 * 		{
 * 		}
 * 	}
 * 
 */
public class MainClass3 {

	public static void main(String[] args) {
		
	}

}

그니까 한마디로 말하면 1.클래스, 2.메소드 3. 매개변수, 4. 생성자. 5.멤버변수를 가르키는 인덱스처럼 활용된다고 생각하면 된다. 위의 코드는 어노테이션이 어느 위치에 있어야 하는지를 보여주는 것이다. 

이걸 활용한 예제를 봤는데.. 좀 어려워서 중간에 또 가슴이 콩닥콩닥했는데.... 일단은 인덱스처럼 필요한 5개중 하나의 것들을 가져와주는 역할을 한다고만 이해를 우선 했다.

 

package com.sist.anno;

public class MovieManager {
	
	
	@RequestMapping("home") // 인덱스처럼 사용하는 것-메소드를 찾아와서 호출함
	public void movieHome() // 사용자가 입력하는 값을 매개변수로 받을 예정 (홈)
	{
		System.out.println("movie home");
	}
	@RequestMapping("list")
	public void movieList() //목록
	{
		System.out.println("movie list");
	}
	@RequestMapping("detail")
	public void movieDetail() // 상세
	{
		System.out.println("movie detail");
	}
	@RequestMapping("reserve")
	public void movieReserve() // 예매
	{
		System.out.println("movie reserve");
	}
	@RequestMapping("find")
	public void movieFind() // 찾기
	{
		System.out.println("movie find");
	}
}

위의 코드 같은 경우에는 메소드 자체를 가져오기 위해서 저 위치에 써주었으며, key값으로는 각자 맞는 것들을 가져왔다. 

 

package com.sist.anno;

import java.lang.reflect.Method;

public class MovieSystem {
   public static void main(String[] args) {
	     MovieSystem ms=new MovieSystem();
	     ms.movie("home");
   }
   public void movie(String menu)
   {
	   try
	   {
		   
		   Class clsName=Class.forName("com.sist.anno.MovieManager");// 클래스의 정보를 가지고 온다
		   // 메모리 할당 
		   Object obj=clsName.getConstructor().newInstance();
		   // MovieManager m=new MovieManager()
		   // clsName가 가지고 있는 모든 메소드를 가지고 온다 
		   Method[] methods=clsName.getDeclaredMethods();
		   for(Method m:methods)
		   {
			   //System.out.println(m.getName());
			   RequestMapping rm=m.getAnnotation(RequestMapping.class);
			   if(rm.value().equals(menu))
			   {
				   m.invoke(obj, null);
				   break;
			   }
		   }
	   }catch(Exception ex){}
   }
}

그리고 위의 코드로 실행... 해줬는데...

여기서 진짜 또 이해가 안되서 뭐라는걸까.. 하면서 들었다. 강사님이 그냥 지금은 이해못해도 된다고 해주셔서 다행이었다. 대충 이런 방식으로 annotation에서 정해준 값들을 가져오는거라고 한다...

 

녜..

 

 

package com.sist.lib;

/*
 * 	java.lang
 * 	 Object 
 * 		= clone() : 복제
 * 		= toString() : 문자열 변환
 * 	 String
 * 		= length() : 문자 갯수
 * 		= equals() : 문자열 비교 (대소문자 구분)
 * 		= substring() : 문자를 자를때 사용
 * 		= indexOf(), lastIndexOf() : 문자 찾기
 * 		= trim(): 공백문자 제거
 * 		= replace() : 문자를 변경
 * 		= valueOf() : 모든 데이터형을 문자열로 변환
 * 		= split() : 문자열 구분해서 분리 
 * 		= contains() : 포함 문자
 * 	 StringBuffer
 * 		= append() : 문자열 결합 (최적화-속도 빠르게 할때)
 * 	 Integer
 * 		= parseInt() : 문자열을 정수로 변환
 * 	 Double
 * 		= parseDouble() : 문자열을 실수형으로 변환
 * 	 Boolean
 * 		= parseBoolean() : 문자열을 boolean형으로 변환
 * 	 Math
 * 		= random() : 난수발생
 * 		= ceil() : 올림
 * 	
 * 	java.util
 * 	 StringTokenizer
 * 		= hasMoreTokens() => while()
 * 		= nextToken() : 자른 문자열을 한개씩 가지고 올때
 * =================================================
 * 	 ArrayList
 * 		= add()
 * 		= size()
 * 		= get()
 * 	 Vector
 * 		= addElement() => add
 * 		= size()
 * 		= elementAt() => get
 * 	 HashMap
 * 		= put() : 저장
 * 		= get() : 읽기
 * ================================================= Collection-데이터형처리=>데이터형 통일(제네릭스)<Type>
 * 어노테이션 : 인덱스 (찾기 위한 구분자)
 * 클래스의 구성 요소 => 찾기 위한 구분을 시켜준다 => 제어역전(IoC)=>마틴 파울러
 * 	1. 클래스
 * 	2. 메소드 ==> 5. 매개변수
 * 	3. 멤버변수
 * 	4. 생성자
 * 이 다섯가지를 찾아주는 역할을 하는 것이 annotation
 * 	==================================	
 * 	 Properties
 * 		= load() : 파일읽기 (.properties)
 * 		= getProperty()
 * 	================================== 파일 (key=값)
 * 	 Date : 시스템 날짜를 읽어 온다 ==> 생성 (Date date=new Date())
 * 		오라클
 * 		데이터형
 * 		CHAR, VARCHAR2, CLOB ==> String
 * 		NUMBER				 ==> int, double
 * 		DATE, TIMESTAMP 	 ==> Date	
 * 		BLOB, BFILE			 ==> InputStream
 *   Calendar : 달력
 *   	= month : 0~11
 *   	= week : 1~7
 * 	java.text
 * 	 SimpleDateFormat
 * 		= format() 
 * 		= yyyy, MM, dd, hh, mm, ss
 * 	
 * 	기타 라이브러리
 * 	========== jsoup, simple-json, jaxb
 * 	
 * 	java.sql:오라클
 * 
 */
//Sawon 데이터형 (사용자 정의 데이터형)
/*
 * 	기본 데이터형 : 메모리에 값 자체를 저장
 * 	참조 데이터형 : 여러개의 데이터가 저장이 되기 때문에 저장된 위치(주소, 번지)를 확인
 * 	=========
 * 		프로그래머가 직접 제작 (같은 데이터형을 저장(배열), 다른 데이터형을 저장(클래스))
 * 		
 * 		Object obj=new A();
 * 		double 		int
 * 		
 * 		A a=new Object();
 * 		int 	double ==> 에러남
 */
import java.util.*;
class Sawon
{
	private int sabun;
	private String name;
	private String dept;
	private String job;
	private int pay;
	
	// 초기값
	public Sawon(int sabun, String name, String dept, String job, int pay) {
		// 생성자 함수 만들어줌
		this.sabun = sabun;
		this.name = name;
		this.dept = dept;
		this.job = job;
		this.pay = pay;
	}
	
	public void print()
	{
		// 출력하는 메소드를 만들어준것
		System.out.println("사번:"+sabun);
		System.out.println("이름:"+name);
		System.out.println("부서:"+dept);
		System.out.println("직위:"+job);
		System.out.println("연봉:"+pay);
	}
	
}
public class MainClass {
	public static void main(String[] args) {
		// 1. 사원 저장
		//Sawon sa1=new Sawon(1, "이제노", "개발부", "대리", 4000);
		//sa1.print();
		// 미리 Collection에 이런 데이터를 저장한다 알려주면 => 데이터형이 Object인 것을 알려준 데이터형으로 변경
		// 한 번에 제어-Collection
		ArrayList<Sawon> list=new ArrayList<Sawon>(); // Sawon[] => 데이터는 제어가 쉽게 같은 종류만 모아서 통일
		list.add(new Sawon(1, "이제노", "개발부", "대리", 4000)); //0
		list.add(new Sawon(2, "나재민", "개발부", "대리", 4000)); //1
		list.add(new Sawon(3, "황런쥔", "개발부", "대리", 4000)); //2
		list.add(new Sawon(4, "이동혁", "개발부", "대리", 4000)); //3
		list.add(new Sawon(5, "박지성", "개발부", "대리", 4000)); //4
		list.add(new Sawon(6, "종천러", "개발부", "대리", 4000)); //5
		
		// 순서가 있다(인덱스 번호), 중복된 데이터 첨부
		
		for(Sawon s: list)
		{
			
			s.print();
			System.out.println("=================");
		}
		
		ArrayList list1=new ArrayList();
		list1.add(new Sawon(1, "이제노", "개발부", "대리", 4000)); //0
		list1.add(new Sawon(2, "나재민", "개발부", "대리", 4000)); //1
		
		for(Object o: list1)
		{
			Sawon s=(Sawon)o;
			s.print();
		}
		
		HashMap<String, String> map=new HashMap<String, String>(); //<K-키, V-값>
		map.put("id", "admin");
		String id=map.get("id");
		System.out.println(id);
		
		
		// 밑에는 같은 기능의 코드
		HashMap map1 = new HashMap();
		map1.put("id", "hong");
		id=(String)map1.get("id");
		System.out.println(id);
		id=map1.get("id").toString();
		System.out.println(id);
		
		
		
		
		
		
	}

}

 

오늘 배운것을 총정리한 코드였다. 눈으로 쭉보니 이해 안가는 부분은 없어서 일단 넘어가겠다. 

위에서 정리했던걸 그대로 반복하는 코드여서 그래도 될것 같다..

 

오늘의 복습 끝