원래 코테는 python으로 준비하다가 프론트엔드로 (거의) 진로를 정하게 되면서 javascript로 하려고 했는데..! 띠용 갑자기 내일 당장 자바로 코테를 치게 되었다.
이 포스팅이 나에게 또 이 글을 보는 사람들에게 도움이 되기를..

📌 0.

라이브러리

import java.util.*;		// collection, map, list, queue 등
import java.io.*;		//file, console, buffer 등

length / length() / size()

// 배열
int[] arr = new arr[3];
System.out.println(arr.length);		//3

// String
String str = "Java";
System.out.println(str.length());	//4

// Collections 객체들
ArrayList<String> list = new ArrayList<>();
System.out.println(list.size());

📌 String 관련 메서드

// 선언
String str = "apple";

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

// 빈 배열 체크
str.isEmpty();

// 문자 찾기
str.charAt(0);	// 'a'
str.indexOf("a");	//0
str.lastIndexOf("p");	//2
// 반복문을 사용해서 요소에 접근할 수 있다.
for(int i=0; i < str.length; i++) str.charAt(i);

// 문자 자르기
str.substring(1, 3);	//'pp'
str.substring(3);	//'app'

// 문자 치환
str.replace('p', 'b');	//'abble'
str.replaceAll('.', '*');	// '*****' //정규식에 맞게 문자 치환
str.replaceFirst('p', 'b');		//'abple'

// 문자열 동일 여부 판단
// String <변수명> = ""; 로 선언했을 때, 클래스로써 주소값이 부여된다. 그러므로 값이 같더라도 주소값이 다를 수 있기 때문에 값이 같은지 확인할 때는 .equals를 사용한다.
str.equals("apple");

// 문자 비교
// 문자와 비교 대상이 같으면 0
// 비교 대상이 문자에 포함되면 두 문자 길이 차이 반환
// 첫 인덱스부터 비교하되 다른 값을 만나면 아스키코드 값 차이 반환
// int형도 비교 가능
str.compareTo("applf");		//0
str.compareTo("ap");	// 3 

// 문자 포함 여부
str.contains("ap");

// 문자열 분리
str.spilt("");	// 구분자는 있을수도 없을수도 있음. 구분자가 없을시 한글자씩 분리하여 String[]로 반환

str.trim();		// 문자 앞뒤 공백 제거

Integer.parseInt("100");	//100
Integer.toString(100);		//'100'

// 대소문자 변경
str = str.toUpperCase();	//str: APPLE
str = str.toLowerCase();	// str: apple

// 한번 선언한 String 객체 값은 변경 불가, substring으로 변경할 수 있음
String newStr = str.substring(3) + "lication";		//application

참고
String.CompareTo 메서드

📌 List 관련 메서드

// 선언
List<string> list = new ArrayList<>();
List<string> list2 = new ArrayList<>();

list.add("one");	//list: "one"
list.add(0, "zero");	//list: "zero", "one"

// 추가되는 리스트가 뒤에 추가됨
list.addAll(list2);

list.indexOf("zero");	//0

// 특정 요소의 마지막 인덱스 반환
list.lastIndexOf("zero");

// 괄호 안에 인덱스가 들어가면 특정 인덱스의 값 삭제, 값이 들어가면 첫번째 값 삭제
list.remove(0);
list.remove("one");

// 리스트 초기화
list.clear();

// 리스트 비어있는지 확인
list.isEmpty();

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

// 리스트 특정 요소 포함 여부
list.contains("one");

// 다른 리스트의 요소 전부의 포함 여부
list.containsAll(list2);	// 모두 포함되어 있으면 true

// 람다식 사용하여 리스트에서 요소 제거
// 예시는 리스트에서 짝수인 수 모두 제거
list.removeIf(x -> x % 2 == 0);	

📌 Array 관련 메서드

// 선언
int arr = [0, 1, 2, 3, 4, 5];
String[] strArr = ["zero", "one", "two"];

// 오름차순 정렬
Arrays.sort(arr);
// 내림차순 정렬
Arrays.sort(arr, Collections.reverseOrder());
// 일부 구간 정렬
Arrays.sort(arr, 0, 4);		//0-3번째 인덱스 정렬

// 오름차순 정렬 후 값 찾기
Arrays.binarySearch(arr, 2);

// 배열 자르기
int temp[] = Arrays.copyOfRange(arr, 0, 3);

Array와 List는 다르다.

• Array, List 모두 선형 자료구조이고, 인덱스를 가지고 있어 값을 참조할 수 있다.
• 그러나 Array는 크기가 고정되어 있으며 메모리 상에 데이터가 연속적으로 존재한다. 검색에는 O(1)의 시간 복잡도를 갖기만 삽입 및 삭제에는 O(N)의 시간 복잡도를 가진다.
• List는 메모리를 유동적으로 할당한다. (메모리에 빈 공간을 허용하지 않는다.) 그러므로 검색, 삽입, 삭제 모두 O(N)의 시간 복잡도를 가진다. ➡️ add, remove 등 자체 메서드를 가지고 있다.
• 두 가지의 특징을 골고루 가지고 있는 ArrayList도 있다
  비슷한 선형 자료구조로 LinkedList도 있긴 함 => 큐에서 사용

// 문자열 array를 list로 변환
String[] temp = {"one", "two", "three"};
List<String> list = new ArrayList<>(Arrays.asList(temp));

// list를 문자열 array로 변환
List<String> list = new ArrayList<>();
String[] temp = list.toArray(new String[list.size()]);

// Integer 등 다른 타입도 그대로 사용 가능

// 하지만 이런 식으로 선언하면 변경할 수 없다.
List<String> list = Array.asList("a", "b", "c");

📌 ArrayList 관련 메서드

• import java.util.ArrayList
• 삽입, 삭제, 참조(순회)에 편리하다!

// 선언
ArrayList<String> list = new ArrayList<>();

// 삽입
list.add("b");		//{"b"}
list.add(0, "a");		//{"a", "b"}

// 수정
list.set(1, "c");		//{"a", "c"}

// 삭제
list.remove(1);		//{"a"}

list.contains("b");		//false
list.indexOf("a");		//0

// iterator 사용
Iterator it = list.iterator();

while(it.hasNext()) { ... }

while(it.hasPrevious()) { ... }

// 중복 없이 값 넣기
if(list.indexOf(value) < 0} {
	list.add(value)		//중복이 있을 경우 값을 넣지 않음
}

// 값 하나씩 가져오기
for(int i=0; i<list.size; i++) {
	list.get(i).intValue();
}

📌 HashMap 관련 메서드

// 선언
HashMap<String, Integer> hashMap = new HashMap<>();

// key-value 넣기
hashMap.put("zero", 0);

// 해당 키 값 삭제
hashMap.remove("zero");

// 초기화
hashMap.clear();

// key로 값 가져오기
hashMap.get(0);

// key값 존재 유무
if(!hashMap.containsKey("one")) hashMap.put("one", 1);

// value 존재 유무
hashMap.containsValue();

// 키가 없으면 값 세팅, 있으면 기존 값 가져오기
hashMap.put("two", hashMap.getOrDefault("two", 2));

// 순회
for(String key : hashMap.keySet()) {
	hashMap.get(key);
}

for(Entry<String, Integer> temp : hashMap.entrySet()) {
	System.out.println(temp.getKey() + " " + temp.getValue());
}

📌 Stack 관련 메서드

// 선언
Stack<Integer> stack = new Stack<>();

// 추가
stack.push(1);

// 요소 제거
stack.pop();

// 초기화
stack.clear();

// 크기
stack.size();

// 비어있는지 확인
stack.empty();

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

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

📌 Queue 관련 메서드

// 선언
Queue<Integer> q = new LinkedList<>();	//LinkedList 사용

// 삽입
q.add(1);		//문제시 예외 발생
q.offer(2);		//문제시 false

// 삭제
q.remove();		//문제시 예외 발생
q.pool();		//문제시 null 리턴

// 초기화 
q.clear();

q.element(); 	//문제시 예외 발생
q.peek();		//문제시 null 리턴

📌 Math 라이브러리

// 두 값을 비교
Math.max(10, 2);	//10
Math.min(10, 2);	//2

// 절대값
Math.abs();

// 올림 내림 반올림
Math.ceil(-2.1);	//-1
Math.floor(-4.8);	//-4
Math.round(-5.5);	// -4

double a = 1.23456;
String b = String.format("%.1f", a);	//1.23

Math.pow(2, 2);		//4
Math.sqrt(4);		//2

💡DFS, BFS

• 메서드는 아니지만 자주 나오는 알고리즘이므로 써 봄

1. DFS: 재귀 또는 스택으로 구현

보통 재귀하면 간단함

public static void dfs(int i) {
	visited[i] = true;
    System.out.println(i + " ");
    
    for (int j=1; j<n+1; j++) {
		if(map[i][j] == 1 && visited[j] == false) {
			dfs(j);
       	}
    }
}

2. BFS: 큐로 구현

public static void bfs(int i) {
	Queue<Integer> q = new LinkedList<>();
    q.offer(i);
    visited[i] = true;
    
    while(!q.isEmpty()) {
    	int temp = q.poll();
        System.out.println(temp + " ");
        for (int j=1; j<n+1; j++) {
        	if(map[temp][j] == 1 && visited[j] == false) {
            	q.offer(j);
                visited[j] = true;
            }
         }
     }
}

참고 링크
[JAVA] 코딩테스트용 주요 함수 모음
[Java] 자주 사용하는 코딩테스트 문법 정리
[Java] DFS, BFS 정리