Collection
java.util의 패키지로서 다수의 데이터를 쉽게 처리하는 방법(CRUD)을 제공하는 프레임워크
List
- 입력 순서가 있는 데이터의 집합
Set
- 입력 순서를 유지하지 않는 데이터의 집합
Queue
- 순서를 유지하며 데이터를 빼기 위한 데이터의 집합
Map
- key와 value의 쌍으로 데이터를 관리하는 집합
기본 메서드
추가
- add()
- addAll()
조회
- contains()
- containsAll()
- equals()
- isEmpty()
- iterator()
- size()
삭제
- clear()
- removeAll()
- retainAll()
List
- 입력순서가 있다.
- 데이터의 중복을 허락한다.
추가
- add(int index,E element)->특정 인덱스에 추가
- addAll(int index,Collection<? extends E> c)->특정 인덱스부터 모두추가
조회
- get(int index)
- indexOf(Object O)
- lastIndexOf(Object O)
- listIterator()
수정
- set(int index,E element)
삭제
- remove(int index)->특정 인덱스 삭제
import java.util.ArrayList;
import java.util.List;
public class ListTest {
// 문자열을 저장할 List, 구현체는 ArrayList
List<String> friends = new ArrayList<>();
public static void main(String[] args) {
ListTest alt = new ListTest();
alt.createTest();
alt.retrieveTest();
alt.updateTest();
alt.deleteTest();
}
public void createTest() {
friends.add("홍길동0");
friends.add(0,"홍길동1");
friends.add("홍길동2");
System.out.println("추가 후 내용 출력: " + friends);
}
public void retrieveTest() {
System.out.println(friends.isEmpty());
// for (int i=0;i<friends.size();i++) {//고전적인 순회
// System.out.println(i+" : "+friends.get(index));
// }
for(String i:friends) {
System.out.println(i+" : "+i);
}
System.out.println(friends.indexOf("홍길동100"));
System.out.println(friends.indexOf("홍길동1"));
}
public void updateTest() {
int index=friends.indexOf("홍길동1");
if (index>=0) {//홍길동1이란 것이 존재한다면
friends.set(index,"홍길동100");
}
System.out.println("수정 후 내용 출력: " + friends);
}
public void deleteTest() {
friends.remove(0);
System.out.println("삭제 후 : " + friends);
friends.clear();// 리스트 초기화
System.out.println("초기화 후 : " + friends);
}
}추가 후 내용 출력: [홍길동1, 홍길동0, 홍길동2]
false
홍길동1 : 홍길동1
홍길동0 : 홍길동0
홍길동2 : 홍길동2
-1
0
수정 후 내용 출력: [홍길동100, 홍길동0, 홍길동2]
삭제 후 : [홍길동0, 홍길동2]
초기화 후 : []Set
- 입력 순서가 없다
- 중복이 허용되지 않는다.
import java.util.HashSet;
import java.util.Set;
public class SetTest {
Set<Object> hset = new HashSet<Object>();
private void addMethod() {
hset.add(Integer.valueOf(1));
hset.add("Hello");
hset.add("Hello"); // 동일한 데이터 추가 확인
hset.add(1);
hset.add(3);
System.out.println("데이터 추가 결과: " + hset);
}
private void retrieveMethod() {
System.out.println("데이터 개수: " + hset.size());
for (Object sobj : hset) {
System.out.println("데이터 조회: " + sobj);
}
}
private void removeMethod() {
hset.remove("Hello");
System.out.println("데이터 삭제 결과: " + hset);
}
public static void main(String[] args) {
SetTest test = new SetTest();
test.addMethod();
test.retrieveMethod();
test.removeMethod();
}
}Map
- Key와 Value를 묶어서 관리한다.
- 순서가 없다.
추가
- put(K key,V value)
- putAll(Map<? extends K,? extednds V> m)
조회
- containsKey(Object Key)
- containsValue(Object value)
- entrySet()
- keySet()
- get(Object key)
- values()
- size()
- isEmpty()
삭제
- clear()
- remove(Object key)
수정
- put(K key,V value)
- putAll(Map<? extends K,? extednds V> m)
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class MapTest {
Map<String, String> hMap = new HashMap<>();
Map<String, String> hMap2 = new HashMap<>();
private void addMethod() {
hMap.put("andy", "1234");
// 동일한 키의 사용 결과는?
hMap.put("andy", "4567");
hMap.put("kate", "9999");
// 기존에 해당 키에 대한 값이 없을 때만 추가하기
hMap.putIfAbsent("kate", "1234");
hMap.put("henry", "4567"); // 동일한 값
hMap.put("hong", "1234");
System.out.println("추가 결과: " + hMap);
hMap2.putAll(hMap);
System.out.println("추가 결과: " + hMap2);
System.out.println((hMap==hMap2));
}
private void retrieveMethod() {
String val1=hMap.get("kate");
System.out.println(val1);
String val2=hMap.getOrDefault("nothing","not Exists");//키가 존재하지 않으면 기본값 반환
System.out.println(val2);
Set<String> keys=hMap.keySet();//키 목록 순회
for(String key:keys) {
System.out.println(key);
}
Set<Entry<String,String>> entries=hMap.entrySet();
for(Entry<String,String> entry:entries) {
System.out.println(entry.getKey()+" "+entry.getValue());
}
}
private void removeMethod() {
System.out.println(hMap);
System.out.println("kate"+"삭제");
hMap.remove("kate");
System.out.println(hMap);
}
public static void main(String[] args) {
MapTest hmt = new MapTest();
hmt.addMethod();
hmt.retrieveMethod();
hmt.removeMethod();
}
}추가 결과: {hong=1234, henry=4567, kate=9999, andy=4567}
추가 결과: {hong=1234, henry=4567, kate=9999, andy=4567}
false
9999
not Exists
hong
henry
kate
andy
hong 1234
henry 4567
kate 9999
andy 4567
{hong=1234, henry=4567, kate=9999, andy=4567}
kate삭제
{hong=1234, henry=4567, andy=4567}정렬
- 요소를 특정 기준에 대한 내림차순 또는 오름 차순으로 배치 하는 것
- 순서를 가지는 Collection들만 정렬 가능
- 특정 기준으로 가지고 비교하려면 Comparable을 상속 받아야 한다.
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import com.ssafy.i_collection.set.SmartPhone;
class SmartPhone implements Comparable<SmartPhone>{
String number;
public SmartPhone(String number) {
this.number = number;
}
public String toString() {
return "전화 번호: " + number;
}
@Override
public int compareTo(SmartPhone o) {
return this.number.compareTo(o.number);
// return this.number.compareTo(o.number)*-1;내림차순
}
}
public class ListSortTest {
private static List<String> names = Arrays.asList("Hi", "Java", "World", "Welcome");
public void basicSort() {
System.out.println("정렬 전"+names);
Collections.sort(names);
System.out.println("기본 정렬"+names);
}
public void sortPhone() {
//특정 기준에 따라 정렬
List<SmartPhone> phones=Arrays.asList(new SmartPhone("111"),new SmartPhone("444"),new SmartPhone("131"));
System.out.println("정렬 전 "+phones);
Collections.sort(phones);
System.out.println("기준 정렬"+phones);
}
public static void main(String[] args) {
ListSortTest st = new ListSortTest();
st.basicSort();
st.sortPhone();
}
}정렬 전[Hi, Java, World, Welcome]
기본 정렬[Hi, Java, Welcome, World]
정렬 전 [전화 번호: 111, 전화 번호: 444, 전화 번호: 131]
기준 정렬[전화 번호: 111, 전화 번호: 131, 전화 번호: 444]
숲을 보는 코더