Collections

Collection

List : 중복 허용, 추가 순서 유지

• 리스트 내 중복 item 제거하기

  List<Integer> items = new ArrayList<Integer>();
  items.add(1);
  items.add(2);
  items.add(1);
  items.add(2);
  items.add(3);
  items.add(3);
  System.out.println(items); // [1, 2, 1, 2, 3, 3]
  
  List<Integer> uniqueItems = new ArrayList<Integer>(new HashSet<Integer>(items));
  System.out.println(uniqueItems); // [1, 2, 3]
  

• 중복되는 요소들을 가질 리스트를 HashSet으로만든뒤에 다시 List로 변환을 하면 중복요소가 사라진 유일한 요소들만 가진 리스트를 만들 수 있다.

Map : 키와 값의 쌍. 순서 유지 안 됨. 키는 중복 허용. 값은 중복 불허

• Key 순환

  while (Integer index : map.keySet()) {
  ...
  }
  

• Iterator 사용

  Iterator<Integer> iter = map.keySet().iterator();
  while (iter.hasNext()) {
  ... = iter.next();
  }
  

Set : 중복 불허, 순서 유지 안 됨

• 한국어로 '집합'이라는 뜻이다. 여기서 집합이란 수학의 집합과 같은 의미이다.
• 모든 Collection 클래스에는 Primitive 타입을 저장할 수 없음 (객체만 저장 가능)

• 상속 관계에 있는 클래스끼리도 Generics 사용 안 됨.

  ArrayList<Animal> dogList = new ArrayList<Dog>(); // 에러!
  

  <? extends T> : T 또는 T의 자손 타입

  <? super T> : T 또는 T의 조상 타입

• 수학적인 집합 연산

  package org.opentutorials.javatutorials.collection;
  
  import java.util.ArrayList;
  import java.util.HashSet;
  
  import java.util.Iterator;
  
  public class SetDemo {
  
     public static void main(String[] args) {
          HashSet<Integer> A = new HashSet<Integer>();
          A.add(1);
          A.add(2);
          A.add(3);
  
          HashSet<Integer> B = new HashSet<Integer>();
          B.add(3);
          B.add(4);
          B.add(5);
  
          HashSet<Integer> C = new HashSet<Integer>();
          C.add(1);
          C.add(2);
  
          System.out.println(A.containsAll(B)); // false
          System.out.println(A.containsAll(C)); // true A⊇C
  
          //A.addAll(B); // A∪B 
          //A.retainAll(B); // A∩B 
          //A.removeAll(B); // A-B
  
          Iterator hi = A.iterator();
          while(hi.hasNext()){
              System.out.println(hi.next());
          }
      }
  }
  

ArrayList

ArrayList<String> list = new ArrayList<String>();
int index = list.indexOf("사과");

HashMap

Map<String, Integer> map = new HashMap<String, Integer>();
map.put("key1", 1);
map.isEmpty();
map.containsKey("key3");
map.containsValue(2);
map.size();

for (String key : map.keySet()) {
    if (key.equals("key1")) { ... }
    }

Iterator

// List에서
List<String> list = new ArrayList<String>();
list.add("수박");
list.add("사과");

Iterator<String> iter1 = list.iterator();
while (iter1.hasNext()) {
    System.out.println(iter1.next());
}

// Map에서
Map<String, String> map = new HashMap<String, String>();
map.put("key1", "value1");
map.put("key2", "value2");

Iterator<String> iter2 = map.keySet().iterator();
while (iter2.hasNext() {
    System.out.println(iter1.next());
}

정렬

• Compare override를 통한 객체 정렬

  Collections.sort(list, new Comparator<Product>() { 
      public int compare(Product p1, Product p2) {
          return p1.getCode().compareTo(p2.getCode()); // code 오름차순으로 정렬
      };
  });
  

• 클래스 Collectors는 다양한 클래스 메소드를 가지고 있다. 메소드 sort는 그 중의 하나로 List의 정렬을 수행한다. 다음은 sort의 시그니처다.

  public static <T extends Comparable<? super T>> void sort(List<T> list)
  

  sort의 인자인 list는 데이터 타입이 List이다. 즉 메소드 sort는 List 형식의 컬렉션을 지원한다는 것을 알 수 있다. 인자 list의 제네릭 는 comparable을 extends 하고 있어야 한다. Generic에서의 extends는 implements 혹은 extends를 의미한다.(호환성때문) Comparable<? super T>는 T타입 혹은 T의 부모 타입에서 Comparable를 구현해도 사용가능하다는 말이다. Comparable은 인터페이스인데 이를 구현하고 있는 클래스는 아래 메소드를 가지고 있어야 한다.

  compareTo(T o)
  

• Comparable 예제

  package com.test.collections;
  
  public class Father implements Comparable<Father>{
      int age;
      public Father(int age) {
          this.age = age;
      }
  
      @Override
      public int compareTo(Father o) {
          // TODO Auto-generated method stub
          return this.age - o.age;
      }
  
      @Override
      public String toString() {
          // TODO Auto-generated method stub
          return " age: " + this.age;
      }
  
  }
  //----------------------------------------------
  package com.test.collections;
  
  public class Son extends Father {
  
      public Son(int age) {
          super(age);
          // TODO Auto-generated constructor stub
      }
  
  }
  //----------------------------------------------
  package com.test.collections;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
  
  public class SortTestDrive {
      public static void main(String[] args) {
          List<Son> sons = new ArrayList<Son>();
          sons.add(new Son(20));
          sons.add(new Son(30));
          sons.add(new Son(10));
  
          for (Son s : sons) {
              System.out.println(s);
          }
  
          System.out.println("Sorting...");
          Collections.sort(sons);
  
          for (Son s : sons) {
              System.out.println(s);
          }
      }
  } 
  //결과 ------------------------------------------
   age: 20
   age: 30
   age: 10
  Sorting...
   age: 10
   age: 20
   age: 30