Collection

Collection이란?
배열보다 다수의 참조형 데이터를 더 쉽고 효과적으로 처리할 수 있는 기능을 많이 가지고 있다. 기능은 주로 크기 자동 조정/ 추가/ 수정/ 삭제/ 반복/ 순회/ 필터/ 포함 확인 등이 있다.

종류 : List, Set , Queue , Map

List : 선입 선출의 형태로 배열과 비슷한 형태를 지니고 있다
List의 종류

ArrayList -> 배열(Array)처럼 일렬로 데이터를 저장하고 조회하여 순번 값(인덱스)로값을 하나씩 조회
LinkedList -> 메모리에 남는 공간을 요청해서 여기저기 나누어서 실제 값을 담아 놓고, 실제 값이 있는 주소값으로 목록을 구성, 값을 조회 했을때 여기저기 나누어서  조회 하는 속도가 느리다.

ArrayList 사용 예시

import java.util.ArrayList; 

public class Col1 {
public static void main(String[] args) {
    //List
    //순서가 있는데이터의 집합 -> Array (최초의 길이를 알아야함)
    //처음에 길이를 몰라도 만들수 있음
    //1> Array -> 정적 배열
    //2> List(ArrayList)-> 동적 배열 (크기가 가변적으로 늘어남)
    //      - 생성시점에 작은 연속된 공간을 요청해서 참조형 변수들을 담아 놓는다.
    //      - 값이 추가될떄 더 큰 공간이 필요하묜 더 큰 공간을 받아서 저장하니깐. 상관없다.
    ArrayList<Integer> intlist = new ArrayList<Integer>();// ArrayList 선언과 생성을 동시에 진행

    intlist.add(99); //LIST에 .add()로 99 추가
    intlist.add(15);
    intlist.add(3);
    System.out.println(intlist.get(0));

    //2번째 있는 값 을바꿔보자

    intlist.set(1,10); //1번째 자리 값을 10으로 변경
    System.out.println(intlist.get(1));

    //삭제
    intlist.remove(0);//0번째 자리값 삭제 진행
    
    System.out.println(intlist.get(0));

    System.out.println("클리어전 ");
    System.out.println(intlist.toString());

    intlist.clear();
    System.out.println("클리어후 ");
    System.out.println(intlist.toString());
	}
	}

결과 값

LinkedList 사용 예시
``

import java.util.LinkedList;

public class Col2 {
public static void main(String[] args) {
    //linked list
    // 메모리에 남는 공간을 요청해서 여기저기 나누어서 실제값을 담아 놓는다.
    // 실제 값이 있는 주소값으로 목록을 구성하고 저장하는 자료 구조

    //기본적 기능른 -> ArratList와 동일
    //linkedList는 값 -> 여기저기 나누어서  조회 하는 속도가 느리다.
    // 값을 추가하거나 삭제할때는 빠르다

    LinkedList<Integer> Linkedlist = new LinkedList<Integer>();
    Linkedlist.add(5); //0번째 주소에 5값을 넣는다
    Linkedlist.add(10); //1번째 주소에 10값을 넣는다
    Linkedlist.add(3); //2번째 주소에 3값을 넣는다

    System.out.println(Linkedlist.get(0));
    System.out.println(Linkedlist.get(1));
    System.out.println(Linkedlist.get(2));

    System.out.println(Linkedlist.toString());// 이렇게 조회 할때는 ArrayList보다 현저히 느리다.

    Linkedlist.add(200); //2번째 주소에 200값을 넣는다
    System.out.println(Linkedlist.toString());
    Linkedlist.add(2,4);
    System.out.println(Linkedlist.toString());

    Linkedlist.set(1,30); //1번째 주소값의 30 변경
    System.out.println(Linkedlist.toString());

    Linkedlist.remove(1);//1번째 주소값의 삭제
    System.out.println(Linkedlist.toString());

    Linkedlist.clear(); //전체 삭제
    System.out.println(Linkedlist.toString());
	}
}

``

Stack 사용법

import java.util.Stack;

public class Col3 {
public static void main(String[] args) {
    //stack
    //수직으로 값을 쌓아놓고 넣었닥다 뺀다. FILO
    //push(값을 추가) peek(맨위 값 조회) pop (맨 위값을 꺼냅니다. 꺼내고 나면 삭제됨)
    // 최근에 저장된 데이터를 나열하고 싶거나 , 데이터의 중복 처리를 막고 싶을때 사용
    Stack<Integer> intStack = new Stack<Integer>();// 선언 및 생성

    intStack.push(10);
    intStack.push(15);
    intStack.push(11);

    while (!intStack.isEmpty()) {
        System.out.println(intStack.pop()); // 11 , 15 , 10 순으로 출력
    }

    //peak
    intStack.push(10);
    intStack.push(15);
    intStack.push(11);
    System.out.println(intStack.peek());
    System.out.println(intStack.size());
	}
}

Queue : First In First Out의 형태로 데이터가 먼저 들어갔으면 나중에 나오는 형태다.

Queue사용 예시

import java.util.LinkedList;
import java.util.Queue;

public class Col4 {
	public static void main(String[] args) {
    //Queue -> 선입 선출의 자료구조
    //add(값을 맨 위에 추가),peek(맨 아래 값을 조회),poll(맨 아래 값을 꺼냅니다. 꺼내고 나면 삭제됨)
    //Queue생성자가 없는 인터페이스

    Queue<Integer> intQueue = new LinkedList<Integer>();//Queue 선언 후 생성

    intQueue.add(1);
    intQueue.add(5);
    intQueue.add(9);
    //intQueue.isEmpty()은 intQueue의 값이 비었는가에 대한 조건이고 현재 값이 있으므로 false, 앞에 !를 붙였으니 ture가 된다.
    while (!intQueue.isEmpty()) {
        System.out.println(intQueue.poll());//1 5 9 
    }

    intQueue.add(1);
    intQueue.add(5);
    intQueue.add(9);
    intQueue.add(10);
    intQueue.add(4);
    //peek
    System.out.println(intQueue.peek()); //1
    System.out.println(intQueue.size()); // size 값 
}
}

set : 순서가 없는 데이터의 집합 (데이터 중복 허용 안 함)
set사용 예시

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
	public class Col5 {
	public static void main(String[] args) {
    //set -> 집합 순서없고 중복 없음
    //순서가 보장되지 않는 대신 중복을 허용하지 않도록 하는 프로그램에서 사용할수 있는 자료 구조
    //set -> 그냥 쓸수도 있음. 그러나 HashSet,TreeSet 등으로 응용해서 같이 사용 가능
    //set 생성자가 없는 껍데기라서 바로 생성할수 없음
    // 생성자가 존재하는 HashSet을 사용해서 ->set 구현 가능
    Set<Integer> set = new HashSet<Integer>();
    set.add(1);
    set.add(12);
    set.add(5);
    set.add(9);
    set.add(1);  //먼저 1을 넣었기 때문에 조회가 안된다.
    set.add(12); //먼저 12을 넣었기 때문에 조회가 안된다.

    for (Integer i : set) {
        System.out.println(i);
    }
    //contains
    System.out.println(set.contains(2)); //set내에 2가 존재하는지 확인 없으면 false
    System.out.println(set.contains(5)); //set내에 5가 존재하는지 확인 있으면 true
}
}

Map : 순서가 없는 (Key, Value) 쌍으로 이루어진 데이터의 집합 (Key값 중복 허용 안 함)

map 사용 예시

import java.util.HashMap;
import java.util.Map;


public class Col6 {
	public static void main(String[] args) {
    //Map : key - value pair -> 중요
    //key 값으로 unique 하게 보장이 돼야함
    //Map -> HashMap,TreeMap응용

    Map<String, Integer> intmap = new HashMap<>();
    intmap.put("일", 11); //일 키라는 값과 11이라는 정수 값을 넣는다.
    intmap.put("이", 12);
    intmap.put("삼", 13);
    intmap.put("삼", 14);//밑에 삼 들은 중복값이 있으면 1개만 출력이 되고 가장 맨아래에 넣었던 값을 기준으로 출력
    intmap.put("삼", 15);
    intmap.put("삼", 16);

    //키값 전체를 출력
    for(String key : intmap.keySet()) {
        System.out.println(key );
    }
    //value 값 전체를 출력
    for(Integer value : intmap.values()) {
        System.out.println(value );
    }

    System.out.println(intmap.get("삼"));
}
}

해당 예제에 관한 숙제제출

**자료구조 요리 레시피 메모장 만들기**

• 입력값
  • 저장할 자료구조명을 입력합니다. (List / Set / Map)
  • 내가 좋아하는 요리 제목을 먼저 입력합니다.
  • 이어서 내가 좋아하는 요리 레시피를 한 문장씩 입력합니다.
  • 입력을 마쳤으면 마지막에 “끝” 문자를 입력합니다.
• 출력값
  - 입력이 종료되면 저장한 자료구조 이름과 요리 제목을 괄호로 감싸서 먼저 출력해 줍니다.
  - 이어서, 입력한 모든 문장 앞에 번호를 붙여서 입력 순서에 맞게 모두 출력해 줍니다.

숙제 코드

import java.util.*;

public class HomeWork2 {
public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.print("자료구조를 입력 하세요 : ");
    //입력하는 곳
    String select = sc.nextLine();

    int number = 0;
    String recipe;


    if (select.equals("List")) {
        //List일 경우
        List<String> list = new ArrayList<String>();
        System.out.println("제목 및 레시피를 입력하세요");
        //무한 루프로 끝을 입력시 Break
        while (true) {
            list.add(sc.nextLine());
            if (list.contains("끝")) {
                break;
            }
        }
        for (int i = 0; i < list.size(); i++) {
            if (i == 0) {
                //제목의 입력된 부분은 따로 빼서 다르게 출력
                System.out.println("[LIST 으로 저장된 " + list.get(i) + "]");
                continue;
            }
            if (list.get(i).equals("끝")) { //LIST 문자열 비교를 위해서는 == 아닌 .equals를 사용
                break;
            } else {
                System.out.println(i + ". " + list.get(i));
            }
        }
    } else if (select.equals("set")) {
        //그냥 set을 사용할 경우 순서가 보장이 되지 않아 Linkedset사용
        LinkedHashSet<String> set = new LinkedHashSet<>();
        //무한 루프로 끝을 입력시 Break
        while (true) {
            set.add(sc.nextLine());
            if (set.contains("끝")) {
                break;
            }
        }
        //set의 데이터를 읽어오기 위해
        Iterator<String> iterator = set.iterator();

        for (int i = 0; i < set.size(); i++) {
            if (i == 0) {
                //제목의 입력된 부분은 따로 빼서 다르게 출력
                System.out.println("[SET 으로 저장된 " + iterator.next() + "]");
            } else if (i == set.size() - 1) {//끝이라는 단어는 마지막에 저장이 되어 있어서 마지막에 도착하면 break;
                break;
            } else {
                System.out.println(i + "." + iterator.next());
            }
        }
    } else if (select.equals("map")) {//MAP
        //그냥 MAP을 사용할 경우 순서가 보장이 되지 않아 LinkedHashMap
        LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
        while (true) {
            map.put(number, sc.nextLine());
            if (map.containsValue("끝")) {
                break;
            }
            number++;
        }
        for (int i = 0; i < map.size(); i++) {
            recipe = map.get(i);
            if (i == 0) {
                //제목의 입력된 부분은 따로 빼서 다르게 출력
                System.out.println("[map 으로 저장된 " + recipe + "]");
            } else if(recipe.equals("끝") ){
                break;
            } else {
                System.out.println(i  + ". " + recipe);
            }
        }
    }
}
}

해당 숙제 하면서 어려웠던점

set,map은 다른 자료구조 처럼 순서가 있게 데이터가 저장이 되는 형식이 아니다 보니 출력을 하는 방식이 어려웠음

해결방안

set은 LinkedHashSet(입력한 순서대로 출력 하는 방식) 후 문자열 방식의 Set의 데이터를 읽어오기 위해 Iterator 사용
map도 set과 비슷한 방식 대로 LinkedHashMap 사용