[JAVA] 컬렉션 (List, Set, Map)

---

컬렉션

 

● List → 저장 순서를 유지(인덱스), 중복 저장 가능

List<String> list = new ArrayList<String>();
			//  0       1       2
list.add("Son");	//"Son"			→ 맨 뒤에 객체 추가
list.add(1, "Kane");	//"Son"   "Kane"	→ 지정한 인덱스에 객체 삽입
list.set(0, "Moura");	//"Moura" "Kane"	→ 지정한 인덱스에 새로운 객체로 변경
list.get(0);		//"Moura"		→ 지정한 인덱스에 저장된 객체 반환
list.remove(1);		//"Moura"		→ 지정한 인덱스에 저장된 객체 삭제
list.remove("Moura");	//			→ 지정한 객체삭제

 

① ArrayList

//String 타입 객체를 저장할 배열 생성 (기본크기: 10)
List<String> list = new ArrayList<String>();	
			//0       1       2       3       4
list.add("Son");	//"Son"
list.add("Kane");	//"Son"	"Kane"
list.add("Moura");	//"Son"	"Kane"	"Moura"
list.add(2, "Dele");	//"Son" "Kane"	"Dele"	"Moura"		→ 지정 인덱스에 객체 삽입하면 한칸씩 밀림
list.add("Skip");	//"Son"	"Kane"	"Dele"	"Moura"	"Skip"
list.remove(1);		//"Son	"Dele"	"Moura"	"Skip"		→ 지정 인덱스에 객체 제거하면 한칸씩 당김

//배열과 ArrayList의 공통점 → 인덱스로 객체를 관리(추가,삭제,검색)
//배열은 생성시 사이즈가 고정되서 크기 변경불가
//ArrayList는 저장할수 있는 크기보다 초과해서 객체가 들어오면 자동적으로 크기가 늘어남

 

② Vector → 스레드 동기화가 되어있어서 멀티 스레드가 동시에 Vector에 접근 하더라도 안전

public class Player {
	String team;
	String name;
	int number;
	
	public Player(String team, String name, int number) {
		this.team = team;
		this.name = name;
		this.number = number;
	}
}

List<Player> list = new Vector<Player>();

list.add(new Player("토트넘", "손흥민", 7));
list.add(new Player("울버햄튼", "황희찬", 26));
list.add(new Player("맨유", "박지성", 13));
list.add(new Player("페네르바체", "김민재", 3));

remove(2);

for(int i=0; i<list.size(); i++) {
	Player p = list.get(i);
	System.out.println(p.name + "(" + p.team + "," + p.number + ")");
}

//output
//손흥민(토트넘,7)
//황희찬(울버햄튼,26)
//김민재(페네르바체,3)

 

③ LinkedList → 특정 인덱스의 객체를 삭제 또는 삽입시 앞뒤 링크만 변경되고 나머지 링크는 유지

 

● Set → 저장 순서가 유지 안됨, 중복 저장 불가능

① HashSet

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

//hashCode()의 반환값이 같고, equals()의 반환값이 true면 동일객체로 판단 → 중복 저장 안함
set.add("손흥민");
set.add("황희찬");
set.add("김민재");
set.add("손흥민"); //동일객체 → 중복저장 안함
set.add("박지성");

//Set은 인덱스로 관리하지 않기때문에 반복자를 사용
Iterator<String> iter = set.iterator();
while(iter.hasNext()) {
	String player = iter.next();
	System.out.println(player);
}

//output → 순서없이 저장됨, 동일 객체는 중복저장 안함
//김민재
//손흥민
//황희찬
//박지성

public class Player {
	String name;
	int number;
	
	public Player(String name, int number) {
		this.name = name;
		this.number = number;
	}
	
	@Override
	public boolean equals(Object obj) {
		if(obj instanceof Player) {
			Player p = (Player)obj;
			return p.name.equals(name) && p.number == number;
		}
		return false;
	}
	
	@Override
	public int hashCode() {
		return Objects.hash(name, number);
	}
}

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

set.add(new Player("손흥민", 7));
set.add(new Player("손흥민", 7));

//new 연산자로 서로 다른 객체를 생성했지만 동등객체이므로 중복저장 안함!
System.out.println(set.size());   //1

② TreeSet

 

● Map → 키와 값으로 구성된 Entry 객체를 저장, 키 중복 불가능

① HashMap

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

map.put("손흥민", 87);
map.put("헤리케인", 88);
map.put("토비", 85);
map.put("호이비에르", 80);
map.put("손흥민", 100);	//키는 중복불가, 값은 새로운 값으로 변경

//(1)
Set<String> set = map.keySet();
Iterator<String> iter = set.iterator();
while(iter.hasNext()) {
	String key = iter.next();
	Integer value = map.get(key);
	System.out.println(key + "(" + value + ")");
}

//(2)
Set<Entry<String, Integer>> entrySet = map.entrySet();
Iterator<Entry<String, Integer>> entryIterator = entrySet.iterator();
while(entryIterator.hasNext()) {
	Entry<String, Integer> entry = entryIterator.next();
	String key = entry.getKey();
	Integer value = entry.getValue();
	System.out.println(key + "(" + value + ")");
}

//키 객체는 hashCode()와 equals() 재정의 해야함
//키가 String 일 때는 문자열이 같으면 동등객체로 인식하게끔 이미 오버라이딩 되있음

 

② Hashtable → 스레드 동기화가 되어있어서 멀티 스레드가 동시에 Hashtable에 접근 하더라도 안전

③ Properties

④ TreeMap