객체지향) 컬렉션 프레임워크

Collections Framework

Collections Framework 구성도

각 카테고리는 데이터 저장방식이 다름.

Set과 List 차이점

List는 중복을 허용하고 set은 중복을 허용하지 않는다.

import java.util.ArrayList;
import java.util.HashSet;
 
import java.util.Iterator;
 
public class ListSetDemo {
 
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        al.add("one");
        al.add("two");
        al.add("two");
        al.add("three");
        al.add("three");
        al.add("five");
        System.out.println("[array]");
        Iterator ai = al.iterator();
        while(ai.hasNext()){
            System.out.println(ai.next());
        }
         
        HashSet<String> hs = new HashSet<String>();
        hs.add("one");
        hs.add("two");
        hs.add("two");
        hs.add("three");
        hs.add("three");
        hs.add("five");
        Iterator hi = hs.iterator();
        System.out.println("\n[hashset]");
        while(hi.hasNext()){
            System.out.println(hi.next());
        }
    }
 
}

//출력 결과
[array]
one
two
two
three
three
five
 
[hashset]
two
five
one
three

set은 페이지 교체 알고리즘(FIFO/LRU/LFU/NUR)과 같은 느낌으로 생각하자(정보처리기사 내용)

[교체되는 건 아님-단지 고유의 값만 저장하는 것]

 

부분집합 문법 : A.containsAll(B); -> A에 B가 속한다. (True/False)

합집합 문법 : A.addAll(B); -> A집합에 B를 추가한다.

교집합 : A.retainAll(B); -> A와 B집합의 교집합.

차집합 : A.removeAll(B) -> A집합에서 B집합을 뺌

 

※List는 중복이 가능하고 순서가 보장된다. Set은 중복이 허용되지 않고 순서가 보장되지 않는다.

 

 

컬렉션 프레임 워크의 관계도를 더 구체적으로 알고자 한다면 아래를 참고하자.

https://www.youtube.com/watch?v=rHPaEJmfa98&list=PLuHgQVnccGMCeAy-2-llhw3nWoQKUvQck&index=155 

Iterator

복제를 함. -> 호출을 함 -> 호출된 값은 삭제됨(복제가 삭제될 뿐 원본이 삭제되지는 않는다.)

[hasNext() : 값이 존재함?? ] 

hashSet이나 ArrayList는 모두 Iterator을 가지고 있어 데이터 타입을 Collection으로 사용해도 된다.

Collection<Integer> A = new HashSet<Integer>();

Map

key값에 따른 value값을 호출 key는 중복이 허용되지 않으나, value값은 중복이 허용된다.

List, Set, Map의 특징()

import java.util.*;
 
public class MapDemo {
 
    public static void main(String[] args) {
        HashMap<String, Integer> a = new HashMap<String, Integer>();
        a.put("one", 1);
        a.put("two", 2);
        a.put("three", 3);
        a.put("four", 4);
        System.out.println(a.get("one"));  // 1출력
        System.out.println(a.get("two"));  // 2출력
        System.out.println(a.get("three"));  // 3출력
        // key가 중복되면 어떤 value를 가지고 와야하는지 모르기 때문에 중복이 허용되지 않는다. 
         
        iteratorUsingForEach(a);
        iteratorUsingIterator(a);
    }
     
    static void iteratorUsingForEach(HashMap map){
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        // Set 데이터 타입의 entries에 값을 넣어라.
        // 여기서 String은 getKey() 를 , Integer은 getvalue() 를 의미한다.
        
        for (Map.Entry<String, Integer> entry : entries) {
        // 데이터 하나하나를 entry에 넣는다.
        
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }
     
    static void iteratorUsingIterator(HashMap map){
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        Iterator<Map.Entry<String, Integer>> i = entries.iterator();
        // i라는 반복자에 얻는다.
        
        while(i.hasNext()){
        // 데이터를 조회하고 있다면 반복문이 실행된다.
            Map.Entry<String, Integer> entry = i.next();
        // 반복자에 있는 값을 하나하나 꺼내서 entry에 담는다.    
            System.out.println(entry.getKey()+" : "+entry.getValue());
        }
    }
 
}

map을 수학적으로 접근하면

즉 map은 수학에서는 함수이다.

 

배열

기존 배열은 한번 크기를 정하면 변경이 불가능하다. 이것을 해결하기 위해 ArrayList를 사용한다.

import java.util.ArrayList; //import 해줘야 한다.
 
public class ArrayListDemo {
 
    public static void main(String[] args) {
        String[] arrayObj = new String[2];
        arrayObj[0] = "one";
        arrayObj[1] = "two";
        // arrayObj[2] = "three"; 오류가 발생한다.
        for(int i=0; i<arrayObj.length; i++){
            System.out.println(arrayObj[i]);
            //배열의 길이로 값을 추출함
        }
         
        ArrayList al = new ArrayList();
        al.add("one"); // 0
        al.add("two"); // 1
        al.add("three"); // 2
        for(int i=0; i<al.size(); i++){
            System.out.println(al.get(i));
            // 사이즈를 통해 값을 추출함
        }
    }
 
}

배열로 추출하는 방법과 ArratList로 추출하는 방법의 차이점을 보자.

ArrayList에서 add는 어떠한 형태든 사용이 가능한 메소드이다. 그래서 "one"... 은 object로 저장된다.

그래서 변수에 저장하기 위해서는 형 변환이 필요하다.

 

String value  = (String)al.get(i);  

 

제네릭 사용도 가능하다.

ArrayList<String> al = new ArrayList<String>();
al.add("one");
al.add("two");
al.add("three");
for(int i=0; i<al.size(); i++){
    String val = al.get(i);
    System.out.println(val);
}

제네릭을 통해 입력되는 값이 String이다라고 정해준 것이다.

 

 

정렬

import java.util.*;
 
class Computer implements Comparable{
	//sort 하기 위해서 Computer은 Comparable을 이행해야한다.

    int serial;
    String owner;
    Computer(int serial, String owner){
        this.serial = serial;
        this.owner = owner;
    }
    public int compareTo(Object o) {
        return this.serial - ((Computer)o).serial;
        // a.compareTo(b)=> a.serial - b.serail 의 결과중 
        // 양수면 a가 크고 음수면 b가 크고 0이면 a,b가 같은 것임.
        
    }
    public String toString(){
        return serial+" "+owner;
    }
}
 
public class CollectionsDemo {
     
    public static void main(String[] args) {
        List<Computer> computers = new ArrayList<Computer>();
        computers.add(new Computer(500, "egoing"));
        computers.add(new Computer(200, "leezche"));
        computers.add(new Computer(3233, "graphittie"));
        Iterator i = computers.iterator();
        System.out.println("before");
        while(i.hasNext()){
            System.out.println(i.next());
        }
        Collections.sort(computers);
        //정렬을 해줌.
        //sort의 메소드는 list라는 매개변수를 가지고 있는데 데이터 타입은 List이다.
        //sort는 Comparable이라는 인터페이스를 implement 하고 있어야한다.
        
        System.out.println("\nafter");
        i = computers.iterator();
        while(i.hasNext()){
            System.out.println(i.next());
        }
    }
 
}

//출력 결과
before
500 egoing
200 leezche
3233 graphittie
 
after
200 leezche
500 egoing
3233 graphittie

 

컬렉션 프레임 워크를 알아야 좋은 코드를 만들 수 있다

-> 자료구조, 알고리즘 파트와 유사하다.