배열
배열이란?
여러 개의 단일 타입 값들을 가지고 있는 객체
// 선언
// 데이터타입[] 변수명;
int[] arr;
// 생성
// new 데이터타입[배열 크기]
arr = new int[3];
// 초기화
int[] numArr = {1, 2, 3, 4, 5};얕은 복사 (Shallow Copy)
복사한 배열이 원래 배열의 주소값을 복사하기 때문에 복사한 배열을 수정할 경우, 원래 배열도 수정됨
int[] a = { 1, 2, 3, 4 };
int[] b = a; // 얕은 복사
b[0] = 3; // 복사한 배열의 값을 수정하면
System.out.println(a[0]); // 3, 원래 배열의 값도 수정됨깊은 복사 (Deep Copy)
복사하 배열이 원래 배열을 그대로 복사하기 때문에 복사한 배열을 수정할 경우, 원래 배열은 수정되지 않음
import java.util.Arrays;
// 깊은 복사
int[] a = { 1, 2, 3, 4 };
int[] b = Arrays.copyOf(a, a.length)
b[0] = 3; // 복사한 배열의 값을 수정하면
System.out.println(a[0]); // 1, 원래 배열의 값은 수정되지 않음다차원 배열
- 2차원 배열
// 선언
// 데이터타입[][] 변수명;
int[][] arr;
// 생성
arr = new int[2][3];
// 초기화
int[][] numArr = {{1, 2, 3}, {4, 5, 6}};
int[][] numArr2 = new int[2][3];
for (int i = 0; i < numArr2.length; i++) {
for (int j = 0; j < numArr2[i].length; j++) {
arr[i][j] = 0;
}
}- 가변 배열
행마다 다른 길이의 배열을 저장할 수 있는 배열
int[][] array = new int[3][];
// 행마다 다른 길이를 설정
array[0] = new int[2];
array[1] = new int[4];
array[2] = new int[1];
int[][] array2 = {
{10, 20},
{10, 20, 30, 40},
{10}
};컬렉션
List
- ArrayList
- 정적 배열 :
Array처럼 크기를 고정하여 생성하는 것 - 동적 배열 :
ArrayList처럼 크기가 가변적으로 늘어나는 것
Array는 요청한 크기만큼의 연속된 공간을 메모리로부터 받아서 값을 저장하기 때문에 정적 배열이라고 칭함ArrayList는 생성 시점에 메모리로부터 받은 작은 연속된 공간에 참조형 변수들을 담아놓고, 값이 추가되어 더 큰 공간이 필요하면 더 큰 공간을 받아서 저장하기 때문에 동적 배열이라고 칭함
- 정적 배열 :
import java.util.ArrayList;
// 선언 및 생성
// ArrayList<데이터타입(래퍼 클래스)> 변수명 = new ArrayList<>();
ArrayList<Integer> intList = new ArrayList<>();
// 값 추가
// ArrayList명.add(추가할 값);
intList.add(1);
intList.add(2);
intList.add(3);
// 값 수정
// ArrayList명.set(대상 인덱스, 수정할 값);
intList.set(1, 10); // [1, 10, 3]
// 값 삭제
// ArrayList명.remove(대상 인덱스);
intList.remove(1); // [1, 3]
// 값 조회
// ArrayList명.get(대상 인덱스);
intList.get(1); // [3];
// 전체 출력
// ArrayList명.toString();
intList.toString(); // [1, 3]
// 전체 삭제 (내부 값만)
// ArrayList명.clear();
intList.clear(); // []- LinkedList
- 메모리에 남는 공간을 요청해서 값을 저장하고, 실제 값이 여기저기 나눠져 있기 때문에 실제 값의 주소값으로 목록을 구성하고 저장
- 기본적인 기능은 ArrayList와 동일하지만 값이 나눠져 있기 때문에 전체 조회 속도는 느림
- 대신 값을 중간에 추가 / 삭제할 때는 빠름
import java.util.LinkedList;
// 선언 및 생성
// LinkedList<데이터타입(래퍼 클래스)> 변수명 = new LinkedList<>();
LinkedList<Integer> linkedList = new LinkedList<>();
// 값 추가
// LinkedList명.add(추가할 값);
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
// LinkedList명.add(대상 인덱스, 추가할 값);
linkedList.add(2, 10); // [1, 2, 10, 3]
// 값 수정
// LinkedList명.set(대상 인덱스, 수정할 값);
linkedList.set(1, 4); // [1, 4, 10, 3]
// 값 삭제
// LinkedList명.remove(대상 인덱스);
linkedList.remove(0); // [4, 10, 3]
// 값 조회
// LinkedList명.get(대상 인덱스);
linkedList.get(1); // [10]
// 전체 출력
// LinkedList명.toString();
linkedList.toString(); // [4, 10, 3]
// 전체 삭제 (내부 값만)
// LinkedList명.clear();
linkedList.clear(); // []- Stack(LIFO)
상자에 물건을 넣고 빼는 것과 같은 방식으로서가장 먼저 들어간 데이터가 가장 나중에 나온다 (Last In First Out)라는 성질을 지님
import java.util.Stack;
// 선언 및 생성
// Stack<데이터타입(래퍼 클래스)> 변수명 = new Stack<>();
Stack<Integer> intStack = new Stack<>();
// 값 추가
// Stack명.push(값);
intStack.push(1);
intStack.push(2);
intStack.push(3); //
// 가장 위의 값 조회
// Stack명.peek();
intStack.peek(); // 3, [3, 2, 1]
// 가장 위의 값 꺼내고 삭제
// Stack명.pop();
intStack.pop(); // 3, [2, 1]
intStack.pop(); // 2, [1]Queue(FIFO)
빨대처럼 한쪽에서 데이터를 넣으면 반대쪽에서 데이터를 뺄 수 있는 방식으로서 가장 먼저 들어간 데이터가 가장 먼저 나온다 (First In First Out)라는 성질을 지님
import java.util.LinkedList;
import java.util.Queue;
// 선언 및 생성
// 생성자가 없기 때문에 LinkedList를 사용
// Queue<데이터타입(래퍼 클래스)> 변수명 = new LinkedList<>();
Queue<Integer> intQueue = new LinkedList<>();
// 값 추가
// Queue명.add(값);
intQueue.add(1);
intQueue.add(2);
intQueue.add(3); // [1, 2, 3]
// 가장 위의 값 조회
// Queue명.peek();
intQueue.peek(); // 1, [1, 2, 3]
// 가장 위의 값 꺼내고 삭제
// Queue명.poll();
intQueue.poll(); // 1, [2, 3]
intQueue.poll(); // 2, [3]Set
순서가 없는 데이터의 집합 (데이터 중복 허용 안함)
import java.util.HashSet;
import java.util.Set;
// 선언 및 생성
// 생성자가 없기 때문에 HashSet을 사용
// Set<데이터타입(래퍼 클래스)> 변수명 = new HashSet<>();
Set<Integer> intSet = new HashSet<Integer>();
// 값 추가
// Set명.add(값);
intSet.add(1);
intSet.add(2);
intSet.add(3); // [1, 2, 3]
intSet.add(3); // 중복된 값은 덮어씀, [1, 2, 3]
// 값 삭제
// Set명.remove(값);
intSet.remove(2); // [1, 3]
// 값 확인
// Set명.contains(값);
intSet.contains(2); // false- HashSet : 가장 빠르며 순서를 전혀 예측할 수 없음
- TreeSet : 정렬된 순서대로 보관하며 정렬 방법을 지정할 수 있음
- LinkedHashSet : 추가된 순서, 또는 가장 최근에 접근한 순서대로 접근 가능
Map
key-value 구조로 데이터를 저장하기 때문에 key값을 기준으로 value를 조회하며, key값은 중복을 허용하지 않음
import java.util.Map;
// 선언 및 생성
// Map<key의 데이터타입(래퍼 클래스), value의 데이터타입(래퍼 클래스)> 변수명 = new HashMap<>();
Map<String, Integer> intMap = new HashMap<>();
// 값 추가
// Map명.put(key값, value값);
intMap.put("일", 1);
intMap.put("이", 2);
intMap.put("삼", 3);
intMap.put("삼", 15); // 중복되는 key값은 새로운 value값으로 덮어씀
// 값 조회
// Map명.get(key값);
intMap.get("삼") // 15
// 값 삭제
// Map명.remove(key값);
intMap.remove("일");
// 전체 key값
// intMap.keySet();
for (String key : intMap.keySet()) {
System.out.println(key); // ["이", "삼"]
}
// 전체 value값
// intMap.values();
for (Integer key : intMap.values()) {
System.out.println(key); // [2, 15]
}- HashMap : 중복을 허용하지 않고 순서를 보장하지 않음, 키와 값으로 null이 허용
- TreeMap : key 값을 기준으로 정렬을 할 수 있습니다. 다만, 저장 시 정렬(오름차순)을 하기 때문에 저장시간이 다소 오래 걸림
