[Java] 코테용 함수 정리

배열

• 고정 길이

int[] arr = new int[len];  // 1차원
int[][] arr = new int[N][M];  // 2차원

// 배열 길이
int len = arr.length;

// 전체 복사
int[] copy = Arrays.copyOf(arr, arr.length);
// 부분 복사
int[] part = Arrays.copyOfRange(arr, 1, 4);  // [1, 4) 구간 복사

// 오름차순 정렬
Arrays.sort(arr);
// 내림차순 정렬
Arrays.sort(arr, Collections.reverseOrder());

// 2차원 배열 정렬
Arrays.sort(schedule, (x, y) -> Integer.compare(x[0], y[0])); // 각 원소의 첫번째 값 기준 오름차순 정렬
Arrays.sort(schedule, (x, y) -> Integer.compare(y[0], x[0])); // 각 원소의 첫번째 값 기준 내름차순 정렬

// 비교
Arrays.equals(arr1, arr2);

// 값 채우기
Arrays.fill(arr, 5);  // 모든 요소를 5로 채우기

// 이진 탐색
Arrays.binarySearch(arr, key);  // 정렬된 배열에서 key의 인덱스 찾기

// int[] -> List<Integer>
List<Integer> list = Arrays.stream(arr).boxed().collect(Collectors.toList());

// List<Integer> -> int[]
int[] arr = list.stream().mapToInt(Integer::intValue).toArray();

ArrayList

• cpp vector

List<T> list = new ArrayList<>();

// 추가
list.add(value);  // 맨 뒤에 추가
list.add(index, value);  //인덱스에 값 추가

// 삭제
list.remove(index);  // 인덱스에 있는 값 삭제
list.remove(Integer.valueOf(x));  // 값 삭제

// 조회
list.get(index);

// 수정
list.set(index, value);

// 리스트 길이
list.size();

// 오름차순 정렬
Collections.sort(list);
// 내림차순 정렬
Collections.sort(list, Collections.reverseOrder());

// 순서 반전
Collections.reverse(list);

// 최대값
Collections.max(list);
// 최소값
Collections.min(list);

// 포함 여부
list.contains(x);  // boolean 반환

stream

int[] arr = {7, 18, 99, 62, 3, 51};
List<Integer> list = Arrays.asList(7, 18, 99, 62, 3, 51);

// 합계
int sum = Arrays.stream(arr).sum();
int sum = list.stream().mapToInt(Integer::intValue).sum();

// 평균
double avg = Arrays.stream(arr).average().orElse(0);
double avg = list.stream().mapToInt(Integer::intValue).average().orElse(0);

// 최대값
Arrays.stream(arr).max().getAsInt();

// 최소값
list.stream().mapToInt(Integer::intValue).min().getAsInt();

// 필터
int[] filtered = Arrays.stream(arr).filter(x -> x > 10).toArray();
List<Integer> filtered = list.stream().filter(x -> x > 10).collect(Collectors.toList());

// 필터 + 합계
int sumEven = list.stream()
                  .filter(x -> x % 2 == 0)
                  .mapToInt(Integer::intValue)
                  .sum();

// 오름차순 정렬
List<Integer> sorted = list.stream()
                           .sorted()
                           .collect(Collectors.toList());
// 내림차순 정렬
List<Integer> desc = list.stream()
                         .sorted(Comparator.reverseOrder())
                         .collect(Collectors.toList());

// 중복 제거
List<Integer> unique = list.stream()
                           .distinct()
                           .collect(Collectors.toList());

// 조건 카운트
long count = list.stream()
                 .filter(x -> x > 50)
                 .count();

string

String str = "abc def ghi";

// 길이
str.length();

// 문자 접근
str.charAt(index);

// 부분 문자열
str.substring(2, 5);  // [2, 5) 구간 문자열

// 구분자 기준 분할
str.split(" ");  // 문자열 배열 반환

// 문자열 이어붙이기
str1 + str2;

// 대문자 변환
str.toUpperCase();
// 소문자 변환
str.toLowerCase();

// 부분 문자열 포함 여부
str.contains("ab");

// 접두 문자 확인
str.startsWith("a");
// 접미 문자 확인
str.endsWith("b");

// 문자열 교체
str.replace("ab", "xy");

// 문자열 뒤집기
String rstr = new StringBuilder(str).reverse().toString();

// 내용 비교
str.equals(s);

// String은 변경 불가 -> 문자 하나 바꾸려면 StringBuilder 필수
StringBuilder sb = new StringBuilder();
sb.append("abc");
sb.append(123);
sb.setCharAt(4, 'b'); 
String newname = sb.toString();

// 문자열 정렬
char[] ch = s.toCharArray(); 
Arrays.sort(ch);

수학

// 절대값
Math.abs(x);

// 최대값
Math.max(a, b);

// 최소값
Math.min(a, b);

// 제곱 a^b
Math.pow(a, b);

// 제곱근
Math.sqrt(x);

// 반올림
Math.round(3.6);

// 올림
Math.ceil(3.6);

// 내림
Math.floor(3.6);

// 정수 -> 2진 문자열
Integer.toBinaryString(13);

queue

Queue<Integer> q = new LinkedList<>();

// push
q.offer(x);

// pop
q.poll();

// front
q.peek();

// empty
q.isEmpty()

// size
q.size()

priority queue

// min heap
PriorityQueue<Integer> pq = new PriorityQueue<>();

// max heap
PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());

// 사용자 정의 비교 (절댓값 오름차순, 값 동일 시 실제 값 오름차순)
PriorityQueue<Integer> pqCustom = new PriorityQueue<>(
	(a, b) -> (Math.abs(a) == Math.abs(b) ? a - b : Math.abs(a) - Math.abs(b))
);

// empty
q.isEmpty()

// size
q.size()

// k번째 큰 수
int kthLargest(int[] nums, int k) {
	PriorityQueue<Integer> pq = new PriorityQueue<>();
    for(int x : nums) {
    	pq.offer(x);
        if(pq.size() > k) pq.poll();
    }
    return pq.peek();
}

stack

Stack<Integer> st = new Stack<>();

// push
st.push();

// pop
st.pop();

// top
st.peek();

// empty
q.isEmpty()

// size
q.size()

set

Set<Integer> set = new HashSet<>();

// 추가
set.add(3);

// 삭제
set.remove(3);

// 존재 여부
set.contains(3);

// 크기
set.size()

map

Map<String, Integer> map = new HashMap<>();

// 추가
map.put(“a”, 10);
// map[key]++;
map.put(key, map.getOrDefault(key, 0) + 1);

// 조회
map.get(“a”);
// 없으면 기본값 조회
map.getOrDefault(“a”, 0);

// 삭제
map.remove(“a”);

// 존재 여부
map.contains(key);

// 순회
for(String key : map.keySet())

형변환

// 문자 -> 정수
c - '0'

// 문자열 -> 정수
Integer.parseInt(s)
// 정수 -> 문자열
String.valueOf(x)