day19 - API(2) generic, collection

> java.util 패키지

> 제네릭 generic

클래스나 인터페이스 선언에 유형 매개변수가 들어있는 클래스

제네릭 타입은 클래스/인터페이스 이름 뒤 "<매개변수>" 위치

클래스에 원치않는 datatype이 들어가는 것을 막을 수 있고, 값을 가져올 때도 형 변환 하지 않아도 됨

형 안정성(type safety)을 위해 사용

//제네릭 없는 코드
//클래스 Ex01
public class Ex01 {
    private Object obj;  //Object는 부모클래스
    public void setObj(Object obj) {  //setter 메소드
        this.obj = obj;
    }
    public Object getObj() {  //getter 메소드
        return obj;
    }
}
//클래스 ExMain01
public class ExMain01 {
    public static void main(String[] args) {  //main
        Ex01 ab = new Ex01();  //객체생성
        ab.setObj("김민수");  //저장
        String name = (String)ab.getObj();  //반환 //강제형변환
    }
}

//제네릭 있는 코드
//클래스 Ex02
public class Ex02<A> {  //클래스 뒤 <매개변수>
    private A a;  //?
    public void set(A a) {  //setter 메소드
        this.a = a;
    }
    public A get() {  //getter 메소드
        return a;
    }
}
//클래스의 저장되는 타입은 정해지지 않은 상태

//클래스 ExMain02
public class ExMain02 {
    public static void main(String[] args) {  //main
        Ex02<String> bc = new Ex02<String>();  //객체생성 <String>
        bc.set("김민수");  //저장
        String name = bc.get();  //반환 //강제형변환 불필요
    }
}
//new로 생성할 때 클래스를 다양한 형태로 만들어 쓸 수 있음

---

> Collection Framework

collection

배열과 유사하지만 데이터 저장/조회/수정/삭제 작업 쉽게 처리, 동적인 크기 가짐

Set/List/Map 등의 인터페이스가 있음 - 이를 구현한 클래스를 이용하면 객체들을 모음저장할 수 있음

컬렉션은 데이터 적재 클래스 자료구조

컬렉션의 상속구조↓

---

< List / Set / Map 계열 >

객체를 저장할 수 있는 자료구조 제공

배열과 달리 동적인 공간, 배열에 비해 높은 성능

컬렉션마다 관리할 수 있는 메소드 존재

컬렉션에 저장된 객체(혹은 변수)를 element 라고 함

---

1. List 계열

List 컬렉션: 객체를 인덱스로 관리, 객체 저장 시 자동으로 인덱스번호 부여, 인덱스로 객체 검색/삭제 가능

객체를 순서대로 저장 / 동일한 객체 중복 저장 허용

- List 계열 주요 메소드 -

- 객체 추가 기능

1) add(E e): 주어진 객체를 List 맨 끝부분에 추가

2) add(int index, E e): 주어진 인덱스에 객체 추가

3) set(int index, E e): 주어진 인덱스에 저장된 객체를 주어진 객체로 바꿈

- 객체 검색 기능

1) contains(Object o): 주어진 객체가 저장되어있는지 판단

2) get(int index): 주어진 인덱스에 저장된 객체 리턴

3) isEmpty(): 컬렉션이 비어있는지 판단

4) size(): 저장된 전체 객체 수 리턴

- 객체 삭제 기능

1) clear(): 저장된 모든 객체 삭제

2) remove(int index): 주어진 인덱스에 저장된 객체 삭제

3) remove(Object o): 주어진 객체 삭제

 

- ArrayList

배열과 흡사하지만 자동으로 사이즈 조절

(특정 인덱스 객체 제거 시 자동으로 바로 뒤 인덱스부터 마지막 인덱스까지 모두 앞으로 한 칸씩 당겨짐)

package collection_;

import java.util.ArrayList; //ArrayList 클래스 import

public class ListEx01 {
    public static void main(String[] args) {
    
        ArrayList<String> lst = new ArrayList<String>(); //객체생성 <String>
        
        lst.add("a");  //add메소드
        lst.add("b");
        lst.add("c");
        lst.add(0, "x");  //처음에 추가
        lst.add("y");  //마지막에 추가
        System.out.println(lst);  //[x, a, b, c, y]
        
        lst.remove(0);  //인덱스0 값 삭제
        System.out.println(lst);  //[a, b, c, y]
        
        lst.remove("b");  //"b"삭제 (없으면 삭제하지 않음)
        System.out.println(lst);  //[a, c, y]
        
        lst.set(1, "new!");  //인덱스1 값을 new!로 변경
        System.out.println(lst);  //[a, new!, y]
        
        System.out.println(lst.get(0));  //인덱스0 값 조회 //a
    }
}

- LinkedList

인접 참조를 링크하여 체인처럼 관리 (ArrayList 는 내부 배열에 객체 저장하여 인덱스로 관리)

(특정 인덱스 객체 제거 시 앞 뒤 링크만 변경되고 나머지 링크는 그대로 유지 - 빈번한 객체 삭제/삽입에서 유리한 성능)

package collection_;

import java.util.LinkedList; //LinkedList 클래스 import

public class ListEx02 {
    public static void main(String[] args) {
        
        LinkedList<String> lst = new LinkedList<String>(); //객체생성 <String>
		
		lst.add("a");  //add 메소드
		lst.add("b");
		lst.add("c");
		lst.addFirst("x");  //처음에 추가
		lst.addLast("y");  //마지막에 추가
		System.out.println(lst);  //[x, a, b, c, y]
		
		lst.remove();  //head(첫번째) 값 삭제
		System.out.println(lst);  //[a, b, c, y]
		
		lst.remove(1);  //인덱스1 값 삭제
		System.out.println(lst);  //[a, c, y]
		
		lst.set(1, "new!");  //인덱스1 값을 new!로 변경
		System.out.println(lst);  //[a, new!, y]
		
		String str1 = lst.peek();  //첫번째 값 조회
		System.out.println(str1);  //a
		System.out.println(lst);  //[a, new!, y]
		
		String str2 = lst.poll();  //첫번째 값 조회 후 삭제 
		System.out.println(str2);  //a
		System.out.println(lst);  //[new!, y]
	}    
}

---

2. Set 계열

Set 컬렉션: 인덱스로 관리하지 않음, 인덱스로 객체 검색 불가, 전체 객체 대상으로 한번씩 반복해서 객체 값 가져오는 반복자(Iterator) 제공

들어갈 때 순서와 나올 때 순서가 다를 수 있음

객체를 순서대로 저장하지 않음 / 동일한 객체 중복 저장을 허용하지 않음

- Iterator 인터페이스의 주요 메소드 -

1) hasNext(): 가져올 객체가 있으면 true, 없으면 false 반환

2) next(): 컬렉션에서 하나의 객체를 가져옴

3) remove(): Set 컬렉션에서 객체를 제거

- Set 계열 주요 메소드 -

- 객체 추가 기능

1) add(E e): 주어진 객체 저장 & 성공적으로 저장되면 true / 중복이면 false 반환

- 객체 검색 기능

1) contains(Object o): 주어진 객체가 저장되어 있는지 판단

2) isEmpty(): 컬렉션이 비어있는지 판단

3) iterator(): 저장된 객체를 한번씩 가져오는 반복자 객체를 반환

4) size(): 저장된 전체 객체 수 반환

- 객체 삭제 기능

1) clear(): 저장된 모든 객체 삭제

2) remove(Object o): 주어진 객체 삭제

 

- HashSet

Set 인터페이스를 구현한 클래스 (순서X 중복X - 순차적인 것보다 속도 빠름)

package collection_;

import java.util.*;  //Set, HashSet

public class SetEx01 {
    public static void main(String[] args) {  //main
        
        Set hs = new HashSet();  //객체생성
        
        hs.add("e");
        hs.add("d");
        hs.add("c");
        hs.add("b");
        hs.add("a");
        //순서대로 추가되지 않음
        hs.add(new Integer(4));  //숫자(정수) 4 추가
        
        boolean check1 = hs.add("f");  //true 반환되고 f 추가됨
        System.out.println(check1);  //true
        
        hs.add("e");  //중복, 추가되지 않음
        
        boolean check2 = hs.add("e");  //중복, false 반환되고 추가되지 않음
        System.out.println(check2);  //false
        
        System.out.println(hs);  //[a, b, c, d, 4, e, f]
        System.out.println(hs.size());  //7
        
        hs.remove("d");  //d 삭제
        System.out.println(hs);  //[a, b, c, 4, e, f]
        
        hs.clear();  //모두 삭제
        System.out.println(hs);  //[]
        
        if(hs.isEmpty()) {  //비어있다면 Empty 출력
            System.out.println("Empty");  //Empty
        }
    }
}

- TreeSet

Tree구조 기반으로 생성된 클래스

Set 기능 + 자동 정렬 기능

package collection_;

import java.util.TreeSet;

public class SetEx02 {
    public static void main(String[] args) {  //main
        
        TreeSet<String> ts = new TreeSet<String>();  //객체생성
        
        ts.add("hello");
        ts.add("cherry");
        ts.add("cat");
        ts.add("wow");
        //추가
        
        for(String str : ts) {
            System.out.print(str + "\t");
        }
    }
}

//cat  cherry  hello wow

package collection_;

import java.util.*;  //TreeSet, Random

public class ThEx {
    public static void main(String[] args) {
        
        TreeSet<Integer> xyz = new TreeSet<>();  //객체생성
        Random r = new Random();  //객체생성
        
        while(true) {
            
            int i = r.nextInt(45) + 1;  //1~45사이의 랜덤한 정수
            xyz.add(i);  //추가
            
            if(xyz.size() >= 6) break;  //크기가 6이 되면 탈출
        }
        
        System.out.println(xyz);  //[12, 14, 23, 27, 34, 43]
    }
}

---

3. Map 계열

Map 컬렉션: 키(lkey)와 값(value)으로 구성된 Entry 객체를 저장하는 구조

순서대로 저장하지 않음 / 키는 중복 저장 허용하지 않음, 값은 중복 저장 허용

- Map 계열 주요 메소드 -

- 객체 추가 기능

1) put(K key, V value): 주어진 키와 값을 추가 & 성공적으로 저장되면 그 값(value)을 반환

- 객체 검색 기능

1) containsKey(Object Key): 주어진 키가 있는지 확인

2) containsValue(Object value): 주어진 값이 있는지 확인

3) get(Object key): 주어진 키에 들어있는 값 반환

4) isEmpty(): 컬렉션이 비어있는지 확인

5) size(): 저장된 전체 키의 수 반환

6) values(): 저장된 모든 값을 컬렉션에 담아서 반환

7) keySet(): 저장된 모든 키를 Set 객체에 담아서 반환

8) entrySet(): 키와 값의 쌍으로 구성된 모든 Entry 객체를 Set에 담아서 반환

- 객체 삭제 기능

1) clear(): 모든 Entry 삭제

2) remove(Object key): 주어진 키와 일치하는 Entry 객체 삭제

 

- HashMap

package collection_;

import java.util.*;  //HashMap, Map, Date, Set

public class MapEx {
    public static void main(String[] args) {  //main
        
        Map mp = new HashMap();  //객체생성
        
        //추가
        mp.put("name", "김사원");
        mp.put("name", "이사원");
        //key 중복 허용X, 중복 시 가장 마지막에 받은 value 가 저장됨
        mp.put("tester", "이사원");
        //value 중복 허용O
        mp.remove("tester");  //주어진 key 삭제
        
        mp.put("salary", 20000);
        mp.put("date", new Date());
        //순서X
        System.out.println(mp);
        //{date=Sun Sep 26 01:09:32 KST 2021, name=이사원, salary=20000}
        
        //주어진 key의 value 반환
        System.out.println(mp.get("name"));  //이사원
        System.out.println(mp.get("date"));  //Sun Sep 26 01:09:32 KST 2021
        System.out.println(mp.get("salary"));  //20000
        
        
        //map 안의 element를 entrySet()메소드로 조회
        Set<Map.Entry<String, Object>> s = mp.entrySet();  //entrySet()
        for(Map.Entry<String, Object> me : s) {
            System.out.println(me.getKey() + ": " + me.getValue());  //getKey(), getValue()
        }
        //date: Sun Sep 26 01:09:32 KST 2021
        //name: 이사원
        //salary: 20000
        
        
        //keySet()메소드로 map의 key를 반환받아 get(key)메소드로 조회
        Set<String> ss = mp.keySet();
        for(String key : ss) {
            System.out.println(key + ":: " + mp.get(key));
        }
        //date:: Sun Sep 26 01:09:32 KST 2021
        //name:: 이사원
        //salary:: 20000
    }
}