기본문법

수학 관련 함수

Math.pow(a, b); // a의 b제곱
Math.sqrt(a); // a의 제곱근
Arrays.stream(arr).sum(); // 배열 arr의 합
// 배열의 평균, average()가 리턴한 값이 없을 경우, null 대신 0 반환
double avg = Arrays.stream(arr).average().orElse(0);
Math.min(a,b); // a,b 중 작은 값 리턴
Math.max(a,b); // a,b 중 큰 값 리턴
Math.abs(a); // 절대값
Integer.compare(a,b); // 정렬 비교하는 숫자가 너무 클때

---

문자열(String)

• .length(): 문자열 길이 반환
• .substring(s,e): 문자열에서 해당 범위(s~e)에 있는 문자열 반환 (e는 범위에 포함 X)
• Integer.toString(): int → string 형변환
• Integer.valueOf(), Integer.parseInt(): string → int 형변환
• toCharArray(): 문자열을 문자 배열로 변환
• .split(""): 문자열을 ""를 기준으로 나누어서 배열로 변환
• .charAt(idx): 특정 인덱스(idx)에 해당하는 문자 리턴
• .equals(): 두 문자열이 같은지 비교
• Arrays.asList(str[]).indexOf("Kim") : str[] 배열에서 kim이 있는 index 찾기
• String.join("", str[]) : str[] 배열 String 문자열로 합치기
• (b+a).compareTo(a+b): 문자열 각 자릿수별로 아스키 코드값을 비교한 후 차이 반환
  • b+a의 아스키 코드가 a+b의 아스키 코드보다 크다면 양수, 작다면 음수, 같다면 0 반환
  • 이를 이용한 정렬 로직 작성 가능

  Arrays.sort(stringNums, (a,b)->(b+a).compareTo(a+b));

---

StringBuilder

StringBuilder는 변경 가능한 문자열을 만들어주어, String을 합치는 작업 시 효율을 증가시킬 수 있다.

StringBuilder sb = new StringBuilder();

• .append(): 문자열 추가
• .insert(offset, str): offset 위치에 문자열 추가
• .replace(s, e, val): 특정 인덱스에 위치한 문자열 대체
• .substring(s,e): s부터 e 인덱스 인덱싱
• .reverse(): 해당 문자 전체 뒤집기
• .toString(): String 타입으로 형변환
• temp.setLength(0); : 객체 초기화(재사용)

---

Character 관련 함수

char c = 'A';
char k = 'B';
Character.toString(c); // char형 변수 c를 String으로
Character.compare(c, k); // 비교 같으면 0출력, 다르면 c-k 반환 : -1
Character.isUpperCase(c); // c가 대문자면 true
Character.isLowerCase(k); // k가 소문자면 true
Character.isDigit(c); // c가 숫자면 true
Character.isAlphabetic(k); // k가 알파벳이면 true

---

배열

배열은 선언할 때 미리 배열의 타입과 공간의 개수(길이)를 지정해야 한다.

int[] score = new int[5]; // int 타입 값 5개 저장
String[] name = new String[3]; // String 타입 값 3개 저장

배열을 출력할 때에는 배열의 각 원소들을 순회하며 출력하거나, Arrays.toString() 메서드를 이용해 배열을 문자열 형식으로 만들어 출력한다.

for (int i=0; i<iArr.length; i++) {
	System.out.println(iArr[i]);
}
System.out.println(Arrays.toString(iArr));

• Arrays.fill(arr, -1): 배열을 -1로 초기화
• .length: 배열의 길이 반환
• Arrays.sort(arr): 배열을 오름차순으로 정렬
• Arrays.stream().max().getAsInt(): Stream API를 이용해 배열 스트림으로 만들어서 최댓값 구하기
• Arrays.copyOfRange(arr,s,e): 배열의 s~e-1 인덱스 영역 복사
• int[]→String[]로 변환
• String[] strNums = Arrays.stream(numbers) .mapToObj(String::valueOf) .toArray(String[]::new);
• String[]→StringBuilder로 변환
• StringBuilder sb = new StringBuilder(); Arrays.stream(strNums).forEach(sb::append);

---

동적 배열: ArrayList

길이가 고정되어 있지 않고, 값의 추가와 삭제가 자주 일어나는 경우 동적 리스트인 ArrayList를 사용하는 것이 더 효율적이다.

import java.util.ArrayList;
ArrayList<Integer> arrayList = new ArrayList<>();

• .add(val): 값 추가
• .set(idx, val): 특정 인덱스 값 수정
• .remove(idx): 배열에서 처음 만난 특정 값 삭제
• .removeI(조건): 동적 배열에서 조건을 만족하는 모든 요소 삭제
• .size(): 배열 크기 반환
• Collections.sort(): 오름차순으로 리스트 정렬
• .get(idx): 특정 인덱스 값 리턴
• .toArray(T[] a): 리스트를 배열(Array)로 변환
• arr.toArray(new Integer[0]);
• Integer[]→int[]
  • .stream(): 리스트 → 스트림
    • 람다를 활용해 배열과 컬렉션을 함수형으로 간단하게 처리할 수 있는 기술
    • 스트림은 원본 데이터 소스를 변경하지 않고 읽기만 하며, 일회용이다.
  • .mapToInt(i->i): 스트림을 정수형 스트림(IntStream)으로 변환해주는 메서드
• return answerList.stream().mapToInt(i->i).toArray();

---

2차원배열

(1) 배열 + 배열

행과 열의 길이를 둘다 확실히 알고 그 길이가 고정일때만 사용

int n = 5;
int[][] graph = new int[n + 1][n + 1];

(2) 배열 + ArrayList

행의 수는 고정인데 열의 수가 가변일 때 사용 가능

ArrayList<Integer>[] list = new ArrayList[n + 1];

for (int i = 0; i <= n; i++) {
	list[i] = new ArrayList<>();
}

for(int[] edge : edges) {
	list[edge[0]].add(edge[1]);
	list[edge[1]].add(edge[0]);
}

(3) ArrayList + ArrayList (⭐)

행과 열 모두 모를 때도 사용 가능

ArrayList<ArrayList<Integer>> graph = new ArrayList<>();
for (int i = 0; i <= n; i++) {
	graph.add(new ArrayList<>());
}
graph.get(n1).add(n2);

리스트와 배열 형변환

// String 배열 -> String 리스트
String[] arr = {"A", "B", "C"};
List<String> arrList = new ArrayList<>(Arrays.asList(arr));

// String 리스트 -> String 배열
String[] arr2 = arrList.stream().toArray(String[]::new);

// int 배열 -> int 리스트
int[] intArr = new int[]{1, 4, 3, 5, 2};
List<Integer> intList = Arrays.stream(intArr).boxed().collect(Collectors.toList());
Collections.reverse(intList); // 뒤집기

// int 리스트 -> int 배열
int[] intArr2 = intList.stream().mapToInt(i -> i).toArray();

Collections 관련 함수

int[] intArr = new int[]{1, 4, 3, 5, 2};
List<Integer> intList = Arrays.stream(intArr).boxed().collect(Collectors.toList());
// List<Integer> intList = Arrays.stream(intArr).boxed().sorted().collect(Collectors.toList());

Collections.sort(intList); // 오름차순
Collections.sort(intList, Collections.reverseOrder()); // 내림차순
Collections.reverse(intList); // 뒤집기
Collections.frequency(intList, 2);
// 이분탐색 : 해당 값이 있으면 해당 인덱스 반환, 없으면 해당 값보다 큰 첫번째 위치 반환 : -1 (값 1의 인덱스)
// reverse 했으므로 인덱스값이 마이너스가 붙어서 나옴
Collections.binarySearch(intList, -1);

---

정렬 (Sorting): 데이터를 순서대로 나열하기

Arrays.sort(), Collections.sort()

Comparator 정렬

• b - a: 내림차순 (큰 놈이 먼저!)
• a - b: 오름차순 (작은 놈이 먼저!)

리턴값 의미

음수	a가 앞에 와라
0	순서 유지
양수	b가 앞에 와라

---

문제:

문자열 배열이 주어질 때

등장 횟수 기준으로 내림차순 정렬된 리스트를 반환하라.

예:

["a","b","a","c","b","a"]
→ ["a","b","c"]

(동점이면 사전순 오름차순)

String str[] = {"a","b","a","c","b","a"};
Map<String, Integer> map = new HashMap<>();
for(String s : str)
{
map.put(s, map.getOrDefault(s,0)+1);
}

List<String> arr = new ArrayList<>(map.keySet());

Collections.sort(arr, (a, b) -> {
    if (map.get(b) != map.get(a)) {
        return map.get(b) - map.get(a); // 횟수 내림차순
    } else {
        return a.compareTo(b); // 사전순 오름차순
    }
});