컬렉션 프레임워크(Collection Framework)

컬렉션 프레임워크(Collection Framework)란?

  프로그램 구현에 필요한 자료구조와 알고리즘을 구현해 놓은 라이브러리다.

  java.util 패키지에 구현되어 있으며 개발에 소요되는 시간을 절약하고 최적화된 라이브러리를 사용할 수 있다.

  Collection Framework는 Collection 인터페이스와 Map 인터페이스로 구성된다.

 

 

Collection Interface

  하나의 객체의 관리를 위해 선언된 인터페이스로 필요한 기본 메소드가 선언되어 있다.

  하위에 List, Set 인터페이스가 있다.

분류	설명
List Interface	순서가 있는 자료관리로 중복이 허용된다. 이 인터페이스를 구현한 클래스는 ArrayList, Vector, LinkedList, Stack, Queue등이 있다.
Set Interface	순서가 정해져 있지 않으며 중복을 허용하지 않는다. 이 인터페이스를 구현한 클래스는 HashSet, TreeSet 등이 있다.

 

  컬렉션은 하나의 객체에 대한 자료구조이며 map은 페어다.

  map인터페이스는 쌍으로 이루어진 객체를 관리하는데에 필요한 여러 메소드가 선언되어 있다.

  map을 사용하는 객체는 key-value 쌍으로 되어 있고 key는 중복될 수 없다.

 

List Interface

  Collection 하위 인터페이스다.

  객체를 순서에 따라 저장하고 관리하는데에 필요한 메소드가 선언된 인터페이스다.

  배열의 기능을 구현하기 위한 메소드가 선언되며 ArrayList, Vector, LinkedList 등이 있다.

 

  ArrayList와 Vector

    객체배열 클래스다

    Vector는 자바 2부터 제공된 클래스로 멀티스레드(Multi Thread) 프로그램에서 동기화를 지원한다.

    동기화(Synchronization)는 두개의 스레드가 동시에 하나의 리소스에 접근할 때 순서를 맞추어서

    데이터의 오류가 발생하지 않도록 하는 것이다.

 

  ArrayList와 LinkedList

    둘다 자료의 순차적 구조를 구현한 클래스다.

    ArrayList는 배열을 구현한 클래스로 논리적 순서와 물리적 순서로 동일하다.

    LinkedList는 논리적으로 순차적인 구조지만, 물리적으로는 순차적이지 않을 수 있다.

 

    LinkedList 구조

   

 

      LinkedList에서 자료의 추가와 삭제

import java.util.LinkedList;

public class LinkedListTest {
  
  public static void main(String[] args) {
    LinkedList<String> myList = new LinkedList<>();
    
    myList.add("A");
    myList.add("B");
    myList.add("C");
    
    System.out.println(myList);
    //대부분의 collection은 toString이 제공되므로
    //바로 출력이 가능하다.
    
    myList.add(1, "D");
    System.out.println(myList);
    
    myList.removeLast();
    System.out.println(myList);
    
    for(int i = 0; i < myList.size(); i++) {
      String s = myList.get(i);
      System.out.println(s);
    }
  }
}

      결과값으로는

      [A, B, C]

      [A, D, B, C]

      [A, D, B]

      A

      D

      B

      이렇게 출력된다.

      .add로 값을 넣어 배열을 만들어 줄 수 있으며 add(1, "D") 이러한 형태로 원하는 위치에 값을 넣어줄 수도 있다.

      1번 인덱스에 D를 넣으라고 했기 때문에 A와 B사이에 D가 들어가게 되고 그로인해 B와 C는 뒤로 밀리게 된다.

      그리고 removeLast로 마지막 인덱스의 값을 삭제하라고 했으므로 C가 삭제 되게 된다.

      마지막 반복문에서 get(i)형태로 출력하는 것은 set인터페이스에서는 사용할 수 없다.

 

      LinkedList 자료구조 정리

연결리스트(Linked List)

 

 

    스택(Stack)과 큐(Queue)

      스택은 LIFO(Last In First Out)으로 후입선출이라 하며 맨 마지막에 들어간 요소가 가장 먼저 꺼내지는 구조이다.

      자바에서는 이미 구현된 클래스가 제공이 되며 ArrayList나 LinkedList로 구현할 수 있다.

      큐는 FIFO(First In First Out)으로 선입선출이라 하며 먼저 저장된 자료가 먼저 꺼내지는 구조이다.

      선착순, 대기열 등을 구현할 때 가장 많이 사용되는 자료구조다.

      큐 역시 ArrayList 나 LinkedList로 구현할 수 있다.

//Stack

import java.util.ArrayList;

class MyStack {
  private ArrayList<String> arrayStack = new ArrayList<>();
  
  public void push(String data) {
    arrayStack.add(data);
  }
  
  public String pop() {
    int len = arrayStack.size();
    
    if(len == 0) {
      System.out.println("스택이 비었습니다.");
      return null;
    }
    
    return arrayStack.remove(len - 1);
  }
} //MyStack End

public class StackTest {
  
  public static void main(String[] args) {
    MyStack stack = new MyStack();
    
    stack.push("A");
    stack.push("B");
    stack.push("C");
    
    Systme.out.println(stack.pop());
    Systme.out.println(stack.pop());
    Systme.out.println(stack.pop());
    Systme.out.println(stack.pop());
  }
} //Test End

      결과값은 C B A 스택이 비었습니다  이렇게 출력된다.

      스택은 나중에 들어간 요소가 먼저 출력되기 때문에 들어간 반대의 순서로 C B A 순서로 빠져나오게 되고

      4번째에는 더이상 빠져나올 것이 없기 때문에 작성한 출력문이 나온다.

 

      스택 자료구조

스택(Stack)

      큐 자료구조

큐(Queue)

 

 

Set Interface

  Collection의 하위 인터페이스이며 중복을 허용하지 않는다.

  List는 순서 기반의 인터페이스지만 Set은 순서가 없다.

  get(i)가 제공되지 않아 Iterator로 순회하며 저장된 순서와 출력순서는 다를 수 있다.

  아이디, 주민번호, 사번 등 유일한 값이나 객체를 관리할 때 사용한다.

  HashSet과 TreeSet클래스가 있다.

 

  Iterator로 순회

    Collection의 개체를 순회하는 인터페이스다.

    iterator ir = memberArrayList.iterator(0;

    이런 형태로 사용한다.

 

    Iterator에 선언된 메서드

메서드	설명
boolean hashNext()	이후에 요소가 더 있는지를 체크하는 메서드이며, 요소가 있다면 true를 반환한다.
E next()	다음에 있는 요소를 반환한다.

 

 

  HashSet 클래스

    Set인터페이스를 구현한 클래스다.

    Set은 중복을 허용하지 않고 해시방식으로 데이터를 관리하기 때문에 입력하는 순서와 출력하는 순서는 다르다.

    ArrayList로 만들어 출력할때는 중복도 허용하기 때문에 중복값과 입력순서대로 출력이 되지만

    HashSet으로 만들어 출력하면 중복데이터는 한번만 출력되고 순서도 입력순서와 다르게 출력된다.

    HashSet을 사용할 때는 객체가 논리적으로 같은지에 대한 정의가 되어 있어야 한다.

    String으로만 처리한다면 String에는 이미 정의가 되어 있으므로 상관없지만 직접 만든 클래스에 대해서는 정의를

    해야 한다.

    같은지에 대한 정의는 equals와 hashCode로 한다.

    

import java.util.*;

public class HashSetTest {
  
  public static void main(String[] args) {
    HashSet<String> set = new HashSet<>();
    
    set.add("이순신");
    set.add("강감찬");
    set.add("김유신");
    set.add("이순신");
    
    System.out.println(set);
    
    Iterator<String> ir = set.iterator();
    
    while(ir.hasNext()) {
      String str = ir.next();
      System.out.println(str);
    }
  }
}

    결과값은 김유신, 강감찬, 이순신   김유신   강감찬   이순신    이렇게 출력된다.

    ArrayList로 만들었을 때는 입력한 순서대로 출력이 되고 중복되는 값도 출력이 되었지만 HashSet은

    중복도 허용하지 않고 순서도 입력순이 아닌 다른 순서대로 출력된다.

    그리고 LinkedList 예제에서처럼 get(i)는 set에서 사용할 수 없다고 했다.

    set인터페이스에서는 get(i)를 사용할 수 없기 때문에 Iterator를 이용해서 호출하여 출력한다.

 

 

  HashSet예제 2

//Member class

public class Member {
  
  private int memberId;
  private String memberName;
  
  public Member() { } //default Constructor
  
  public Member(int memberId, String memberName) { //Constructor
    this.memberId = memberId;
    this.memberName = memberName;
  }
  
  //getter, setter
  public int getMemberId() {
    return memberId;
  }
  
  public void setMemberId(int memberId) {
    this.memberId = memberId;
  }
  
  public String getMemberName() {
    return memberName;
  }
  
  public void setMemberName() {
    this.memberName = memberName;
  }
  
  public String toString() {
    return memberName + " 회원님의 아이디는 " + memberId + " 입니다.";
  }
  
  //equals hashCode
  @Override
  public boolean equals(Object o) {
    if(o instanceof Member) {
      Member member = (Member)o;
      
      return (this.memberId == member.memberId);
    }
    
    return false;
  }
  
  @Override
  public int hashCode() {
    return memberId;
  }
}

//Member HashSet class

import java.util.*;

public class MemberHashSet {
  
  private HashSet<Member> hashSet;
  
  public MemberHashSet() {
    hashSet = new HashSet<Member>();
  }
  
  public void addMember(Member member) {
    hashSet.add(member);
  }
  
  public boolean removeMember(int memberId) {
    Iterator<Member> ir = hashSet.iterator();
    
    while(ir.hasNext()) {
      Member member = ir.next();
      
      if(member.getMemberId() == memberId) {
        hashSet.remove(member);
        return true;
      }
    }
    System.out.println(memberId + " 번호가 존재하지 않습니다.");
    return false;
  }
  
  public void showAllMember() {
    for(Member member : hashSet) {
      System.out.println(member);
    }
    System.out.println();
  }
}

//Test class

public class MemberHashSetTest {
  
  public static void main(String[] args) {
    MemberHashSet manager = mew MemberHashSet();
    
    Member memberLee = new Member(100, "Lee");
    Member memberKim = new Member(200, "Kim");
    Member memberPark = new Member(300, "Park");
    Member memberPark2 = new Member(300, "Park2");
    
    manager.addMember(memberLee);
    manager.addMember(memberKim);
    manager.addMember(memberPark);
    manager.addMember(memberPark2);
    
    manager.showAllMember();
  }
}

    결과값은

    Lee 회원님의 아이디는 100입니다.

    Kim 회원님의 아이디는 200입니다.

    Park 회원님의 아이디는 300입니다.

    이렇게 출력된다. Park2의 경우는 아이디가 300으로 Park과 중복되기 때문에 출력되지 않는다.

    Member 클래스에서 equals와 hashCode로 아이디값이 동일하다면 논리적으로 같은 값이라고 판단하기 때문이다.

    Member 클래스에서 equals와 hashCode를 지우고 실행한다면 Park2역시 출력된다.

    String클래스에서는 미리 구현되어 있기 때문에 따로 equals와 hashCode를 구현하지 않아도 되지만

    이렇게 직접 만들어준 클래스에 대해서는 꼭 구현을 해줘야 중복값을 처리할 수 있다.

 

 

  TreeSet 클래스

    객체의 정렬에 사용되는 클래스다.

    중복을 허용하지 않으면서 오름차순이나 내림차순으로 객체를 정렬한다.

    내부적으로 이진검색트리(Binary Search Tree)로 구현되어 있다.

    이진검색트리에 자료가 저장될 때 비교하여 저장될 위치를 정한다.

    객체의 비교를 위해 Comparable이나 Comparator 인터페이스를 구현해야 한다.

 

    Comparable인터페이스와 Comparator 인터페이스는 정렬대상이 되는 클래스가 구현해야 하는 인터페이스다.

    Comparable은 compareTo 메서드를 구현한다.

    매개변수와 객체 자신(this)를 비교한다.

    Comparator는 compare() 메서드를 구현한다.

    두개의 매개변수를 배교하며 TreeSet 생성자에 Comparator가 구현된 객체를 매개변수로 전달한다.

    TreeSet<Member> treeSet = new TreeSet<Member>(new Member());

    이러한 형태로 사용할 수 있으며 일반적으로는 Comparable을 더 많이 사용한다.

    이미 Comparable이 구현된 경우에는 Comparator를 이용하여 다른 정렬방식을 정의할 수 있다.

 

   TreeSet 예제 1

import java.util.*;

class MyCompare implements Comparator<String> {
  
  @Override
  putlic int compare(String s1, String s2) {
    return s1.compareTo(s2) * (-1);
  }
}

public class ComparatorTest {
  
  public static void main(String[] args) {
    TreeSet<String> treeSet = new TreeSet<String>();
    treeSet.add("홍길동");
    treeSet.add("강감찬");
    treeSet.add("이순신");
   
    for(String str : treeSet) {
      System.out.println(str);
    }
  }
}

    결과값은 강감찬  이순신  홍길동  이렇게 출력된다.

    여기서는 String 클래스에 이미 Comparable이 구현되어 있기 때문에 오름차순으로 정렬되어 출력된다.

    하지만 내림차순으로 출력하고 싶다면 Comparator를 이용해 정의한 MyCompare를 이용해 정렬하면 된다.

    TreeSet<String> treeSet = new TreeSet<String>(new MyCompare());

    이렇게 쓰면 되고 생성자에 추가해서 이 방식으로 정렬하라고 하는 것이다.

 

 

  TreeSet 예제 2

 

//Member Class

public class Member implements Comparable<Member> {

  private int memberId;
  private String memberName;
  
  public Member() { }
  
  public Member(int memberId, String memberName) {
    this.memberId = memberId;
    this.memberName = memberName;
  }
  
  public int getMemberId() {
    return memberId;
  }
  
  public void setMemberId(int memberId) {
    this.memberId = memberId;
  }
  
  public String getMemberName() {
    return memberName;
  }
  
  public void setMemberName(String memberName) {
    this.memberName = memberName;
  }
  
  public String toString() {
    return memberName + " 회원님의 아이디는 " + memberId + " 입니다.";
  }
  
  //memberId가 같은 경우 두 값은 논리적으로 같은 값이라는 것을
  //구현하기 위해 equals와 hashCode를 작성
  @Override
  public boolean equals(Object o) {
    if(o instanceof Member) {
      Member member = (Member)o;
      
      return (this.memberId == member.memberId);
    }
    
    return false;
  }
  
  @Override
  public int hashCode() {
    return memberId;
  }
  
  @Override
  public int compareTo(Member o) {
    return (this.memberId - o.memberId);
    /*
      내 값이 더 클때 양수를 반환하게 되면 오름차순으로 정렬하게 된다.
      그래서 내림차순으로 정렬하고 싶다면 * (-1)을 추가해서 음수로 반환하게 하면 된다.
      이름으로 정렬하고 싶다면
      this.memberName.compareTo(member.getMemberName());
      이렇게 작성한다.
      String은 compareTo가 구현되어 있기 때문에
      그냥 사용하면 된다.
      그리고 예제1에서와 마찬가지로 String역시 내림차순으로 정렬하고 싶을때는
      * (-1)을 추가한다.
    */
  }
}

/*
  Comparable말고 다른 방법으로는
  Comparator가 있다.
  implements Comparator<Member>로 작성하면 되고
  그럼
  @Override
  public int compare(Member o1, Membmer o2) {
    return (o1.memberId - o2.memberId);
  }
  이렇게 작성하면 된다.
  
  o1이 this고 o2가 매개변수가 된다.
  마찬가지로 이렇게 처리해서 양수가 반환되면 오름차순
  * (-1)을 해서 음수를 반환하게 되면 내림차순이 된다.
*/

//MemberTreeSet class

import java.util.*;

public class MemberTreeSet {
  private TreeSet<Member> treeSet;
  
  public MemberTreeSet() {
    treeSet = new TreeSet<Member>();
    /*
      만약 Member 클래스에서 Comparable이 아닌
      Comparator로 작성했다면
      treeSet = new TreeSet<Member>(new Member());
      이렇게 작성한다.
    */
  }
  
  public void addMember(Member member) {
    treeSet.add(member);
  }
  
  public boolean removeMember(int memberId) {
    Iterator<Member> ir = treeSet.iterator();
    
    while(ir.hasNext()) {
      Member member = ir.next();
      if(member.getMemberId() == memberId) {
        treeSet.remove(member);
        return true;
      }
    }
    System.out.println(memberId + " 번호가 존재하지 않습니다.");
    return false;
  }
  
  public void showAllMember() {
    for(Member member : treeSet) {
      System.out.println(member);
    }
    System.out.println();
  }
}

//Test class

public class MemberTreeSetTest {
  
  public static void main(String[] args) {
    MemberTreeSet manager = new MemberTreeSet();
    
    Member memberLee = new Member(300, "Lee");
    Member memberKim = new Member(100, "Kim");
    Member memberPark = new Member(200, "Park");
    
    manager.addMember(memberLee);
    manager.addMember(memberKim);
    manager.addMember(memberPark);
    
    manaber.showAllMember();
  }
}

    결과값은

    Kim회원님의 아이디는 100입니다.

    Park회원님의 아이디는 200입니다.

    Lee회원님의 아이디는 300입니다.

    이렇게 출력된다.

    만약 Member클래스에서 Comparable을 implements해주지 않는다면 ClassCastException이 발생한다.

    Member cannot be cast to java.lang.Comparable 이라는 오류를 확인할 수 있는데

    Comparable을 cast할 수 없다는 것이다.

    예제 1에서는 String클래스에 Comparable이 구현되어있었으니 문제가 없었지만 Member클래스에서는 따로 

    구현하지 않았다면 Comparable을 찾을 수 없기 때문이다.

 

 

Map Interface

  key-value pair의 객체를 관리하는데 필요한 메서드가 정의된다.

  key는 중복될 수 없으며 검색을 위한 자료구조다.

  key를 이용하여 값을 저장하거나 검색, 삭제할 때 사용하면 편리하다.

  내부적으로 hash방식으로 구현되며 key가 되는 객체는 유일함의 여부를 알기 위해 

  equals와 hashCode메서드를 재정의한다.

 

  HashMap클래스

    Map인터페이스를 구현한 클래스 중 가장 일반적으로 사용하는 클래스다.

    HashTable클래스는 자바2부터 제공된 클래스로 Vector처럼 동기화를 제공한다.

    pair 자료를 쉽고 빠르게 관리할 수 있다.

 

    HashMap 예제코드

 

//Member class

public class Member {
  
  private int memberId;
  private String memberName;
  
  public Member() { }
  
  public Member(int memberId, String memberName) {
    this.memberId = memberId;
    this.memberName = memberName;
  }
  
  public int getMemberId() {
    return memberId;
  }
  
  public void setMemberId(int memberId) {
    this.memberId = memberId;
  }
  
  public String getMemberName() {
    return memberName;
  }
  
  public void setMemberName(String memberName) {
    this.memberName = memberName;
  }
  
  public String toString() {
    return memberName + " 회원님의 아이디는 " + memberId + " 입니다.";
  }
  
  @Override
  public boolean equals(Object o) {
    if(o instanceof Member) {
      Member member = (Member)o;
      
      return (this.memberId == member.memberId);
    }
    return false;
  }
  
  @Override
  public int hashCode() {
    return memberId;
  }
}

//MemberHashMap class

import java.util.*;

public class MemberHashMap {
  
  private HashMap<Integer, Member> hashMap;
  
  public MemberHashMap() {
    hashMap = new HashMap<Integer, Member>();
  }
  
  public void addMember(Member member) {
    hashMap.put(member.getMemberId(), member);
    //member.getMemberId가 key
    //member가 value가 된다.
  }
  
  public boolean removeMember(int memberId) {
    if(hashMap.containsKey(memberId)) { //키값에 해당하는 값이 있는지
      hashMap.remove(memberId);
      return true;
    }
    System.out.println("회원번호가 없습니다.");
    return false;
  }
  
  public void showAllMember() {
    Iterator<Integer> ir = hashMap.keySet().iterator();
    //모든 set 객체를 반환한다.
    //key객체를 반환하는데 key는 중복되지 않으므로 set타입으로 반환한다.
    
    while(ir.hasNext()) {
      int key = ir.next();
      Member member = hashMap.get(key);
      System.out.println(member);
    }
    System.out.println();
  }
}

//Test class

public class MemberHashMapTest {
  
  public static void main(String[] args) {
    MemberHashMap manager = new MemberHashMap();
    
    Member memberLee = new Member(100, "Lee");
    Member memberKim = new Member(200, "Kim");
    Member memberPark = new Member(300, "Park");
    Member memberPark2 = new Member(300, "Park2");
    
    manager.addmember(memberLee);
    manager.addmember(memberKim);
    manager.addmember(memberPark);
    manager.addmember(memberPark2);
    
    manager.showAllMember();
    
    manager.removeMember(200);
    
    manager.showAllMember();
  }
}

    결과값은

    Lee회원님의 아이디는 100 입니다.
    Kim회원님의 아이디는 200 입니다.
    Park2회원님의 아이디는 300 입니다.

    Lee회원님의 아이디는 100 입니다.
    Park2회원님의 아이디는 300 입니다.

    이렇게 출력된다.

    키값이 Integer고 Integer에는 equals와 hashCode가 구현되어 있기 때문에 중복값은 출력하지 않는다.

 

  TreeMap 클래스

    key 객체를 정렬하여 key-value를 pair로 관리하는 클래스다.

    key에 사용되는 클래스에 Comparable, Comparator 인터페이스를 구현한다.

    자바에 많은 클래스들은 이미 Comparable이 구현되어 있다.

    구현된 클래스를 key로 사용하는 경우에는 구현할 필요가 없다.

 

    TreeMap 예제코드

 

//Member class

public class Member {
  
  private int memberId;
  private String memberName;
  
  public Member() { }
  
  public Member(int memberId, String memberName) {
    this.memberId = memberId;
    this.memberName = memberName;
  }
  
  public int getMemberId() {
    return memberId;
  }
  
  public void setMemberId(int memberId) {
    this.memberId = memberId;
  }
  
  public String getMemberName() {
    return memberName;
  }
  
  public void setMemberName(String memberName) {
    this.memberName = memberName;
  }
  
  public String toString() {
    return memberName + " 회원님의 아이디는 " + memberId + " 입니다.";
  }
  
  @Override
  public boolean equals(Object o) {
    if(o instanceof Member) {
      Member member = (Member)o;
      
      return (this.memberId == member.memberId);
    }
    return false;
  }
  
  @Override
  public int hashCode() {
    return memberId;
  }
}

//MemberTreeMap class

import java.util.*;

public class MemberTreeMap {
  
  private TreeMap<Integer, Member> treemap;
  
  public MemberTreeMap() {
    treeMap = new TreeMap<Integer, Member>();
  }
  
  public void addMember(Member member) {
    treeMap.put(member.getMemberId(), member);
  }
  
  public boolean removeMember(int memberId) {
    if(treeMap.containsKey(memberId)) {
      treeMap.remove(memberId);
      return true;
    }
    System.out.println("회원번호가 없습니다.");
    return false;
  }
  
  public void showAllMember() {
    Iterator<Integer> ir = treeMap.keySet().iterator();
    
    while(ir.hasNext()) {
      int key = ir.next();
      Member member = treeMap.get(key);
      System.out.println(member);
    }
    System.out.println();
  }
}

//Test class

public class MemberTreeMapTest {

  public static void main(String[] args) {
    MemberTreeMap manager = new MemberTreeMap();

    Member memberPark = new Member(300, "Park");
    Member memberLee = new Member(100, "Lee");
    Member memberKim = new Member(200, "Kim");
    Member memberPark2 = new Member(300, "Park2");

    manager.addMember(memberLee);
    manager.addMember(memberKim);
    manager.addMember(memberPark);
    manager.addMember(memberPark2);

    manager.showAllMember();

    manager.removeMember(200);
    manager.showAllMember();
  }
}

    결과값은

    Lee회원님의 아이디는 100 입니다.
    Kim회원님의 아이디는 200 입니다.
    Park2회원님의 아이디는 300 입니다.

    Lee회원님의 아이디는 100 입니다.
    Park2회원님의 아이디는 300 입니다.

    이렇게 출력된다.

    treeMap의 키값이 Integer이기 때문에 아이디를 기준으로 오름차순 정렬되어 출력된다.

    Integer에는 Comparable이 구현되어 있어 오름차순으로 정렬되게 된다.

    만약 Integer가 아닌 직접 작성한 클래스였다면 직접 구현해야 한다.

 

 

 

 

레퍼런스

패스트캠퍼스 올인원 패키지 - 자바 객체지향프로그래밍