Collection API: List, Set, Map

컬렉션 API : 대량의 Data를 묶어서 관리하는 클래스들.

 

★List,  ★Set,  ★ Map  = interface임 ( 인터페이스 직접new로 객체생성 불가능.) 

:곧바로 객체생성 불가 /  실제 코드 구현은 각 인터페이스를 구현한 자식클래스들을 사용

1.   List	순서대로 저장	인덱스번호	중복Data 허용
2.   Set	순서 X	인덱스 X	중복 X
3.   Map	순서X	key	key    중복   X
		value	value  중복  O

★List★ : 가장 많이 사용됨.

List인터페이스를 구현한 하위 클래스를 사용 <제네릭>을 이용하여 배열요소 타입 지정.

 

: ArrayList

:LinkedList

:Vector

 

★Set★

 

:HashSet

:TreeSet

:LinkedHashSet

 

★Map★

 

:HashMap

:TreeMap

:LinkedMap

:HashTable

import java.sql.Array;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;

public class CollectionsClassTest {

	public static void main(String[] args) {
		//Collections 클래스의 유용한 static(객체없이 쓸수 있는 기능메소드)메소드
		//1) Collections.sort()
		//2) Collections.shuffle()
		
		ArrayList<String> datas = new ArrayList<String>(); 
		datas.add("nice");
		datas.add("World");
		datas.add("Hello");
		datas.add("Android");
		datas.add("hello");
		datas.add("nice");
		datas.add("good");
		System.out.println(datas.toString());
		
		System.out.println();
		
			Collections.sort(datas);  //리스트객체 요소들이 정렬됨.
			System.out.println(datas.toString());
		
		
			Collections.shuffle(datas);  //요소의 위치가 랜덤하게 섞임
			System.out.println(datas.toString());
	}
}
-------------------------------------------------------------------------------------------
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

public class ListTest {

	public static void main(String[] args) {
		
		//Collection 클래스들 : 자료구조를 구현한 Java API글래스들 -대량의 데이터를 관리
		
		//배열과 차이점 있음.
		//배열은 새로운 데이터의 추각, 삭제 등의 작업이 다소 번거롭다.
		//데이터의 추가, 삭제, 변경, 정렬 등의 작업을 편하게 해주기 위해 만들어진 클래스들이 Collection임.
		
		//컬렉션은 저장 방법론에 따라 크게 3가지 종류로 구분됨.
		
		//1. List  : 자료가 저장된 순서대로 있음. 자동부여된 인덱스번호로 구분함. 중복된 값 가질 수 있음.
		//2. Set   : 순서X, 인덱스 번호X , 중복 데이터X
		//3. Map   : 순서X, 인덱스 번호대신에 식별자(key)를 사용함. 중복 key는 허용X, 중복 Data는 허용.
		
		//위 3종류 모두 인터페이스여서 곧바로 객체생성이 불가능.
		// 실제 코드 구현은 .. 각 인터페이스를 구현한 자식 클래스들을 사용하는 것임. 
		//1) List : ArrayList, LinkedList, Vector
		//2) Set  : HashSet, TreeSet, LinkedHashSet
		//3) Map  : HashMap, TreeMap, LinkedMap, HashTable
		
		
		//가장 많이 사용하는 List계열 부터 실습해보기.
		
		//List는 인터페이스이기에 직접 new로 객체생성이 불가능.
		//List list= new List();   /error
		
		//List인터페이스를 구현한 하위 클래스를 사용 - 제네릭<>을 이용하여 배열요소의 타입을 지정
		ArrayList<String> aaa=new ArrayList<String>();
		
		//List계열의 객체들이 가지고 있는 유용한 기능메소드들..
		
		//1. 요소의 개수**
		int size= aaa.size();
		System.out.println("요소 개수: " + size);
		
		//2. 요소의 추가**
		String s= new String("aa");
		aaa.add(s);
		aaa.add(new String("bb"));
		aaa.add("cc");  //자동 new String()
		
		System.out.println("요소 개수: " + aaa.size());
		
		//3. 요소를 얻어오기**
		String ss =aaa.get(0);
		System.out.println(ss);
		System.out.println(aaa.get(1));
		System.out.println(aaa.get(2));
		// System.out.println(aaa.get(3));  //Exception(예외)발생 
		
		//4. 요소 삭제하기 **
		aaa.remove(1);
		System.out.println("요소 개수 : " + aaa.size());
		System.out.println(aaa.get(0));
		System.out.println(aaa.get(1));
		//System.out.println(aaa.get(2)); //error
		
		//5. 특정 위치에 추가하기
		aaa.add(1, new String("dd"));
		System.out.println(aaa.get(0));
		System.out.println(aaa.get(1));
		System.out.println(aaa.get(2));
		
		//6. 제거할 때 인덱스 번호가 아닌 객체 참조변수로 제거 가능
		String s2= new String("Test");
		aaa.add(s2);
		System.out.println("요소 개수 : " + aaa.size());
		aaa.remove(s2);   //주소를 가져온것 
		System.out.println("요소 개수 : " + aaa.size());
		
		//7. 요소 모두 제거하기
		aaa.clear();
		System.out.println("요소 개수 : " + aaa.size());
		
		//8. 중복 데이터의 허용 알아보기
		aaa.add("aa");
		aaa.add("aa");
		aaa.add("aa");
		System.out.println(aaa.get(0));
		System.out.println(aaa.get(1));
		System.out.println(aaa.get(2));
		
		//9. 요소의 비교 관련 기능들.
		//aaa.clear();   /true
		System.out.println(aaa.isEmpty());  //false   //비어 있는지 여부
		System.out.println(aaa.contains("aa"));   //true // "aa"가 포함되어 있는지 여부
		System.out.println(aaa.contains("bb"));    //false //bb 포함여부
		
		//10. 한번에 여러요소를 추가하기 
		aaa.clear();
		aaa.add("aa");
		aaa.add("bb");
		aaa.add("cc");
		
		//다른 리스트있어야 함.
		ArrayList<String> bbb= new ArrayList<String>();
		bbb.add("kk");
		bbb.add("ss");
		
		aaa.addAll(bbb);
		System.out.println(aaa.toString()); //요소들을 [,,,,,]모양의 문자열로 출력(편의기능임.)
		//개발자의 편의기능임. 실무에선 안씀. 
		
		//10.1 특정위치에 한번에 추가하기
		aaa.addAll(1,bbb);
		System.out.println(aaa.toString());
		
		// 위 addAll 처럼 .removeAll(), containsAll()도 존재함.
		
		//11. List계열에만 있는 기능
		System.out.println(aaa.indexOf("cc"));    //위치까지 알려줌. 
		System.out.println(aaa.indexOf("tt"));   //못찾으면 마이너스 -1
		
		//요소의 값을 순차적으로 얻어오기...
		//방법1. for문 사용하기  **(0번부터~ 몇번까지 )
		for(int i=0; i<aaa.size(); i++) {
			String t= aaa.get(i);
			
			System.out.println(t);
		}
		System.out.println();
		
		//방법2. 확장된 for문법  **(무조건 0번부터~끝번까지)- 다른 언어에서는 for each문법이라고 부름
		for(String t : aaa) {
			System.out.println(t);
		}
		System.out.println();
		
		//방법3. iterator()[반복자]를 이용하는 방법 .. Set수업에서 소개
		
		
		//List계열의 또 다른 하위 클래스들.  사용법 똑같음. 단, 성능이 다름.
		//ArrayList차이점 -요소의 빈번한 추가/ 제거시에 속도가 빠름. 단, 요소의 접근이 오래걸릴수 있음.
		LinkedList<String> ccc= new LinkedList<String>();
		ccc.add(new String("aaa"));
		ccc.add("bbb");
		ccc.add("ccc");
		
		ccc.remove(1);
		System.out.println(ccc.toString());
		
		//Vector   =  ArrayList와 다 똑같음... 단, 동기화 처리(Thread수업에 소개)가 되어 있음.
		Vector<String> ddd= new Vector<String>();
		ddd.add("aaa");
		ddd.remove(0);
		
		//<>제네릭에는 기본자료형은 불가능.
		//혹시 int형을 여러개 리스트에 저장하고 싶다면? Wrapper클래스 사용
		ArrayList<Integer> eee=new ArrayList<Integer>();
		eee.add(10);
		eee.add(20);
		System.out.println(eee.toString());
		//당연하게 개발자가 만든 class도 제네릭에 사용가능함
		ArrayList<Person> people = new ArrayList<Person>();
		people.add(new Person());
		people.add(new Person());
		people.add(new Person());
		
		people.get(0).name="sam";
		people.get(0).age= 20;
		people.get(0).show();   // ArrayList.person.체이닝기법 
	}
}

class Person{
	String name;
	int age;
	void show() {
		System.out.println(name+ "," + age);
	}
}
--------------------------------------------------------------------------------------------
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetTest {
	public static void main(String[] args) {
		
		//Set계열: 순서X ,index X , 중복Data허용 X
		
		//Set은 interface여서 직접new 생성 불가능
		//Set set= new Set(); //error
		
		//Set 인터페이스를 구현한 하위 클래스들 사용
		//1. HashSet       :순서 X, index X, 중복Data X
		//2. TreeSet       :저장된 값에 따라 정렬되는 Set , 성능Good
		//3. LinkedHashSet : 저장된 순서대로 정렬된 Set, 성능이 가장 안좋음
		
		//HashSet<String> set=new HashSet<String>();
		//TreeSet<String> set=new TreeSet<String>();  //오름차순
		LinkedHashSet<String> set = new LinkedHashSet<String>();  //저장된 순서
		//요소 추가
		set.add(new String("aaa"));
		set.add("bbb");   //자동new String()
		set.add("ccc");
		set.add("ddc");
		set.add("ffb");
		set.add("bbb"); //중복데이터
		set.add("eee");
		set.add("ccc"); //중복데이터
		
		//요소 개수
		System.out.println(set.size()+ ":"+set.toString());  //중구난방으로 나옴. 
		
		//인데스번호가 없기에.. 요소값을 얻어오는 get()이 존재하지 않음.
		//set.get();
		
		//순차적으로 얻어오는 방법존재
		//방법 1. for each문 (확장된 for문) **
		for(String t: set) {
			System.out.println(t);
		}
		System.out.println();
		
		//방법 2. 반복자(Iterator)를 이용하는 방법
		Iterator<String> datas=set.iterator();
		while(true) {
			while(datas.hasNext()) {
				String e = datas.next();
				System.out.println(e);
				//Set를 사용하는 가장 중요한 이유!!
				//중복 데이터를 허용하지 않기에
				//블루투스 장치 검색이 중복으로 되지 않는 등의  작업을 할때 사용됨.
			}
}
		}
	}
    ----------------------------------------------------------------------------------------
    import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class MapTest {

	public static void main(String[] args) {
		//Map계열: 키- 벨류 쌍(Key-Value- Pair)으로 데이터를 저장하는 방식
		//Map도 interface여서 직접 객체 생성 불가능
		//Map 인터페이스를 구현한 하위 클래스들을 사용
		//1. HashMap       :저장순서 X, 인덱스 X, 대신 Key(식별자)사용 /중복key사용 안됨, 중복Data허용.
		//2. TreeMap       :key(식별자)의 오름차순으로 정렬
		//3. LinkedHashMap : 저장순서대로 ... 정렬됨. 
		//4. HashTable     :HashMap와 99%  같음(멀티스레드에서 동기화 처리가 되어 있음.)
		
		//<키 타입, 벨류 타입>
		//HashMap<String, String> map=new HashMap<String, String>();
		//TreeMap<String, String> map=new TreeMap<String, String>();   //키값의 오름차순
		LinkedHashMap<String, String> map=new LinkedHashMap<String, String>();  //저장순
		
		//요소 추가;
		map.put("Name", "Hong");
		map.put("ID", "abcd");
		map.put("PW", "1234");
		map.put("kkk", "Hong");  //중복 data는 허용
		map.put("kkk", "Park");   //중복 key는 허용x    -->저장이 안되는 것이 아니라 그 값이 변경되는 것.
		
		System.out.println(map.size());
		
		//요소 얻어오기
		String s = map.get("Name");
		System.out.println(s);
		System.out.println(map.get("ID"));
		System.out.println(map.get("PW"));
		System.out.println(map.get("kkk"));
		
		System.out.println(map.toString());
		
		//요소값을 순차적으로 얻어오기
		//방법 for, for each문 불가능
		//방법1. 먼저 key값들만 먼저 뽑아와서 작업
		Set<String> keys =map.keySet();
		//1.1 keys를 for each로
		for(String key: keys) {
			String e = map.get(key);
			System.out.println(e);
		}
		System.out.println();
		
		//1.2 keys를 반복자로 접근
		Iterator <String>datas =keys.iterator();
		while(datas.hasNext()) {
			String key= datas.next();
			System.out.println(key+ ":" + map.get(key));
		}
		System.out.println();
		
		//방법2. Map의 요소들을 Set으로 변경하여 가져오기
		//Map의 요소(키-밸류 쌍) 객체인 Entry의 Set 얻어오기
		Set<Entry<String, String>> entries =map.entrySet();
		for(Entry<String, String> e :entries) {
			System.out.println(e.getKey() + ":" + e.getValue());
		}
	}
}