[Java] 자바 코테의 기술

입출력 팁

import java.io.*;

public class FastIOExample {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));

        // 문자열로 읽고 출력하기
        String inputLine = reader.readLine();
        writer.write("입력 받은 문자열: " + inputLine);

        // 숫자로 읽고 출력하기
        int num = Integer.parseInt(reader.readLine());
        writer.write("입력 받은 숫자: " + num);

        // 버퍼 비우기
        writer.flush();

        // 리소스 닫기
        reader.close();
        writer.close();
    }
}

형변환

(자료형)x # 원하는 자료형으로 변환

 

 

수학

1e9 = 10^9

2e9 =  2 * 1e9 (INT_MAX에 거의 근접한 값이다)

1e9 + 7 # 보통 온라인 저지 사이트나 알고리즘 대회에서 값이 너무 커질 때, 오버플로우를 막기 위해서 1e9 + 7로 나누라고 한다.

쓰이는 이유:

 1. int 안에 들어오는 큰소수 : 소수여서 모듈러 연산의 값의 중복이 잘 없어 정확한 문제풀이가 가능하다.

 2. 쉬운 표기 : 간편한 표기의 큰 소수여서 기억하기 쉽다.

 3. 모듈러 곱셈 역원 : 페르마 소정리로 역원을 불러오기 좋은 수이다.

 

import java.lang.math

Math.PI # 원주율

 

Math.pow(a, b) # a의 b제곱

 

Math.sqrt(x) # x의 제곱근

 

Math.ceil(x) # 올림

 

Math.floor(x) # 내림

 

Math.round(x) # 소수 첫째 자리 반올림

 

Math.abs(x) # 절댓값

 

Math.random(x) # 0에서 1 랜덤

 

Math.min(a, b) # 더 작은값 반환

 

Math.max(a, b) # 더 큰값 반환

 

Math.random() # 0에서 1까지의 값 반환

 

스택, 큐, 덱 자료구조

import java.util.Stack;

Stack<T> stack = new Stack<>();

 

stack.push(item); // 요소를 스택에 추가.

 

stack.pop(); // 스택의 맨 위(가장 최근) 요소를 제거하고 반환.

 

stack.peek(); // 스택의 맨 위(가장 최근) 요소를 반환하지만 제거하지 않음.

 

stack.isEmpty(); // 스택이 비어있는지 여부를 확인.

 

stack.size(); // 스택에 있는 요소의 개수를 반환.

 

import java.util.Queue;

Queue<T> queue = new LinkedList<>();

 

queue.add(e); // 요소를 큐에 추가.

 

queue.offer(e); // 요소를 큐에 추가.

 

queue.remove(); // 큐의 맨 앞 요소를 제거하고 반환.

 

queue.poll(); // 큐의 맨 앞 요소를 제거하고 반환.

 

queue.peek(); // 큐의 맨 앞 요소를 반환하지만 제거하지 않음.

 

queue.isEmpty(); // 큐가 비어있는지 여부를 확인.

 

queue.size(); // 큐에 있는 요소의 개수를 반환.

 

import java.util.Deque;
import java.util.LinkedList;

Deque<E> deque = new LinkedList<>();

deque.addFirst(e); // 덱의 맨 앞에 요소를 추가.

 

deque.addLast(e); // 덱의 맨 뒤에 요소를 추가.

 

deque.offerFirst(e); // 덱의 맨 앞에 요소를 추가.

 

deque.offerLast(e); // 덱의 맨 뒤에 요소를 추가.

 

deque.removeFirst(); // 덱의 맨 앞 요소를 제거하고 반환.

 

deque.removeLast(); // 덱의 맨 뒤 요소를 제거하고 반환.

 

deque.pollFirst(); // 덱의 맨 앞 요소를 제거하고 반환.

 

deque.pollLast(); // 덱의 맨 뒤 요소를 제거하고 반환.

 

deque.getFirst(); // 덱의 맨 앞 요소를 반환하지만 제거하지 않음.

 

deque.getLast(); // 덱의 맨 뒤 요소를 반환하지만 제거하지 않음.

 

deque.peekFirst(); // 덱의 맨 앞 요소를 반환하지만 제거하지 않음.

 

deque.peekLast(); // 덱의 맨 뒤 요소를 반환하지만 제거하지 않음.

 

deque.isEmpty(); // 덱이 비어있는지 여부를 확인.

 

deque.size(); // 덱에 있는 요소의 개수를 반환.

 

배열

int[] arr = new int[size]; // 크기가 size인 정수 배열을 생성.
int element = arr[index]; // index 위치에 있는 요소에 접근.
arr[index] = newValue; // index 위치에 있는 요소의 값을 변경.
int length = arr.length; // 배열의 길이(요소의 개수)를 반환.

import java.util.Arrays;
int[] slicedArray = Arrays.copyOfRange(arr, startIndex, endIndex); // arr 배열의 startIndex부터 endIndex-1까지의 부분 배열을 생성.

 

//배열 앞에 값 추가

int[] newArray = new int[arr.length + 1];
newArray[0] = newValue;
System.arraycopy(arr, 0, newArray, 1, arr.length);

// 배열 맨 뒤에 값 추가
int[] newArray = Arrays.copyOf(arr, arr.length + 1);
newArray[newArray.length - 1] = newValue;

// 특정 위치에 값 추가
int[] newArray = new int[arr.length + 1];
System.arraycopy(arr, 0, newArray, 0, index);
newArray[index] = newValue;
System.arraycopy(arr, index, newArray, index + 1, arr.length - index);

// 특정 값 제거
int[] newArray = new int[arr.length - 1];
System.arraycopy(arr, 0, newArray, 0, index);
System.arraycopy(arr, index + 1, newArray, index, arr.length - index - 1);

// 특정 값 위치 찾기
int index = -1;
for (int i = 0; i < arr.length; i++) {
    if (arr[i] == targetValue) {
        index = i;
        break;
    }
}

// 요소 개수 세기
int count = 0;
for (int element : arr) {
    if (element == targetValue) {
        count++;
    }
}

import java.util.ArrayList;

ArrayList<E> arrList = new ArrayList<>();

arrList.add(element); // 요소를 ArrayList의 끝에 추가.

 

arrList.add(index, element); // 지정한 인덱스에 요소를 추가.

 

arrList.get(index); // 지정한 인덱스에 있는 요소를 반환.

 

arrList.set(index, newValue); // 지정한 인덱스에 있는 요소의 값을 변경.

 

arrList.remove(index); // 지정한 인덱스에 있는 요소를 제거.

 

arrList.remove(element); // 지정한 요소를 제거.

 

arrList.size(); // ArrayList에 있는 요소의 개수를 반환.

 

arrList.isEmpty(); // ArrayList가 비어있는지 여부를 확인.

 

arrList.contains(element); // 지정한 요소가 ArrayList에 포함되어 있는지 여부를 확인.

 

arrList.indexOf(element); // 지정한 요소의 첫 번째 인덱스를 반환합니다. 없으면 -1을 반환.

 

arrList.lastIndexOf(element); // 지정한 요소의 마지막 인덱스를 반환합니다. 없으면 -1을 반환.

 

arrList.clear(); // ArrayList의 모든 요소를 제거.

 

arrList.toArray(); // ArrayList의 요소들을 배열로 변환.

 

 

Collections 라이브러리

import java.util.Collections;

Collections.reverse(list); // 주어진 리스트의 순서를 뒤집기.

Collections.frequency(list, element); // 주어진 요소가 리스트에 몇 번 등장하는지 카운트합.

Collections.copy(destList, srcList); // 소스 리스트의 요소들을 대상 리스트로 복사.

Collections.fill(list, value); // 리스트의 모든 요소를 지정한 값으로 채우기.

Collections.max(list); // 리스트에서 최댓값을 반환.

Collections.min(list); // 리스트에서 최솟값을 반환.

Collections.addAll(list, elements); // 배열이나 요소들을 리스트에 추가.

 

Collections.binarySearch(list, key); // 이진 검색을 사용하여 리스트에서 특정 요소의 인덱스를 찾기.

 

Collections.sort(list); // 리스트의 요소들을 오름차순으로 정렬합니다.

 

Collections.sort(list, comparator); // 지정한 비교자를 사용하여 리스트의 요소들을 정렬.

 

Collections.swap(list, index1, index2); // 주어진 인덱스의 두 요소를 서로 바꾸기.

 

Collections.nCopies(n, element); // 지정한 개수와 요소로 이루어진 리스트를 반환.

 

Collections.disjoint(list1, list2); // 두 리스트가 공통된 요소를 가지고 있는지 확인.

문자열 처리

// 문자열 생성 및 초기화
String str1 = "안녕하세요";
String str2 = new String("자바");

// 문자열 연결

String s1 = "Hello";

String s2 = "World";

String concatenated = s1 + " " + s2;

// 문자열 길이

String str = "Java Programming";

int length = str.length();

// 문자열 비교

boolean isEqual = str1.equals(str2);

boolean isIgnoreCaseEqual = str1.equalsIgnoreCase("APPLE");

 

// 문자 추출

char firstChar = str.charAt(0);

char lastChar = str.charAt(str.length() - 1);

 

// 부분 문자열 추출

String sub1 = str.substring(5);

String sub2 = str.substring(5, 12);

 

// 문자열 검색
int indexOfComma = str.indexOf(",");

int lastIndexOfl = str.lastIndexOf("l");

 

// 문자열 대체
String replaced = str.replace("cats", "dogs");

 

// 문자열 분리

String fruitsString = "apple,banana,grape";

String[] fruits = fruitsString.split(",");

 

// 공백 제거

String trimmed = str.trim();

 

// 대소문자 변환

String upper = str.toUpperCase();

String lower = str.toLowerCase();

 

 

집합과 해시 테이블

import java.util.HashSet;
HashSet<T> set = new HashSet<>();

Collections.reverse(set); // 주어진 집합의 순서를 역순으로 바꿈.

Collections.shuffle(set); // 주어진 집합의 요소들을 무작위로 섞기.

Collections.frequency(set, element); // 주어진 요소가 집합 내에서 몇 번 등장하는지 카운트.

Collections.copy(destSet, srcSet); // 소스 집합의 요소들을 대상 집합으로 복사.

Collections.fill(set, value); // 집합의 모든 요소를 지정한 값으로 채움.

T maxElement = Collections.max(set); // 집합에서 최댓값을 반환.

T minElement = Collections.min(set); // 집합에서 최솟값을 반환.

Collections.addAll(set, elements); // 배열이나 요소들을 집합에 추가.

int index = Collections.binarySearch(list, key); // 이진 검색을 사용하여 집합에서 특정 요소의 인덱스를 찾음.

Collections.sort(set); // 집합의 요소들을 오름차순으로 정렬.

Collections.sort(set, comparator); // 지정한 비교자를 사용하여 집합의 요소들을 정렬.

Collections.swap(set, index1, index2); // 주어진 인덱스의 두 요소를 서로 바꿈.

List<E> nCopiesList = Collections.nCopies(n, element); // 지정한 개수와 요소로 이루어진 집합을 반환.

boolean haveCommonElements = Collections.disjoint(set1, set2); // 두 집합이 공통된 요소를 가지고 있는지 확인.

 

import java.util.Hashtable;
Hashtable<K, V> hashTable = new Hashtable<>();

hashTable.put(key, value); // 키와 값을 해시 테이블에 추가.

hashTable.get(key); // 지정한 키에 해당하는 값을 반환.

hashTable.remove(key); // 지정한 키와 해당하는 값을 해시 테이블에서 제거.

boolean containsKey = hashTable.containsKey(key); // 지정한 키가 해시 테이블에 있는지 확인.

boolean containsValue = hashTable.containsValue(value); // 지정한 값이 해시 테이블에 있는지 확인.

int size = hashTable.size(); // 해시 테이블의 요소 개수를 반환.

boolean isEmpty = hashTable.isEmpty(); // 해시 테이블이 비어있는지 확인.

hashTable.clear(); // 해시 테이블의 모든 요소를 제거하여 비움.

Enumeration<K> keysEnumeration = hashTable.keys(); // 모든 키의 열거형을 반환.

Enumeration<V> valuesEnumeration = hashTable.elements(); // 모든 값의 열거형을 반환.