[JAVA] 지네릭스(Generics), 컬렉션(Collection)

💖 지네릭스(Generics)

다양한 타입의 객체들을 다루는 메서드나 컬렉션 클래스에 컴파일 시의 타입체크를 해주는 기능
자료형의 변수
같은 클래스에서 다양한 자료형을 사용하고 싶은 경우에 사용하는 요소

지네릭스의 장점
1. 타입의 안정성 제공
2. 타입체크, 형변환 생략할 수 있어 코드가 간결해짐

🔥 예시

public class MainClass {
	public static void main(String[] args) {
    	Box<Integer> box = new Box<Integer>(100);	// 실제 타입을 지정
        System.out.println(box.getTemp() + 2);
        
        Box<String> sbox = new Box<String>("Hello");
		System.out.println(sbox.getTemp());
        
        BoxMap<Integer, String> boxmap = new BoxMap<Integer, String>(1001, "홍길동");
		System.out.println(boxmap.getKey());
		System.out.println(boxmap.getValue());
        
        BoxMap<String, String> boxmap2 = new BoxMap<String, String>("Hello", "World");
		System.out.println(boxmap2.getKey());
		System.out.println(boxmap2.getValue());
    }
}
// 지네릭스 클래스의 선언
class Box<T> {	// 지네릭 타입 T를 선언. 다른 것 사용 가능
	T temp;
		
	public Box(T temp) {
		this.temp = temp;
	}

	public T getTemp() {
	    return temp;
	}

	public void setTemp(T temp) {
		this.temp = temp;
	}	
}

class BoxMap<KEY, VALUE> {	// 변수가 여러 개인 경우
	KEY key;
	VALUE value;
		
	public BoxMap(KEY key, VALUE value) {
		this.key = key;
		this.value = value;
	}

	public KEY getKey() {
		return key;
	}

	public void setKey(KEY key) {
		this.key = key;
	}

	public VALUE getValue() {
		return value;
	}

	public void setValue(VALUE value) {
		this.value = value;
	}
}

// console
/*
102
Hello
1001
홍길동
Hello
World
*/

💖 컬렉션(Collection)

데이터군을 저장하는 클래스들을 표준화한 설계. 지네릭스 형식
수집(데이터, Object)

핵심 인터페이스 : List, Set / Map

🔥 List

목록
순서가 있는 데이터의 집합. 중복 허용. 데이터 저장 순서 유지

구현 클래스 : ArrayList, LinkedList, Stack, Vector 등

🧾 ArrayList

: 배열처럼 사용할 수 있는 리스트 == 유동적 배열
: 선형구조
: 배열처럼 index로 접근하고 관리
: 검색속도가 빠르다

ArrayList<String> arrlist = new ArrList<String>();

추가

String str = new String("Tigers");
arrlist.add(str);

arrlist.add("Eagles");
arrlist.add("Bears");

리스트의 크기(길이)

System.out.println(arrlist.size());

for(int i = 0; i < arrlist.size(); i++) {
	System.out.println(i + ":" + arrlist.get[i]);	// == arrlist[i]
}
System.out.println();

arrlist.add("Lions");	// 맨뒤에 추가

for(int i = 0; i < arrlist.size(); i++) {
	System.out.println(i + ":" + arrlist.get[i]);	// == arrlist[i]
}
System.out.println();

arrlist.add(2, "Giants");	// index number 2에 추가
		
for (int i = 0; i < arrlist.size(); i++) {
	System.out.println(i + ":" + arrlist.get(i));	// == arrlist[i]
}
System.out.println();

// console
/*
0:Tigers
1:Eagles
2:Bears

0:Tigers
1:Eagles
2:Bears
3:Lions

0:Tigers
1:Eagles
2:Giants
3:Bears
4:Lions
*/

삭제

arrlist.remove(1);	// 삭제하고 싶은 index

for (int i = 0; i < arrlist.size(); i++) {
	System.out.println(i + ":" + arrlist.get(i));	// == arrlist[i]
}
System.out.println();

// console
/*
0:Tigers
1:Giants
2:Bears
3:Lions
*/

검색

int index = arrlist.indexOf("Giants");
System.out.println("데이터가 있습니다 " + index);

for (int i = 0; i < arrlist.size(); i++) {
	String s = arrlist.get(i);
    if("Giants".equals(s)) {
    	index = i;
        break;
    }
}
System.out.println("데이터가 있습니다 :" + index);

// console
/*
데이터가 있습니다 :1
데이터가 있습니다 :1
*/

수정

String updateStr = "Twins";

arrlist.set(2, updateStr);
for (int i = 0; i < arrlist.size(); i++) {
	System.out.println(i + ":" + arrlist.get(i));	// == arrlist[i]
}
System.out.println();

// console
/*
0:Tigers
1:Giants
2:Twins
3:Lions
*/

확장 for문

for([배열 자료형][변수명]:[배열명] or [컬렉션 객체명]){
    // 각각의 변수에 적용할 Java Code;
    // 변수는 배열 내의 각각의 값을 뜻함
}

🧾 예시: Human클래스를 이용한 List

// ArrayList<Human> list = new ArrayList<Human>();
List<Human> list = new ArrayList<Human>();

추가 -> 3명

Human human = new Human("홍길동", 24);	// name과 age변수를 갖는 Human class
list.add(human);

human = new Human("성춘향", 16);	
list.add(human);

list.add(new Human("일지매, 22"));

/*
for (int i = 0; i < list.size(); i++) {
Human h = list.get(i);
System.out.println(h.toString());
}
*/

// 확장 for문
for(Human h : list) {
	System.out.println(h.toString());
}
		
// console
/*
Human [name=홍길동, age=24]
Human [name=성춘향, age=16]
Human [name=일지매, age=22]
*/

삭제 -> 1명

String name = "일지매";
		
int findindex = -1;
for (int i = 0; i < list.size(); i++) {
Human h = list.get(i);
if(name.equals(h.getName())) {
	findindex = i;
	break;
	}
}
list.remove(findindex);
		
for(Human h : list) {
	System.out.println(h.toString());
}
System.out.println();

//console
/*
Human [name=홍길동, age=24]
Human [name=성춘향, age=16]
*/

검색 -> 이름

name = "성춘향";
findindex = -1;
for (int i = 0; i < list.size(); i++) {
	Human h = list.get(i);
	if(name.equals(h.getName())) {
		findindex = i;
		break;
	}
}
if(findindex != -1) {
	System.out.println(list.get(findindex).toString());
} else {
	System.out.println("데이터가 없습니다");
}
System.out.println();

// console
/*
Human [name=성춘향, age=16]
*/

수정 -> 1명

Human updateHuman = new Human("이몽룡", 17);
list.set(1, updateHuman);
		
for(Human h : list) {
	System.out.println(h.toString());
}
System.out.println();
		
System.out.println(list.toString());
// Arrays.toString()

// console
/*
Human [name=홍길동, age=24]
Human [name=이몽룡, age=17]

[Human [name=홍길동, age=24], Human [name=이몽룡, age=17]]
*/

🔥 Map

사전
키(key)와 값(value)의 쌍으로 이루어진 데이터의 집합 -> Entry
키는 중복 허용X, 값은 중복 허용O

구현 클래스 : HashMap, TreeMap, Hashtable, Properties 등

🧾 HashMap

: Map인터페이스를 구현한 대표적인 컬렉션 클래스
: 순서를 유지하려면 LinkedHashMap 사용
: 해싱기법으로 데이터 저장. 데이터가 많이도 검색이 빠르다

해싱(hashing)
: 해시함수(hash function)를 이용해서 해시테이블(hash table)에 데이터를 저장하고 읽어오는 것
-> key값을 넣으면 저장위치를 알려줌
: 해시테이블은 배열과 링크드리스트가 조합된 상태(2차원배열)-> 데이터 저장 공간

// HashMap<Integer, String> hMap = new HashMap<>();
Map<Integer, String> hMap = new HashMap<>();

추가

hMap.put(11, "Lions"); 
hMap.put(22, "Tigers");
hMap.put(33, "Twins");
hMap.put(44, "Bears");

hMap.put(33, "Giants");	// 같은 key값을 추가하면 value값이 바뀜

출력

// 모두 출력
// Iterator : 반복자( == 포인터(주소)) == cursor
Iterator<Integer> it = hMap.keySet().iterator();	// 가장 첫번째 주소

while(it.hasNext()) {
	Integer key = it.next();	// key값을 꺼내주면서 다음 주소를 가리킴
	String value = hMap.get(key);
	System.out.println(key+ " : " + value);
}

// console
/*
33 : Giants
22 : Tigers
11 : Lions
44 : Bears
*/

삭제

String deleteVal = hMap.remove(33);	// 삭제하면서 삭제한 데이터의 value값을 반환
System.out.println("삭제된 value: " + deleteVal);

// console
// 삭제된 value: Giants

검색

String value = hMap.get(11);	// 데이터를 꺼내옴

boolean b = hMap.containsKey(22);	// key의 존재여부
if(b == true) {
	String val = hMap.get(22);
    System.out.println("value: " + val);
}

// console
// value: Tigers

수정

hMap.replace(44, "Eagels");

it = hMap.keySet().iterator();
while(it.hasNext()) {
	Integer key = it.next();
    String val = hMap.get(key);
    System.out.println(key + " " + val);
}

// console
/*
22 Tigers
11 Lions
44 Eagels
*/

HashMap은 서로 다른 데이터도 담을 수 있음 (데이터타입 :Object)

String str = "hello";
Integer in = 456;
ArrayList<String> list = new ArrayList<>();

Map<String, Object> map = new HashMap<>();

map.put("문자열", str);
map.put("숫자", in);
map.put("목록", list);

🧾 TreeMap

: 범위 검색과 정렬에 유리한 컬렉션 클래스
: HashMap보다 데이터 추가, 삭제에 시간이 더 걸림

TreeMap<Integer, String> tMap = new TreeMap<>(hMap);

// 오름
Iterator<Integer> iter = tMap.keySet().iterator();
while(iter.hasNext()) {
	Integer k = iter.next();
	String v = tMap.get(k);
	System.out.println(k + " " + v);	// 정렬된 상태로 출력됨
}

// console.log
/*
11 Lions
22 Tigers
44 Eagels
*/

// 내림
Iterator<Integer> iter1 = tMap.descendingKeySet().iterator();
while(iter1.hasNext()) {
	Integer k = iter1.next();
	String v = tMap.get(k);
	System.out.println(k + " " + v);	// 정렬된 상태로 출력됨
}

// console.log
/*
44 Eagels
22 Tigers
11 Lions
*/