<Collection Framework>
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ArrayList {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
//ArrayList<Integer> list = new ArrayList<Integer>();
// 1. 저장 : add()
list.add(new Integer(1));
list.add(new Integer(2));
list.add(5);
list.add(4);
list.add(3);
list.add(5,2); // 인덱스를 지정하여 값을 넣을 수 있다. add(인덱스 번호, 값)
// 2. 저장된 요소 가져오기 : get(index)
System.out.println("첫 번째 요소 : " + list.get(0));
System.out.println("두 번째 요소 : " + list.get(1));
System.out.println("세 번째 요소 : " + list.get(2));
// 3. 크기 : size() -> length와 같은 역할
for(int i=0; i<list.size(); i++) {
System.out.println(list.get(i));
}
// 4. 삭제 : remove(index), clear()
list.remove(0); // 0번 인덱스의 데이터 삭제
// list.clear(); // 저장된 모든 객체를 삭제
System.out.println(list);
// 5. 확인(저장 유무 확인) : contains(객체)
List<Integer> list2 = new ArrayList<Integer>();
list2.add(5);
list2.add(6);
list2.add(7);
for(int i=0; i<list2.size(); i++) {
if(list.contains(list2.get(i))) {
System.out.println("중복되는 값 : " + list2.get(i));
}
}
// 6. 컬렉션은 그냥 출력해도 된다.
System.out.println(list);
// 7. 정렬 : sort(list)
Collections.sort(list);
System.out.println("정렬 후 list : " + list);
// 8. 최악의 성능으로 list의 모든 데이터 삭제
while(list.size() > 0) {
list.remove(0); // 앞 인덱스부터 삭제
}
}
}import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class iterator {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
// 10, 20, 30,...100 까지 list에 저장하기
// for(int i=1; i<=10; i++) {
// list.add(i*10);
// }
for(int i=10; i<=100; i+=10) {
list.add(i);
}
// 반복자 호출
Iterator<Integer> itr = list.iterator();
while(itr.hasNext()) {
System.out.println(itr.next());
}
}
}import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class LinkedList {
public static void main(String[] args) {
/*
* ArrayList 와 LinkedList 성능 비교
* 1000개의 객체를 0번 인덱스에 삽입하는데 걸리는 시간을 측정
*
* - 순차적으로 추가/삭제하는 경우에는 ArrayList가 빠르지만,
* 중간에 추가/삭제 하는 경우는 LinkedList가 더욱 빠르다.
*/
List<String> list1 = new ArrayList<String>();
List<String> list2 = new LinkedList<String>(); // ArrayList와 방법 동일
long startTime;
long endTime;
// ArrayList
startTime = System.nanoTime();
for(int i=0; i<10000; i++) {
list1.add(0, String.valueOf(i));
}
endTime = System.nanoTime();
System.out.println("ArrayList 걸린시간 : " + (endTime - startTime) + " ns");
// LinkedList
startTime = System.nanoTime();
for(int i=0; i<10000; i++) {
list2.add(0, String.valueOf(i));
}
endTime = System.nanoTime();
System.out.println("LinkedList 걸린시간 : " + (endTime - startTime) + " ns");
}
}import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class HashSet {
public static void main(String[] args) {
// Set 컬렉션: 저장 순서 유지 X, 객체 중복 저장 X, 인덱스로 관리하지 않아 인덱스를 매개 값으로 갖는 메소드가 없다.
Set<String> set = new HashSet<String>();
set.add("C");
set.add("Spring");
set.add("Java");
set.add("DB");
set.add("JSP");
set.add("Web");
set.add("Java"); // 중복 저장 시도
Iterator<String> itr = set.iterator();
while(itr.hasNext()) {
String str = itr.next();
// if(str.equals("Spring")) {
// itr.remove();
// }
}
// set.remove("Spring"); // set을 이용한 특정 객체 삭제
// set.removeAll(set); // set을 이용한 전체 객체 삭제
System.out.println(set);
}
}import java.util.TreeSet;
public class TreeSet {
public static void main(String[] args) {
// TreeSet 의 메소드를 사용하기 위해 Set 대신 TreeSet 사용
TreeSet<String> set = new TreeSet<String>();
set.add("airplane");
set.add("apple");
set.add("area");
set.add("disc");
set.add("dance");
System.out.println(set);
/*
* 1. 메소드 정의
*
* headSet : 지정된 객체보다 작은 값의 객체들 반환
* subSet : 범위 내의 검색 결과 반환
* tailSet : 지정된 객체보다 큰 값의 객체들 반환
*/
System.out.println(set.headSet("b"));
System.out.println(set.subSet("a", "aq"));
System.out.println(set.tailSet("c"));
TreeSet<Integer> setInt = new TreeSet<Integer>();
setInt.add(10);
setInt.add(20);
setInt.add(30);
setInt.add(40);
setInt.add(50);
System.out.println(setInt.headSet(15)); // 15보다 작은 값
System.out.println(setInt.subSet(15, 45)); // 15 ~ 45 사이의 값
System.out.println(setInt.tailSet(35)); // 35보다 큰 값
}
}import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashMap {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
// 데이터 추가 : put(key, value)
map.put("할머니", 120);
map.put("할아버지", 110);
map.put("엄마", 70);
map.put("아빠", 60);
map.put("동생", 3);
map.put("동생", 10); // key 중복 발생 (중복된 key를 삽입 시 기존 value가 수정)
// 삭제 : remove(key)
map.remove("할머니");
System.out.println(map);
// 크기 확인 : size()
System.out.println("entry 개수 : " + map.size());
// 반복자는 key를 통해서 순회한다.(반복자의 타입 == key의 타입)
// map의 key를 Set에 저장한다. 1번
// map에서 key만 빼서 순회한다. 2번
Set<String> set = map.keySet();
Iterator<String> itr = set.iterator();
// 저장된 value 가져오기 : get(key)
while(itr.hasNext()) {
String key = itr.next();
Integer value = map.get(key);
System.out.println("이름(key) : " + key + ", 나이(value) : " + value);
}
System.out.println("-----------------------");
// itr 를 순회하고 나면 사용된 itr은 재사용이 불가하다.
// 새로 itr 값을 받아서 사용해야 한다.
itr = set.iterator(); // 다시 정보를 얻어옴
while(itr.hasNext()) {
String key = itr.next();
Integer value = map.get(key);
System.out.println("이름(key) : " + key + ", 나이(value) : " + value);
}
System.out.println("---------------------------");
System.out.println(map); // 키=값 형태의 배열
map.clear(); // map의 모든 객체 삭제
System.out.println(map);
}
}반응형