오늘은 collection 에 대해서 알아 보겠습니다.
collection 의 종류는
-
List
-
Set
-
Map
-
Queue
-
stack
이렇게 구성되어 있습니다.
List 에 대해 알아 보겠습니다.
1) 리스트는 순서가 있는 데이터의 집합이고, 데이터 중복을 허용합니다.
ArrayList , LinkedList
-
ArrayList
배열(Array) 처럼 일렬로 데이터를 저장하고 조회하여 인덱스(순번) 으로 값을 하나씩 조회할 수 있습니다.
Array 와 ArrayList는 유사해 보이지만 크기의 면애서 차이를 보입니다.
배열 Array는 처음에 크기를 고정하여 생성합니다. => 정적 배열, 기본형 변수
( int, long, double 등등)
ArrayList는 계속해서 가변적으로 크기를 늘려 나갈 수 있습니다. => 동적 배열, 참조형 변수
( Integer, Long, double, String 등등)
자 그럼 ArrayList 를 한번 생성해 보겠습니다.
먼저 선언을 해줍니다.
ArrayList<Integer> intList다음으로 생성을 해줍니다.
new ArrayList<Integer>();코드로 한번 확인 해 보겠습니다.
ArrayList<Integer> intList = new ArrayList<Integer>(); // 선언 및 생성이와 같이 생성 해주고 다음으로 값을 추가, 삭제, 수정, 호출을 한번 해보겠습니다.
package operator;
import java.util.ArrayList;
public class Practice {
public static void main(String[] args) {
ArrayList<Integer> intList = new ArrayList<Integer>();
intList.add(10);
intList.add(2);
intList.add(5);
intList.add(7);
System.out.println(intList);
System.out.println(intList.get(1));
System.out.println(intList.get(2));```
위와 같이 값을 추가 하고 싶을때 add 를 이용합니다.
intList.add(입력할 값);그럼 실제로 값을 출력해 보겠습니다.
System.out.println(intList.get(0));
System.out.println(intList.get(1));
System.out.println(intList.get(2));
System.out.println(intList.get(3));
10
2
5
7
이와 같이 값을 호출 할 때에는 get을 이용해서 호출합니다.
intList.get(인덱스 번호);그럼 삭제를 한번 해보겠습니다. 삭제는 remove 를 이용해서 삭제합니다.
intList.remove(인덱스 번호);
intList.remove(0);0번째 인덱스 값을 삭제하게됩니다.
실제 값을 한번 확인해 보겠습니다.
package operator;
import java.util.ArrayList;
public class Practice7 {
public static void main(String[] args) {
ArrayList<Integer> intList = new ArrayList<Integer>();
intList.add(10);
intList.add(2);
intList.add(5);
intList.add(7);
System.out.println(intList.toString());
intList.remove(0);
System.out.println(intList.toString());
}
} 결과 값을 확인해 보겠습니다. 다음과 같이 0번째 인덱스 값이 삭제 되신 것을 볼수 있습니다.
toString()은 배열에 저장된 전체 값을 []로 묶어서 가져옵니다.
[10, 2, 5, 7]
[2, 5, 7]
수정을 한번 해보겠습니다.
intList.set(인덱스넘버, 수정할 값);
코드로 적용해 보겠습니다.
intList.set(1,10);
System.out.println(intList.toString());
[10, 2, 5, 7]
[10, 10, 5, 7]보시는 것과 같 2번째 값(인덱스 번호 1)이 변경되신것을 볼수 있습니다.
- 다음으로는 LinkedList 입니다.
기본적인 기능은 ArrayList와 동일하지만 LinkedList는 값을 나누어 담기 때문에 모든 값을 조회하는 속도가 느립니다. 하지만 중간에 값을 추가하거나 삭제할 때는 속도가 빠릅니다.
그럼 코드를 작성해서 출력해 보겠습니다.
ArrayList와 기능은 동일하기 간단하게 보겠습니다.
추가
intLinked.add(추가할 값);삭제
intLinked.remove(안덱스 번호);수정
intLinked.set(인덱스 번호, 추가할 값);호출
intLinked.get(인덱스 번호)그럼 실제 코드를 구현해 보겠습니다.
public class Practice {
public static void main(String[] args) {
LinkedList<Integer> intList = new LinkedList<Integer>();
intList.add(10);
intList.add(2);
intList.add(5);
System.out.println(intList.get(0)); // 호출 10
System.out.println(intList.get(1)); // 호출 2
다음은 수정 및 삭제를 한번 해보겠습니다.
intList.add(10);
intList.add(2);
intList.add(5);
System.out.println(intList.toString());
intList.set(0, 5);
intList.remove(2);
System.out.println(intList.toString());
[10, 2, 5] // 수정 및 삭제 전 ( 인덱스번호 0번째 값을 5로 변경, 1번째 값 삭제)
[5, 2] // 수정 및 삭제 후
다음과 같이 수정 및 삭제 전과 후를 비교하면
인덱스번호 0번째 값을 5로 변경, 1번째 값 삭제
아까와 동일하게 전체 값을 대괄호로 출력합니다.
intLinked.toString() ```-
Map
Map은 다른 컬랙션과는 다르게 두 가지 참조형 변수(key, value)를 사용합니다.Map는 저장 방법과 조회, 전체 key 조회, 전체 value 조회
또한 Map는 기존 순번으로 조회하더 것과는 달리 key값은 해당 value값을 찾습니다.
중복도 허용하지 않습니다.
일단 오늘은 HashMap으로 진행해 보겠습니다.
먼저 선언 및 생성을 해보겠습니다.
Map<String, Integer> intmap = new HashMap<String, Integer>();
저장
intmap.put(Key, value);조회
intMap.get(조회할 Key값)전체 key 조회
intMap.keySet() 전체 value 조회
intMap.values()
그럼 실제로 저장 및 조회를 구현해서 출력해 보겠습니다.
Map<String, Integer> intmap = new HashMap<String, Integer>();
intmap.put("안", 11);
intmap.put("녕", 12);
intmap.put("하", 13);
System.out.println(intmap.get("안"));
System.out.println(intmap.get("하"));
11
13
그럼 실제로 키 중복을 허용하지 않는 것을 확인해 보겠습니다.
Map<String, Integer> intmap = new HashMap<String, Integer>();
// Set<String> strSet = new LinkedHashSet<String>();
intmap.put("안", 11);
intmap.put("녕", 12);
intmap.put("하", 13);
intmap.put("하", 999);
//
System.out.println(intmap.get("안"));
System.out.println(intmap.get("하"));
11
``` 999
이처럼 키가 중복되면 나중값 으로 변경됩니다.
-
다음으로 Set에 대해 알아보겠습니다.
-
Set은 순서가 보장되지는 않지만 중복을 허용하지 않습니다.
추가 및 삭제, 포함 확인이 가능합니다.
먼저 선언 및 생성 부터 해보겠습니다.
Set<Integer> intSet = new HashSet<Integer>();추가
intHashSet.add(추가할 값);삭제
intHashSet.remove(삭제할 값);포함 확인
intHashSet.contains(확인할 값);실제 구현해서 출력해 보겠습니다.
import java.util.HashSet;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Set<Integer> intSet = new HashSet<Integer>(); // 선언 및 생성
intSet.add(34);
intSet.add(5);
intSet.add(20);
intSet.add(34);
intSet.add(50);
intSet.add(20);
for (Integer value : intSet) {
System.out.println(value); // 34, 50, 20, 5 출력
}
System.out.println(intSet.toString()); // [ 34, 20, 5]
// contains()
System.out.println(intSet.contains(34)); // true 출력
System.out.println(intSet.contains(4)); // false 출력
// remove()
intSet.remove(50); // 50 삭제
for (Integer value : intSet) {
System.out.println(value); // 1,2 출력
위 코드와 같이
add
=> 결과 및 for문을 통해서 34, 20, 5 가 나오는걸 확인 할 수 있습니다.
contains
=> 통해서는 포함하는 값인지 아닌지 true / false 로 출력됩니다.
remove
=> List와 다르게 실제 값을 입력해서 삭제를 합니다.
그 밖에도
LinkedHashSet 이 존재하는데 HashSet과는 다르게 순서를 보장해주는 컬랙션이다.
간단하게 선언 및 생성과 순서 보장 여부만 알아보겠습니다.
Set<Integer> intSet1 = new LinkedHashSet<Integer>();
Set<Integer> intSet1 = new LinkedHashSet<Integer>();
intSet1.add(34);
intSet1.add(50);
intSet1.add(20);
intSet1.add(34);
intSet1.add(5);
intSet1.add(20); // 20, 34 중복 값
System.out.println(intSet1.toString());
// [34, 50, 20, 5]
이와 같이 순서가 보장되는 것을 확인 할 수 있습니다.
다음은 Stack과 Queue 입니다.
Stack 과 Queue 는 파이프와 바구니를 생각하시면 이해하는데 도움이 됩니다.
Stack 은 먼저 넣은 값이 가장 나중에 나오는 ( first in last out )
Queue 는 먼저 넣은 값이 가장 먼저 나오는 ( first in first out )
Stack 부터 선언 및 생성해 보겠습니다.
Stack<Integer> intStack = new Stack<Integer>();Stack은 추가, 맨 위값 확인 , 뽑기 이렇게 구성됩니다.
추가
intStack.push(추가할 값);맨 윗값 확인
intStack.peek()뽑기
intStack.pop()그럼 실제로 구현해서 출력해 보겠습니다.
public class Main {
public static void main(String[] args) {
Stack<Integer> intStack = new Stack<Integer>(); // 선언 및 생성
intStack.push(0);
intStack.push(3);
intStack.push(4);
while (!intStack.isEmpty()) { // 다 지워질때까지 출력
System.out.println(intStack.pop()); // 출력 4, 3, 0
} first in 0 , 3, 4 last out 4, 3, 0
// 다시 추가
intStack.push(55);
intStack.push(99);
intStack.push(142);
// peek()
System.out.println(intStack.peek()); // 142 출력
System.out.println(intStack.size()); // 3 출력 (peek() 할때 삭제 안됬음)
// pop()
System.out.println(intStack.pop()); // 142 출력
System.out.println(intStack.size()); // 2 출력 (pop() 할때 삭제 됬음)
} push
=> 바구니 값을 넣는 것과 비슷하게 first in 되서 넣는다.
peek
=> 맨 위에 값을 확인만 한다.
pop
=> 차례로 넣은 값을 하나씩 꺼내준다.
Queue 를 선언하고 생성해 보겠습니다. 생성자가 존재하는 LinkedList를 사용합니다.
queue<Integet> intQueue = new LinkedList<Integer>();Queue는 추가, 맨 아래 값 확인, 맨 아래 값 추출
추가
intQueue.add(추가할 값) 맨 아래값 확인
intQueue.peek()맨 아래값 확인
intQueue.poll()
import java.util.LinkedList;
import java.util.Queue;
public class Main {
public static void main(String[] args) {
Queue<Integer> intQueue = new LinkedList<>(); // 선언 및 생성
intQueue.add(1);
intQueue.add(2);
intQueue.add(3);
while (!intQueue.isEmpty()) { // 다 지워질때까지 출력
System.out.println(intQueue.poll()); // 1,2,3 출력
}
// 다시 추가
intQueue.add(29);
intQueue.add(19);
intQueue.add(24);
intQueue.add(67);
// peek()
System.out.println(intQueue.peek()); // 29출력 (맨먼저 들어간값이 29 라서)
System.out.println(intQueue.size()); // 4 출력 (peek() 할때 삭제 안됬음)
// poll()
System.out.println(intQueue.poll()); // 29 출력
System.out.println(intQueue.size()); // 3 출력 (poll() 할때 삭제 됬음)
System.out.println(intQueue.poll()); // 19 출력
System.out.println(intQueue.size()); // 2 출력 (poll() 할때 삭제 됬음)
위에 코드와 같이 작성하면 주석의 값이 출력된다.
add
=> 값을 추가해서 파이프에 값이 first in 된다.
peek
=> 맨 아래값을 확인해서 출력 한다.
poll
=> first in 된 값을 차례로 first out 한다.
혹시 제가 틀린 부분이 있다면 댓글 부탁 드립니다. !! 감사합니다.
