Collection

제네릭

자바에서 제네릭(generic)이란 데이터의 타입(data type)을 일반화한다(generalize)는 것을 의미합니다.

제네릭은 클래스나 메소드에서 사용할 내부 데이터 타입을 컴파일 시에 미리 지정하는 방법입니다.

제네릭 클래스

class AnimalList<T> {
    private ArrayList<T> animalList = new ArrayList<T>();

    void add(T animal) {
        animalList.add(animal);
    }

    void remove (T animal) {
        animalList.remove(animal);
    }

    T get(int index) {
        return animalList.get(index);
    }

    void print() {
        for (T animal : animalList) {
            System.out.print(animal + " ");
        }
    }
}

public class Generics {
    public static void main(String[] args) {
        // 제네릭스
        AnimalList<String> animalList = new AnimalList<>();
        animalList.add("Dog");
        animalList.add("Cat");
        animalList.add("Monkey");
        animalList.print();
        System.out.println(animalList.get(2));
        animalList.remove("Cat");
        animalList.print();
    }
}

제네릭 메소드

public static void main(String[] args) {
    // 제네릭스
    Integer[] iArray = {1, 2, 3, 4, 5};
    Double[] dArray = {1.0, 2.0, 3.0, 4.0, 5.0};
    String[] sArray = {"A", "B", "C", "D", "E"};

    printArray(iArray);
    printArray(dArray);
    printArray(sArray);
}

private static <T> void printArray(T[] arr) {
    for (T element : arr ){
        System.out.println(element);
    }
}

두 개 이상의 제네릭 사용하기

public static void main(String[] args) {
    orderCoffee("김영철");
    orderCoffee("김희철", "아메리카노");

}

public static <T> void orderCoffee(T name) {
    System.out.println("커피 준비 완료: " + name);
}

public static <T, V> void orderCoffee(T name, V coffee) {
    System.out.println(coffee + " 준비 완료: " + name);
}

---

Wrapper Class

프로그램에 따라 기본 타입의 데이터를 객체로 취급해야 하는 경우가 있습니다.

예를 들어, 메소드의 인수로 객체 타입만이 요구되면, 기본 타입의 데이터를 그대로 사용할 수는 없습니다.

이때에는 기본 타입의 데이터를 먼저 객체로 변환한 후 작업을 수행해야 합니다.

위의 그림과 같이 기본 타입의 데이터를 래퍼 클래스의 인스턴스로 변환하는 과정을 박싱(Boxing)이라고 합니다.

반면 래퍼 클래스의 인스턴스에 저장된 값을 다시 기본 타입의 데이터로 꺼내는 과정을 언박싱(UnBoxing)이라고 합니다.

---

Collection

데이터 구조

1. 변수
2. 배열 : 인덱스, 대량
3. 리스트 : 인덱스, 대량, 추가/삭제/변경 용이
4. set : 집합 구조 - 중복, 순서 없음
5. map : Key-Value (JSON, Class(변수-값))

---

List

• ArrayList
  • 저장 용량을 초과한 객체들이 들어오면 자동적으로 늘어남.
  • 객체 제거 시, 바로 뒤 인덱스부터 마지막 인덱스까지 모두 앞으로 1씩 당겨짐.
• LinkedList
  • 인접 참조를 링크해서 체인처럼 관리
  • 특정 인덱스에서 객체를 제거하거나 추가하게 되면 바로 앞뒤 링크만 변경
  • 빈번한 객체 삭제와 삽입이 일어나느 곳에서 ArrayList보다 좋은 성능

ArrayList

// 컬렉션 프레임 워크 (List, Set, Map)
List<String> list = new ArrayList(); // **upcasting** 더 많이 쓰는 표현

// 추가
list.add("만수르");
list.add("마동석");
list.add("임영웅");
list.add("유재석");

// 확인
System.out.println(list.get(3));
System.out.println(list.size()); // 4

// 제거
list.remove("임영웅");
System.out.println(list.size()); // 3

// 정렬
System.out.println(list); // [만수르, 마동석, 유재석]
Collections.sort(list);
System.out.println(list); // [마동석, 유재석, 만수르]

Collections.sort(list, Collections.reverseOrder());
System.out.println(list); // [만수르, 유재석, 마동석]

for (String name : list)
    System.out.println(name);

// 변경
list.set(1, "신세경");
System.out.println(list.get(1));

// 확인
System.out.println(list.indexOf("만수르"));
System.out.println(list.contains("유재석") ? "포함O" : "포함X");

// 전체 삭제
list.clear();
System.out.println(list.isEmpty() ? "지움" : "못지움");

LinkedList

LinkedList<String> list = new LinkedList<>();

// 추가
list.add("유재석");
list.add("조세호");
list.add("강호동");

// 조회
System.out.println(list.get(0));
System.out.println(list.get(1));
System.out.println(list.getFirst());
System.out.println(list.getLast());

// 추가
list.addFirst("차은우");
System.out.println(list.getFirst());
list.addLast("류준열");
System.out.println(list.getLast());
list.add(2, "최우식");

System.out.println("----------------------------");
for (String name: list) {
    System.out.println(name);
}

---

Set

• 중복 저장 불가
• 저장 순서 유지되지 않음
• 순서 유지하고 싶은 경우 LinkedHashSet 사용

HashSet

HashSet<String> set = new HashSet<>();
set.add("삼겹살");
set.add("상추");
set.add("쌈장");
set.add("삼겹살");
set.add("깻잎");
set.add("소금");
System.out.println("----------------------------");
for (String s : set) {
    System.out.println(s);
}

// 확인
if (set.contains("삼겹살")) {
    System.out.println("출발");
} else {
    System.out.println("삼겹살 사야함");
}

// iterator
System.out.println("----------------------------");
Iterator iter = set.iterator();
while (iter.hasNext()) {
    System.out.println(iter.next());
}

// 삭제
set.remove("삼겹살");
set.clear();
System.out.println(set.isEmpty() ? "다 삼" : "아직 덜 삼");

System.out.println("----------------------------");
Set<Integer> setA = new HashSet<>();
Set<Integer> setB = new HashSet<>();

setA.add(1);
setA.add(2);
setA.add(3);

setB.add(1);
setB.add(3);
setB.add(5);

setA.addAll(setB);
System.out.println(setA); // [1, 2, 3, 5]

setA.removeAll(setB);
System.out.println(setA); // [2]

---

Map

• 키와 값으로 구성된 Map.Entry 객체를 저장하는 구조
• 키와 값은 모두 객체
• 키는 중복될 수 없지만 값은 중복 저장 가능
• 입력 순서와 출력 순서는 동일하지 않을 수 있음 (key 값이 Set으로 관리)
• 순서 유지하고 싶은 경우 LinkedHashMap 사용

HashMap

// 맵 (Key, Value)
HashMap<String, Integer> map = new HashMap<String, Integer>();

// 데이터 추가
map.put("유재석", 10);
map.put("박명수", 20);
map.put("김종국", 30);

System.out.println("총 고객 수 : " + map.size());

// 조회
System.out.println(map.get("유재석"));

// 확인
if (map.containsKey("서장훈")) {
    int point = map.get("서장훈");
    map.put("서장훈", ++point);
} else {
    System.out.println("서장훈님, 신규 등록");
    map.put("서장훈", 1);
}

// 삭제
map.remove("유재석");
System.out.println(map.get("유재석"));

// iterator
// map.keySet();
// map.values();
Iterator iter = map.keySet().iterator();
while (iter.hasNext()) {
    Object key = iter.next();
    Integer value = map.get(key);
    System.out.println(key + value.toString());
}

Reference

https://www.tcpschool.com/java/