티스토리 뷰
1. String
1-1. 문자열 붙이기, 자르기
String N = "abcd";
Sring K = "efgh";
String s = N + K; //O(N+K)
s.substring(5); //"fgh" //O(N)
s.substring(0,3); //"abc"
1-2. 입력
BufferedReader - 입력 라이브러리, String 객체만 다룸
예1) 한 줄 입력, 한 줄에 한 단어
public Class main{
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = br.readLine();
.
.
.
예2) 한 줄 입력, 한 줄에 단어 여러개
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] input = br.readLine().split(" ");
.
.
.
예3) Int 입력
BufferedReader는 String 객체만 취급하기 때문에 먼저 String 변수로 문자열을 저장하고 추후에 Integer 객체로 변환해야 한다.
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int N = Integer.parseInt(br.readLine());
.
.
.
1-3. 출력
StringBuilder - 출력을 담당하는 class, 버퍼를 활용하여 문자열을 문자 시퀀스로 관리
String을 불변객체지만 StringBuilder는 가변객체.
예1) 문자열 하나 반환
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException{
StringBuilder sb = new StringBuilder();
//문자열 추가
sb.append("ab"); //ab
//다음 줄 이동
sb.append("ef\n");
/*
abef\n
------ 커서는 이 줄에 위치
*/
sb.append("ij").append("\n");
/*
abef\n
ij\n
------ 커서는 이 줄에 위치
*/
//문자열 삽입
sb.insert(2, "2");
/*
ab2ef\n
ij\n
------ 커서는 이 줄에 위치
*/
sb.insert(5, 5);
/*
ab2ef5\n
ij\n
------ 커서는 이 줄에 위치
*/
sb.insert(7, 7);
/*
ab2ef5\n
7ij\n
------ 커서는 이 줄에 위치
*/
sb.insert(6,6);
/*
ab2ef56\n
7ij\n
------ 커서는 이 줄에 위치
*/
//문자 삭제
sb.deleteCharAt(7);
/*
ab2ef567ij\n
------ 커서는 이 줄에 위치
*/
//문자열 삭제
sb.delete(8,11); //ab2f567------ 커서는 이 줄에 위치
//문자열 뒤집기
sb.reverse(); // 765f2ba
//문자 교체
sb.setCharAt(1, 'g'); //7g5f2ba
//문자열 교체
sb.replace(1,4,"change"); //7change2ba
//문자열 길이 조정
sb.setLength(2); //7c
//문자열 변환
sb.toString(); //7c
}
}
ArrayList
동적 배열 자료구조
중복되는 값 포함 가능
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
// ArrayList 생성
ArrayList<String> arrayList = new ArrayList<>();
// 요소 추가
arrayList.add("Apple");
arrayList.add("Banana");
arrayList.add("Orange");
// 요소 가져오기
String firstElement = arrayList.get(0); //Apple 반환
// 요소 수정
arrayList.set(1, "Grapes");
// 요소 제거
arrayList.remove(1); // 인덱스로 제거
rrayList.remove("Orange"); // 값으로 제거
// 요소가 포함되어 있는지 확인
boolean containsBanana = arrayList.contains("Banana");
// 특정 값의 인덱스 확인
int indexOfGrapes = arrayList.indexOf("Grapes");
// 사이즈 확인
int size = arrayList.size();
// 모든 요소 출력
for (String element : arrayList) {
System.out.println(element);
}
// ArrayList 비우기
arrayList.clear();
// ArrayList가 비어 있는지 확인
boolean isEmpty = arrayList.isEmpty(); //true반환
}
}LinkedList
dluble linked list 형태로 구현되어있음
요소들은 인덱스 순서를 유지
요소의 삽입, 삭제가 배열에 비해 효율적
인덱스 기반 접근은 ArayList보다 성능이 좋지 않음. 대신, 요소를 순차적으로 접근하는데 적합
메서드는 ArrayList와 동일
HashMap
키-값 쌍을 저장하는 자료구조
특정 키의 값을 검색하거나 저장하는데 사용됨
해시테이블을 기반으로 구현됨
해시 테이블: 키를 해시 함수를 사용해 해시 코드로 변환하고 이 해시 코드를 사용하여 값을 저장하거나 검색
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
// HashMap 생성
HashMap<String, Integer> hashMap = new HashMap<>();
// 요소 추가
hashMap.put("Apple", 10);
hashMap.put("Banana", 20);
hashMap.put("Orange", 30);
// 요소 가져오기
int appleQuantity = hashMap.get("Apple"); //O(1)
// 요소 수정
hashMap.put("Banana", 25); // O(1)
// 요소 제거
hashMap.remove("Orange");
// 사이즈 확인
int size = hashMap.size();
// 모든 요소 출력
System.out.println("HashMap의 모든 요소:");
for (String key : hashMap.keySet()) {
int value = hashMap.get(key);
System.out.println(key + ": " + value);
}
// HashMap에 특정 키가 포함되어 있는지 확인
boolean containsApple = hashMap.containsKey("Apple"); //O(1)
// HashMap의 모든 키(key) 가져오기
Set<String> keySet = hashMap.keySet();
}
}HashSet
Set 인터페이스를 구현
중복 X, 순서 X
해시 테이블을 기반으로 구현
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
// HashSet 생성
HashSet<String> hashSet = new HashSet<>();
// 요소 추가
hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Orange");
// 중복된 요소 추가
hashSet.add("Apple"); //O(1)
// 요소의 개수 확인
int size = hashSet.size(); //3
// 요소가 포함되어 있는지 확인 //O(1)
boolean containsBanana = hashSet.contains("Banana"); // 출력: true
// 요소 제거
hashSet.remove("Orange"); //O(1)
// HashSet이 비어 있는지 확인
boolean isEmpty = hashSet.isEmpty(); //false
// 모든 요소 출력
System.out.println("HashSet의 모든 요소:");
for (String element : hashSet) {
System.out.println(element);
}
// HashSet 비우기
hashSet.clear();
}
}Stack
LIFO - Lsat In first Out
Vector 클래스를 상속하여 구현
import java.util.Stack;
public class Main {
public static void main(String[] args) {
// 스택 생성
Stack<Integer> stack = new Stack<>();
// 요소 추가 (push) O(1)
stack.push(10); //index 1
stack.push(20); //index 2
stack.push(30); //index 3
// 요소 확인 (peek) O(1)
int topElement = stack.peek(); //30
// 요소의 인덱스 검색 (search) O(n)
int index = stack.search(20); //2
// 요소 제거 (pop) O(1)
int removedElement = stack.pop(); // 30 제거
stack.contains(10); //true, O(n)
// 스택이 비어 있는지 확인 (empty) O(1)
boolean isEmpty = stack.empty(); // false
// 스택의 모든 요소 출력
System.out.println("스택의 모든 요소:");
while (!stack.empty()) {
System.out.println(stack.pop());
}
}
}Queue
FIFO - First In First Out
전용 구조체가 존재하지 않음
일반적으로 LinkedList 클래스를 활용해 Queue 인터페이스를 구현
import java.util.Queue;
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
// Queue 생성 (LinkedList를 사용하여 구현)
Queue<Integer> queue = new LinkedList<>();
// 요소 추가 (offer) O(1)
queue.offer(10);
queue.offer(20);
queue.offer(30);
// 요소 확인 (peek) O(1)
int frontElement = queue.peek(); // 10
// 요소 제거 (poll) O(1)
int removedElement = queue.poll(); // 10
// Queue가 비어 있는지 확인 (isEmpty) O(1)
boolean isEmpty = queue.isEmpty(); // false
// Queue의 크기 확인 (size) O(1)
int size = queue.size(); // 2
// Queue의 모든 요소 출력
System.out.println("Queue의 모든 요소:");
for (int element : queue) {
System.out.println(element);
}
}
}PriorityQueue
요소를 우선순위에 따라 저장하고 제거
최소 힙을 사용하여 구현됨
중복값 허용
import java.util.PriorityQueue;
public class Main {
public static void main(String[] args) {
// PriorityQueue 생성
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
// 요소 추가 (offer) O(log n)
priorityQueue.offer(30);
priorityQueue.offer(10);
priorityQueue.offer(20);
// 요소 확인 (peek) O(1)
int topElement = priorityQueue.peek(); // 10
// 요소 제거 (poll) O(log n)
int removedElement = priorityQueue.poll(); // 10
// PriorityQueue가 비어 있는지 확인 (isEmpty) O(1)
boolean isEmpty = priorityQueue.isEmpty(); // false
// PriorityQueue의 크기 확인 (size) O(1)
int size = priorityQueue.size(); // 2
// PriorityQueue의 모든 요소 출력
System.out.println("PriorityQueue의 모든 요소:");
while (!priorityQueue.isEmpty()) {
System.out.println(priorityQueue.poll());
}
}
}Deque(Double-ended Queue)
양쪽 끝에서 삽입과 삭제를 모두 수행할 수 있는 큐(queue)의 확장된 형태
큐(Queue)와 스택(Stack)의 기능을 모두 제공
양쪽에서 요소를 추가하거나 제거
양방향으로 데이터를 처리해야 하는 상황에 매우 유용
ArrayDeque와 LinkedList를 이용하여 인터페이스 구현
더보기
- addFirst(E e): Deque의 맨 앞에 요소를 추가합니다.
- 시간 복잡도: O(1)
- addLast(E e): Deque의 맨 뒤에 요소를 추가합니다.
- 시간 복잡도: O(1)
- offerFirst(E e): Deque의 맨 앞에 요소를 추가하고 성공 여부를 반환합니다.
- 시간 복잡도: O(1)
- offerLast(E e): Deque의 맨 뒤에 요소를 추가하고 성공 여부를 반환합니다.
- 시간 복잡도: O(1)
- removeFirst(): Deque의 맨 앞에 있는 요소를 제거하고 반환합니다.
- 시간 복잡도: O(1)
- removeLast(): Deque의 맨 뒤에 있는 요소를 제거하고 반환합니다.
- 시간 복잡도: O(1)
- pollFirst(): Deque의 맨 앞에 있는 요소를 제거하고 반환합니다. Deque가 비어 있는 경우 null을 반환합니다.
- 시간 복잡도: O(1)
- pollLast(): Deque의 맨 뒤에 있는 요소를 제거하고 반환합니다. Deque가 비어 있는 경우 null을 반환합니다.
- 시간 복잡도: O(1)
- getFirst(): Deque의 맨 앞에 있는 요소를 반환합니다. Deque가 비어 있는 경우 NoSuchElementException이 발생합니다.
- 시간 복잡도: O(1)
- getLast(): Deque의 맨 뒤에 있는 요소를 반환합니다. Deque가 비어 있는 경우 NoSuchElementException이 발생합니다.
- 시간 복잡도: O(1)
- peekFirst(): Deque의 맨 앞에 있는 요소를 반환합니다. Deque가 비어 있는 경우 null을 반환합니다.
- 시간 복잡도: O(1)
- peekLast(): Deque의 맨 뒤에 있는 요소를 반환합니다. Deque가 비어 있는 경우 null을 반환합니다.
- 시간 복잡도: O(1)
- isEmpty(): Deque가 비어 있는지 확인합니다.
- 시간 복잡도: O(1)
- size(): Deque의 크기를 반환합니다.
- 시간 복잡도: O(1)
import java.util.Deque;
import java.util.ArrayDeque;
public class Main {
public static void main(String[] args) {
// Deque 생성 (ArrayDeque를 사용하여 구현)
Deque<Integer> deque = new ArrayDeque<>();
// 요소 추가 (addFirst / addLast) O(1)
deque.addFirst(10);
deque.addLast(20);
deque.addFirst(5);
deque.addLast(30);
// Deque의 모든 요소 출력 O(1)
System.out.println("Deque의 모든 요소:");
for (int element : deque) {
System.out.println(element);
}
// 요소 제거 (removeFirst / removeLast) O(1)
int removedFirst = deque.removeFirst();
int removedLast = deque.removeLast();
// Deque의 크기 확인 (size) O(1)
int size = deque.size();
// Deque의 모든 요소 출력
System.out.println("Deque의 모든 요소:");
while (!deque.isEmpty()) {
System.out.println(deque.removeFirst());
}
}
}BinarySearch
정렬된 배열에서 원하는 값을 찾는 알고리즘
O(log n)
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
// 이진 탐색을 위해 배열을 먼저 정렬해야 함
Arrays.sort(array);
int key = 13;
int index = Arrays.binarySearch(array, key);
if (index >= 0) {
System.out.println(key + "는 배열의 " + index + "번째 인덱스에 있습니다.");
} else {
System.out.println(key + "는 배열에 존재하지 않습니다.");
}
}
}