[Java] Java 코딩테스트 기본 메소드

 

파이썬에서 자바로 코테 응시 언어를 바꾸면서 가장 걱정됐던 부분이 메소드에 대한 부분이었다.

그래서 기본 메소드들을 정리하고 암기했다 ..!

그때 정리해둔 메소드들..

 

---

 

1. String

String str = "apple";

// 길이 반환
str.length();

// 빈 문자열 체크
str.isEmpty();

/* 문자 찾기 */
// 0 번째 인덱스 반환
str.charAt(0); // 'a' 반환

// "a"의 인덱스 반환
str.indexOf("a"); // 0 (인덱스) 반환

// "p"의 마지막 인덱스 반환
str.lastIndexOf("p"); // 2

/* 문자열 자르기 */
// 인덱스 1 이상 3 미만 자르기
str.substring(1, 3); // "pp"

// 인덱스 3부터 끝까지 반환
str.substring(3); // "le"

/* 문자 치환 */
// 모든 p를 e로 치환한 결과를 반환 (str은 바뀌지 않음)
str.replace('p', 'e'); // "aeele"

// 정규식에 맞게 문자 치환한 값을 반환 (str은 바뀌지 않음)
str.replaceAll(".", "/"); // "/////" : 정규식 "."는 모든 문자

// 첫번째 등장하는 "p"를 "e"로 치환한 값을 반환 (str은 바뀌지 않음)
str.replaceFirst("p", "e"); // "aeple"

/* 문자열 비교 */
// 문자열 동일 여부 판단
str.equals("apple");

str.compareTo("applp"); // 음수 (str과 같으면 0, str이 사전순 앞이면 음수, 뒤면 양수)

// 문자 포함 여부 판단
str.contains("app");

// 문자열 분리
str.split(" "); // 공백으로 문자열 str 구분하여 String[] 반환
str.split(""); // str를 한 문자 씩 분리하여 String[]

// 문자 앞뒤 공백 제거
str.trim(); // 문자열 사이의 공백은 제거 X

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

/* Casting */
// 문자 -> 숫자
Integer.parseInt("100"); // 100 

// 숫자 -> 문자
Integer.toString(100); // "100" *주의사항 : casting하려는 String 길이가 0이면 오류

// char -> String
String.valueOf(char);

// String -> char[]
str.toCharArray();

/* N진수 */
// 10진수 N을 K진수로
Integer.toString(N, K); // String K진수 반환
// K진수 N을 10진수로
Integer.parseInt(N, K); // int 반환

 

 

1-1. StringBuilder

• String은 문자를 추가/삭제할 수 없으므로 StringBuilder를 이용

StringBuilder sb = new StringBuilder();

// 문자열 추가
sb.append("apple"); // "apple"

// 특정 인덱스에 문자 삽입
sb.insert(2, "oo"); // "apoople"

// 인덱스 0 이상 2 미만 문자열 삭제
sb.delete(0, 2); // "oople"

**// 인덱스 2의 문자 삭제
sb.deleteCharAt(2); // "oole"**

**// 인덱스 1의 문자를 p로 변경
sb.setCharAt(1, 'p'); // "ople"**

**// 문자열 길이를 2로 줄이기
sb.setLength(2); // "el"**

**// 문자열 길이 4로 늘리기
sb.setLength(4); // "el  "**

// 문자열 뒤집기
sb.reverse(); // "elpo"

// StringBuilder to String
sb.toString();

 

 

2. Queue

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

// 1 추가
queue.offer(1);

// 요소 제거 및 반환
queue.poll();

// 큐 비우기
queue.clear();

// 큐 최상단 요소 확인
queue.peek();

 

 

3. Stack

 

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

// 1 추가
stack.push(1);

// 요소 꺼내기
stack.pop();

// 스택 비우기
stack.clear();

// 스택 크기 반환
stack.size();

// 스택 비었는지 확인
stack.empty();

// 1이 존재하는지 확인
stack.contains(1);

// 스택 최상단 요소 확인
stack.peek();

 

 

4. ArrayList

List<String> list = new ArrayList<>();
List<String> list2 = new ArrayList<>();

// "one" 삽입
list.add("one");

// 0번 인덱스에 "zero" 삽입
list.add(0, "zero"); // "zero", "one"

// list 뒤에 list2를 병합
list.addAll(list2);

// 0번 인덱스의 값 반환
list.get(0);

// "zero"가 등장하는 첫번째 인덱스 반환
list.indexOf("zero"); // 0

// "zero"의 마지막 인덱스 반환
list.lastIndexOf("zero"); // 0

// 0번째 인덱스의 값 삭제
list.remove(0); // "one"

// "one"이 등장하는 첫 번째 값 삭제
list.remove("one");

// 리스트 차집합 : list - list2
list.removeAll(list2);

// list와 list2의 리스트 교집합
list.retainAll(list2);

// 리스트 비우기
list.clear();

// 리스트 비어있는지 체크
list.isEmpty();

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

// 리스트에 "one"이 포함되는지 확인
list.contains("one");

// list에 list2의 모든 요소가 전부 포함되는지 확인
list.containsAll(list2);

// 람다식으로 list에서 짝수인 요소 제거
list.removeIf(x -> x%2 == 0);

// list 정렬 (오름차순)
Collections.sort(list);

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

/* 배열 <-> 리스트 */
// temp라는 배열을 list라는 ArrayList로
List<String> list = new ArrayList<>(Arrays.asList(temp));

// list를 문자열 배열로 반환
String[] temp = list.toArray(new String[list.size()]);

 

 

4-1. Collections 관련 메소드

int[] temp = {1, 2, 3, 10, 20};
List<Integer> list = new ArrayList<>(Arrays.asList(temp));

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

/* 정렬 */
// list를 오름차순 정렬
Collections.sort(list);
// list를 내림차순 정렬
Collections.sort(list, Collections.reverseOrder());
// 요소의 길이 순 정렬
Collections.sort(list, (o1, o2) -> o1.length() - o2.length());

// list 뒤집기
Collections.reverse(list);

// list에 3 등장 횟수 반환
Collections.frequency(list, 3);

// list에서 이진탐색으로 10의 인덱스 찾기
Collections.sort(list); // 정렬 후 이진탐색 해야 함
Collections.binarySearch(list, 10);

 

 

 

5. PriorityQueue

// 작은 수에 가중치 (오름차순)
PriorityQueue<Integer> pq = new PriorityQueue<>();

// 큰 수에 가중치 (내림차순)
PriorityQueue<Integer> pq2 = new PriorityQueue<>(Collections.reverseOrder());

// 가중치 대상 사용자 정의
PriorityQueue<Node> q3 = new PriorityQueue<Node>((o1, o2) -> Integer.compare(o1.cost, o2.cost));

// offer

// poll

// remove

// peek : 첫번째 값

// clear

 

 

6. HashMap

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

// key = 1, value = "딸기"를 hashMap에 추가
hashMap.put(1, "딸기"); // null 반환
hashMap.put(1, "사과"); // 1의 value가 "사과"로 바뀜, "딸기" 반환
// key에 mapping된 이전 value를 반환

// key가 1인 요소 삭제
hashMap.remove(1); // key가 있으면 value를, 없으면 null 반환

// 전체 비우기
hashMap.clear();

// key가 1인 요소 있는지 확인
hashMap.containsKey(1);

// "사과"가 value인 요소 있는지 확인
hashMap.containsValue("사과");

// key에 1 있으면 value 반환, 없으면 바나나 반환
hashMap.getOrDefault(1, "바나나");

// map 순회
// key만 순회
hashMap.keySet();

// key, value 모두 순회
hashMap.entrySet(); // Entry<Key 자료형, Value 자료형> 으로 순회

 

💡 HashMap, LinkedHashMap, TreeMap

• HashMap : value 중복 허용 O, 순서 X
• LinkedHashMap : value 중복 허용 O, key 순서 O (삽입 순)
• TreeMap : key 순서가 오름차순(알파벳순) 정렬

 

 

7. Set

Set<Integer> hashSet = new HashSet<>();
Set<Integer> hashSet2 = new HashSet<>();

// 1을 추가
hashSet.add(1); // 1이 없으면 true, 있으면 false

// 1 삭제
hashSet.remove(1); // 삭제하면 true, 없으면 false

// 차집합 : hashSet - hashSet2
hashSet.removeAll(hashSet2);

// 교집합
hashSet.retainAll(hashSet2);

// 합집합
hashSet.addAll(hashSet2);

// hashSet 비우기
hashSet.clear();

// hashSet 크기 확인
hashSet.size();

// 1이 포함되는지 확인
hashSet.contains(1);

 

💡 HashSet, LinkedHashSet, TreeSet

• HashSet : 중복 허용 X, 순서 X
• LinkedHashSet : 중복 허용 X, 순서 O (삽입 순)
• TreeSet : 중복 허용 X, 정렬 O, 이진탐색트리 형태로 데이터 저장

 

 

8. Array

// 2차원 배열에서 첫번째 숫자 기준 오름차순 정렬
Arrays.sort(arr, (o1, o2) -> {
    return o1[0]-o2[0]; // 첫번째 숫자 기준 오름차순
});
Arrays.sort(arr, (o1, o2) -> o1[0] - o2[0]);

// arr이라는 Array를 Integer.MAX_VALUE로 채우기
Arrays.fill(arr, Integer.MAX_VALUE);

// arr의 인덱스 start 이상 end 미만만 정렬
Arrays.sort(arr, start, end);