컬렉션 프레임워크

package kr.or.ddit.collection;

import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.Vector;

public class CollectionTest {
public static void main(String[] args) {
		/*
		 * 컬렉션 프레임워크
		 * 
		 * 널리 알려져 있는 자료구조를 사용해서 객체들을 효율적으로
		 * 추가, 삭제, 검색할 수 있도록 인터페이스와 구현 클래스를
		 * java.util 패키지에서 제공한다
		 * 이들을 총칭해서 컬렉션 프레임워크라고 한다.
		 * 
		 * 컬렉션 프레임워크의 주요 인터페이스로는 List, Set, Map이 있다.
		 * 이러한 인터페이스 List, Set, Map으로 사용 가능한 컬렉션 클래스가 아래에 있다.
		 * 
		 * List
		 *  - ArrayList
		 *  - LinkedList
		 *  - Vector
		 *  
		 * Set
		 *  - HashSet
		 *  - TreeSet
		 *  
		 * Map
		 *  - HashMap
		 *  - HashTable
		 *  - TreeMap
		 *  - Properties
		 *  */
	
		/*
		 * 1. List
		 * 
		 * List 컬렉션은 배열과 비슷하게 객체를 인덱스로 관리한다.
		 * 배열과의 차이점은 저장용량이 자동으로 증가, 객체를 저장할 때 자동으로
		 * 인덱스가 부여된다 /추가, 삭제, 검색을 위한 메소드가 있다
		 * 
		 * 1) ArrayList
		 * 
		 * ArrayList는 꼭 제네릭 타입이 있거나 없거나해도 된다.
		 * index 0번부터 차곡차곡 쌓아가야한다
		 * 초기 default 모리 공간길이는 10이다
		 * */
		List list = new ArrayList();
		// .size() List 객체 안에 들어있는 데이터 길이
		System.out.println("새로 만든 List 길이 : " + list.size());
		list.add(1); // index 0
		list.add(1,"STR"); //index 1
		//list.add(3,10);  인덱스 순서를 안지켰기때문에 주석 풀면 오류남
		System.out.println(list.toString());
		
		// list index 1번째에 있는 STR값을 str로 바꿔봅시다 (set())
		//오브젝트 o로 셋을 밀어넣으면 기존에 인덱스에 있던 STR값을 str로 바꿔봅시다 (set())
		Object o = list.set(1, "str");
		System.out.println(o);
		System.out.println(list.toString());
		list.add(200);	//index 2
		list.add("name"); //index 3
		//list index 3번째에 있는 값을 "-"로 수정
		list.set(3, "-");
		System.out.println(list.toString());
		
		//list 안에 있는 값을 삭제
		list.remove(1); // index로 삭제
		list.remove("-"); // 값으로 삭제
		System.out.println(list.toString());
		
		//문제
		// 임의의 데이터 5개를 추가하고
		// .get() 함수를 이용해서 index 1, 3, 4번째에 해당하는 데이터를 출력하세요
		list.add(2);
		list.add(3,"청포도");
		list.add(4);
		list.add(5,"자두");
		list.add(6);
		list.add(7,"복숭아");
		System.out.println(list.toString());
		
		System.out.print(list.get(1));
		System.out.print(list.get(3));
		System.out.print(list.get(4));
		System.out.println();
		
		//제네릭을 지정하지 않으면 값을 넣을땐 굉장히 편하나
		//값을 꺼낼땐 값을 예측하기 어려운점이 있어서
		//제네릭의 사용을 권장한다.
		
		List<String> list2 = new ArrayList<String>();
		List<Integer> list3 = new ArrayList<Integer>();
		
		list2.add("A");
		list2.add("B");
		list2.add("C");
		list2.add("D");
		list2.add(4,"E");
		System.out.println("새롭게 등록한 list2 : " + list2.toString());
		System.out.println("F를 추가해봅시다 결과는? " + list2.add("F")); //출력창에 추가를하면 boolean타입으로 return함
		System.out.println("새롬게 list2에 G를 추가 " + list2.add("G"));
		System.out.println("전체 :" + list2.toString());
		System.out.println("list2 길이 : " + list2.size()); // List의 길이를 가져온다
		
		list3.add(100); // 0번째 100추가
		list3.add(200); // 1번째 200추가
		list3.add(300); // 2번째 300추가
		list3.add(123); // 3번재 123추가
		list3.add(202); //4번째 202 추가
		
		// list2에 들어있는 값 모두를 출력합니다
		for(int i = 0; i < list2.size(); i++) {
			System.out.println("list2 : (" + i + ")번째 " + list2.get(i));
		}
		
		// list3에 들어있는 값 모두를 출력합니다
		for(int i = 0; i < list3.size(); i++) {
			System.out.println("list3 : (" + i + ")번째 " + list3.get(i));
		}
		
		//문제1)
		// list2 index 짝수번째에 값을 ddit로 수정하고
		// 수정된 값을 출력해주세요
		
		for(int i = 0; i < list2.size(); i++) {
			if(i % 2 == 0) {
				list2.set(i, "ddit");
			}
		}
		System.out.println(list2.toString());
	
		//문제2)
		// list3의 저장되어 있는 값 모두를 더한 총합을 구하여 출력하고
		// 총합을 가지고 평균을 구해 평균도 출력하세요
		
		int sum= 0;
		
		for(int i = 0; i < list3.size(); i++) {
			sum += list3.get(i);
		}
		System.out.println(sum);
		
		double avg =0;
		avg = (double)sum / list3.size();
		System.out.println(avg);
		
		/*
		 * 2) Vector
		 *    Vector는 ArrayList와 동일한 구조를 가진다   (스레드 : 작업자! )
		 *    Vector는 동기화된 메소드로 구성되어 있어 멀티 스레드가 동시에 Vector메소드를
		 *    실행할 수 없고 하나의 스레드가 메소드를 실행을 완료해야만 다른 메소드를 
		 *    실행할 수 있다. 멀티 스레드 환경에서 안전하게 데이터를 추가/삭제/수정 할 수 있다.
		 * */
		
		Vector vect = new Vector();
		vect.add(100);
		vect.add("AA");
		vect.add(200);
		vect.set(1, "BB");
		System.out.println(vect.toString());
		
		/*
		 * 3) LinkedList
		 *    List 구현 클래스로 ArrayList와 사용 방법은 같으나 내부구조가 다르다
		 *    ArrayList와 같이 내부 배열에 객체를 저장해서 관리하는 게 아닌
		 *    인접 참조를 링크해서 체인처럼 관리한다
		 * */
		List<String> list4 = new LinkedList<String>();
		for(int i = 0; i < 20; i++) {
			list4.add(0,String.valueOf(i));
			System.out.print(list4.get(0) + " ");
		}
		System.out.println(list4.size());
		
		// 최종 List 정리
		// List add(index), add(index, value), set(index, value), remove(index), remove(value)
		// 함수를 이용하여 데이터를 사용할 수 있다.
		
		/*
		 * 2. Set (주머니)
		 * 
		 * Set은 저장 순서가 없다.
		 * 객체를 중복해서 저장할 수 없고, 하나의 null만 저장할 수 있다.
		 * SEt은 인덱스로 개체를 관리하지 않는다
		 * Iterator
		 * - hasNext() : 가져올 객체가 있으면 true, 없으면 false 리턴
		 * - next() : 켈렉션에서 하나의 객체를 가져온다
		 * - remove() : 객체를 제거
		 * 
		 * 1) HashSet
		 * 	  Set 인터페이스의 구현 클래스로, 객체들을 순서없이 저장하고 동일한 객체는
		 * 	  중복 저장하지 않는다
		 * 	  Set은 객체를 저장하기 전에 먼저 저장된 객체와 새로 넣을 객체의 hashCode를 비교
		 *    하여 동일한 해시코드인지를 먼저 확인한다. 그리고 다시 equals 메소드로 두 객체를
		 *    비교해서 동일한 객체로 판단되었을때는 중복 저장하지 않는다.
		 * */
		Set<String> set = new HashSet<String>();
		set.add(new String("100"));  // 해쉬코드 100이 2개가 중복이므로 하나만 나오게함
		set.add(new String("100"));
		set.add("200");
		set.add("300");
		set.add("400");
		set.add("500");
		System.out.println(set.toString()); //그래서 100과 200만 들어가있음
		System.out.println(set.hashCode());
		System.out.println(set.size());
		
		// Set은 get() 메소드를 지원하지 않으므로 Iterator라는 녀석을 필요로 한다
		Iterator<String> iterator = set.iterator();
		while(iterator.hasNext()) { // set안에 객체를 다 찾을 때까지 while이 작동
			System.out.println("Set iterator로 꺼내는 중 : " + iterator.next());
		}
		
		
		/*
		 * 3. Map (405호)
		 * 
		 * Map은 키와 값으로 구성된 Map.Entry 객체를 저장하는 구조
		 * 키는 중복으로 저장할 수 없지만 값은 중복으로 저장이 가능하다
		 * 
		 * 1) HashMap
		 * 	  HashMap은 Map인터페이스의 대표적인 구현 컬렉션
		 *    Map은 키가 중복되면 안되서 hashCode()와 equals() 메소드가 중복되지 않게
		 *    처리하는 기능으로 재정의되어 있다.
		 *    모든 컬렉션이 그렇듯 제네릭 타입은 기본타입을 사용할 수 없다
		 * */
		Map<String,Object> map = new HashMap<String,Object>();
		map.put("유재석", 100);
		map.put("박명수", 99);
		map.put("하하", 98);
		map.put("정형돈", 97);
		//맵하면 405호 우리반을 떠올려보다
		
		// Map에서 데이터를 꺼내올떄는 get() 메소드를 사용하고
		// get() 메소드 파라미터 값으로 key를 전달한다
		// ex) get(key), get("유재석");
		System.out.println(map.get("박명수"));
		System.out.println(map.get("하하"));
		
		// 객체를 하나씩 순차적으로 꺼내봅시다 (방법1) map은 keyset 이용
		
		Set<String> keySet = map.keySet();
		Iterator<String> keyIterator = keySet.iterator();
		while(keyIterator.hasNext()) {
			String key1 = keyIterator.next();
			int num = (Integer) map.get(key1);
		}
		
		//객체를 하나씩 순차적으로 꺼내봅시다(방법2) entryset 이용
		Set<Entry<String,Object>> entry = map.entrySet(); 
		Iterator<Entry<String,Object>> iter = entry.iterator();
		String key = "";
		String value = "";
		while(iter.hasNext()) {
			Map.Entry<String, Object> ent = iter.next();
			key = ent.getKey();
			value = String.valueOf(ent.getValue());
			//value = String.valueOf(map.get(key));
			System.out.println("[방법2 Map에 들어는 데이터 : " + value );
		}
		
	}
}

 

 

 

 List

package h_collection;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
import java.util.Scanner;

public class ArrayListClass {
	/*
	 * boolean add(Object o)	: 마지막 위치에 객체를 추가 후 성공여부를 반환한다,
	 * void add(int i, Object o) : 지정된 위치에 객체를 추가한다.
	 * Object set(int i, Object o) : 지정된 위치에 객체를 저장한 후 기존 객체를 반환한다. 
	 * 								arr[0] = 1 -> list.set(0,1)
	 * Object get(int i) : 지정된 위치의 객체를 반환한다. arr[0] -> list.get(0)
	 * int size() : 저장된 객체의 수를 반환한다.	arr.length -> list.size()
	 * boolean remove(int i) : 지정된 위치의 객체를 제거한다.
	 * */
	public static void main(String[] args) {
		List list = new ArrayList();
		
		list.add("abc");
		list.add(100);
		list.add(new Scanner(System.in));
		
		//제네릭을 지정하지 않으면 넣을때는 편하나 꺼낼때는 타입을 예측하기 어렵다.
		// 따라서 제네릭의 사용이 권장된다.
		
		List<Integer> list2 = new ArrayList<>(); // <>제네릭 안에 INTEGER 넣음 생략해도됨
		list2.add(10); //add가 integer로 바뀜
		
		System.out.println(list2.add(20));
		System.out.println(list2.add(20));
		System.out.println(list2);
		
		list2.add(1,40); //원래 1번 위치에 40이 들어가고 나머지것들은 뒤로 밀림
		System.out.println(list2);
		
		//list2.add(10,40); //add는 배열이 1개씩 늘려주는 거라 갑자기 10번지에 40을 넣을 수 없음 ,순서대로만 저장할 수 있다
		
		int before = list2.set(2, 50);
		System.out.println("before : " + before);
		System.out.println("after : " + list2.get(2));
		
		//값을 제거할때는 반드시 뒤에서부터 제거해야한다.
		System.out.println(list2);
//		for(int i = 0; i <list2.size(); i++) {
//			System.out.println(i + " : " + list2.get(i));
//			list2.remove(i);  //배열과 달리 하나씩 빼지기 때문에 앞에 40이 사라지고 50이 나온다
//			
//		}
//		System.out.println(list2);
		
		
		
		for(int i = list2.size() -1; i >=0; i--) {
			System.out.println(i + " : " + list2.get(i));
			list2.remove(i);
		}
		System.out.println(list2);
		
		// 예제) list3에 1부터 100까지 랜덤값을 10개 저장해주세요.
		List<Integer> list3 = new ArrayList<>();
		Random rnd = new Random();
		
		for(int i = 0; i < 10; i++) { //length나 size를 쓸 수 없다!!!!
			list3.add(rnd.nextInt(100) + 1);
		}
		System.out.println(list3);
		
		// 예제2) list3에 저장된 값의 합계와 평균을 구해주세요.
		
		int sum = 0;
		double avg = 0;
	
		for(int item : list3) {
			sum += item;
		}
		avg =(double)sum / list3.size();
		System.out.println("sum : " + sum + ", avg : " + avg);
		
		//예제3) list3에서 최솟값과 최댓값을 구해주세요.
		int min = list3.get(0);
		int max = list3.get(0);
//		min = 100;
//		max = 1; 이렇게 해도 된다
		
		for(int item : list3) {
			if(item > max) max = item;
			if(item < min) min = item;
		}
		System.out.println("min : " + min + ", max : " + max);
		
		// 예제4) list3을 오름차순으로 정렬해주세요. (sort() 미사용)
//		
//		for(int i = 0; i < list3.size(); i++) {
//			for(int j = i+1; j < list3.size();j++) {   //다음꺼랑 비교하기 위해 i+1 해준다!!
//				if(list3.get(i) > list3.get(j)) {
//					int temp = list3.set(j, list3.get(i));  // 크니까 j를 i로 바꾼다!!!!!!!!!!!
//					list3.set(i, temp);
//				}
//			}
//		}
//		System.out.println(list3);
		
		
		for(int i = 0; i < list3.size(); i++) {
			for(int j = i+1; j < list3.size(); j++) {
				if(list3.get(i) > list3.get(j)) {
					int temp = list3.set(j, list3.get(i));
					list3.set(i, temp);
				}
			}
		}System.out.println(list3);
		
		
		//sort() 이용한 것
		   Comparator<Integer> c= new Comparator<Integer>(){
		         @Override
		         public int compare(Integer o1, Integer o2) {
		            if (o1 > o2) {
		               return 1;
		            } else if (o1 == o2) {
		               return 0;
		            } else {
		               return -1;
		            }
		         }

		      };
		      list3.sort(c);
		      System.out.println(list3);  
	}
}

 

 

Map

package h_collection;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class HashMapClass {
	
	/*
	 * List : index => value
	 * Map : key => value
	 * 
	 * Object put(Object key, Object value) : 지정된 키와 값을 저장한다.
	 * Object remove(Object key) : 지정된 키의 값(없으면 null)을 반환한다.
	 * Set keySet() : 저장된 모든 키를 Set으로 반환한다.
	 * */
	public static void main(String[] args) {
		Map<String, Object> map = new HashMap<>();
		map.put("이름","홍길동");
		map.put("국어", 100);
		map.put("영어", 20);
		map.put("수학", 100);
		map.put("생일", new Date());
		System.out.println(map);
		// [] : 배열이나 List => 순서가 있다
		// {} : Map => 순서 없음
		
		map.put("영어", 90);
		System.out.println(map); // 새로운 항목이 추가된게 아니고 기존의 영어의 점수를 덮어 씀
		
		map.remove("생일");
		System.out.println(map);
		
		Object o = map.get("국어");
		System.out.println(o);
		System.out.println(map.size());
		
		for(int i = 0; i <map.size(); i++) {
			System.out.println(i + " : " + map.get(i)); //키가 0번째 1번째 라는 게 없기 때문에 null1이 나옴
		}
		
		// Set
		// 1. 중복없음 2.순서 없음
		// List => 중복가능 순서있음
		// Map => 중복가능 순서없음
		for(String key : map.keySet()) { // set은 향상된 for문을 사용한다 한개씩 꺼내기 때문에 map에 사용 가능 > _ <
			System.out.println(key + " : " + map.get(key));
			
		}
		System.out.println("==================================");
		
		
		Map<String,Object> user1 = new HashMap<>();
		user1.put("id", "admin");
		user1.put("pw", "1234");
		user1.put("name", "홍길동");
		user1.put("phone", "010-0000-0000");
		
		for(String key : user1.keySet()) {
			System.out.println(key + " : " + user1.get(key));
		}
		
		Map<String,Object> user2 = new HashMap<>();
		user2.put("id", "tester");
		user2.put("pw", "1234");
		user2.put("name", "이순신");
		user2.put("phone", "010-1111-1111");
		
		// Map도 Map 배열을 생성할 수 있음
//		Map<String, Object>[] userArray = new HashMap<>[3];
		// 근데 배열이 귀찮아서 List를 사용했듯이
		// Map배열도 귀찮아서 List에 담는다
		List<Map<String, Object>> userList = new ArrayList<>();
		userList.add(user1);
		userList.add(user2);
		System.out.println((userList));
		
		System.out.println("=====================================");
		
		Map<String, Object> classMap = new HashMap<>();
		classMap.put("405", userList);
		System.out.println(classMap);
		
	}
}