기본으로 import는 다음 두 개를 넣어놓고 시작하자.

import java.util.*;
import java.io.*;

IOException을 붙여주지않으면, BufferedReader를 사용할 때 readLine()에서 에러가 난다. throws IOException도 붙여주자 😙

public static void main(String[] args) throws IOException

입력 받기

소프티어에서는 입력받는 것까지 나오므로 준비하는 것을 추천한다.

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());

// 4 5 7 같이 입력받아야할 때
StringTokenizer st = new StringTokenizer(br.readLine());
int x = Integer.parseInt(st.nextToken());
int y = Integer.parseInt(st.nextToken());

배열

1차원 배열 정의

기본적인 1차열 배열의 정의이다. 길이가 고정이라는 점이 중요하다!

int[] arr = {5, 0, 2, 3, 4, 1};

아래와 같이 전역 변수로 선언 후, 함수 안에서 초기화하는 경우도 많다.

public class Main {
    static boolean[] visited;
    
    public static void main(String[] args) throws IOException {
        visited = new boolean[n+1];
...

2차원 배열 정의

다음 기본적인 2차원 배열의 정의이다. 역시 길이가 고정이다!

int[][] arr = new int[][]{{5, 40}, {3, 50}, {1, 30}};

위와 마찬가지로, 전역 변수로 선언 후, 함수 안에서 초기화하는 경우이다.

public class Main {
    static int[][] problems;
    
    public static void main(String[] args) throws IOException {
        int n = Integer.parseInt(br.readLine());
        problems = new int[n][2];
...

리스트

그럼, 배열의 크기를 모를 때는 어떻게 할까? 길이가 가변인 리스트를 사용한다. 보통 그래프 문제에서 많이 쓰인다는 걸 알아두자.

아래 경우는 행의 수는 고정이고, 열의 수는 가변인 2차원 배열이다.

public class Main {
    static List<Integer>[] graph;
    
    public static void main(String[] args) throws IOException {
        int n = Integer.parseInt(br.readLine());
        graph = new ArrayList[n+1];
        for(int i = 0; i < n+1; i++) {
	    relation[i] = new ArrayList<>();
        }

...

그렇다면, 행의 수는 가변이고, 열의 수는 고정인 경우는 어떨까?

public class Main {
    static List<int[]> graph;
    
    public static void main(String[] args) throws IOException {
        int n = Integer.parseInt(br.readLine()); 
        graph = new ArrayList<>(); // 가변 리스트 초기화

        for (int i = 0; i < n; i++) {
            st = new StringTokenizer(br.readLine());
            int node1 = Integer.parseInt(st.nextToken());
            int node2 = Integer.parseInt(st.nextToken());
            graph.add(new int[]{node1, node2}); // 고정된 배열 
        }

...

그럼 행과 열 둘다 가변일 경우는? 명확하게 ArrayList를 사용할 것이라면, ArrayList로 선언해도 좋다.

public class Main {
    static List<List<Integer>> graph;
 // static ArrayList<ArrayList<Integer>> graph;
    
    public static void main(String[] args) throws IOException {
        graph = new ArrayList<>(); 

        for (int i = 0; i < n; i++) {
            graph.add(new ArrayList<>()); // 각 행도 ArrayList로 초기화
        }

...

배열 슬라이싱

public static void main(String[] args) {
    int[] arr = {0, 1, 2, 3, 4, 5};
    arr = Arrays.copyOfRange(arr, 2, 4); // 인덱스 2~3까지 슬라이싱
    System.out.println(Arrays.toString(arr));

    // result : [2, 3]
}

배열 중복된 값 제거

public static void main(String[] args) {
    int[] arr = {0, 1, 2, 3, 4, 5, 5, 1, 2, 3};
    // 중복 제거 후 다시 배열에 넣어줘야함
    arr = Arrays.stream(arr).distinct().toArray(); 
    System.out.println(Arrays.toString(arr));

    // result : [0, 1, 2, 3, 4, 5]
}

배열 정렬

오름차순 정렬

public static void main(String[] args) {
    int[] arr = {5, 3, 2, 1, 4, 9, 4, 6};
    Arrays.sort(arr); // 오름차순 정렬 
    System.out.println(Arrays.toString(arr));

    // result : [1, 2, 3, 4, 4, 5, 6, 9]

    int[] arr = {5, 3, 2, 1, 4, 9, 4, 6};
    Arrays.sort(arr, 1, 4); // 인덱스 1~3까지 오름차순 정렬
    System.out.println(Arrays.toString(arr));
 
    // reulst : [5, 1, 2, 3, 4, 9, 4, 6]


}

내림차순 정렬

Collections.reverseOrder()는 Comparable을 구현한 객체만 정렬할 수 있기 때문에 int형에서 Integer로 변환하여 사용해야한다. 배열에 -1을 곱한 뒤, 오름차순 정렬하는 방법도 있다.

public static void main(String[] args) {
    int[] arr = {5, 3, 2, 1, 4, 9, 4, 6};
    Integer[] arr2 = Arrays.stream(arr).boxed().toArray(Integer[]::new);
    Arrays.sort(arr2, Collections.reverseOrder()); // 내림차순 정렬
    System.out.println(Arrays.toString(arr2));

    // result : [9, 6, 5, 4, 4, 3, 2, 1]

2차원 배열 특정 조건 기준으로 정렬

public static void main(String[] args) {
    int[][] arr = new int[][]{{5,40}, {3, 50}, {1,30}, {2, 20}, {2, 10}};
    
    // 첫번째 숫자 기준 오름차순
    Arrays.sort(arr, Comparator.comparingInt((int[] o) -> o[0])); 
    
    // 첫번째 숫자 기준 내림차순
    Arrays.sort(arr, Comparator.comparingInt((int[] o) -> o[0]).reversed()); 

    // 첫 번째 숫자를 기준으로 오름차순 정렬, 첫 번째 숫자가 같을 경우 두 번째 숫자를 기준으로 내림차순 정렬
    Arrays.sort(arr, Comparator.comparingInt((int[] o) -> o[0]).thenComparingInt((o -> -o[1])));

}

리스트 정렬

public static void main(String[] args) {
    // 초기 요소를 가진 ArrayList 생성
    List<Integer> arr = new ArrayList<>(Arrays.asList(5, 0, 2, 3, 4, 9, 1));
    
    // 오름차순    
    Collections.sort(arr); // result : [0, 1, 2, 3, 4, 5, 9]
    // 내림차순
    Collections.sort(arr, Comparator.reverseOrder()); // result : [9, 5, 4, 3, 2, 1, 0]

}

숫자와 문자열 변환

Integer.toString(n); // 숫자 -> 문자열
Integer.parseInt(s): // 문자열 -> 숫자

리스트 관련 함수

List<String> arr = new ArrayList<>();
List<String> arr2 = new ArrayList<>(Arrays.asList("부산", "대구"));
arr.add("서울"); // 리스트 가장 뒤에 서울 삽입
arr.add("제주");
arr.add(0, "대전"); // 리스트 0위치에 대전 삽입
arr.addAll(arr2); // arr2 리스트에 있는 모든 요소 arr1에 추가
arr.get(0); // 0위치의 값 반환
arr.set(1, "제주"); // 1 위치의 값을 제주로 변경
arr.indexOf("제주"); // 제주의 첫 번째 인덱스 반환
arr.lastIndexOf("제주"); // 제주의 마지막 인덱스 반환
arr.isEmpty();
arr.size(); // 길이
arr.contains("서울"); // 서울이 포함되어있으면 true
arr.containsAll(arr2); // arr에 arr2의 모든 값이 포함되어있으면 true
arr.remove(0); // 0번째 인덱스 값 삭제
arr.remove("제주"); // 해당 값 삭제
arr.removeIf(k -> k.equals("부산")); // 람다식으로 arr안의 값이 부산이라는 값과 같으면 삭제
// 응용 -> k % 2 ! = 0 : 홀수를 리스트에서 모두 제거 가능
arr.removeAll(arr2); // arr에서 arr2에 들어있는 모든 값 삭제
arr.retainAll(arr2); // arr에서 arr2에 들어있는 값들을 제외한 모든 값 삭제
arr.clear();

문자열 관련 함수

String str = "abcdec";
str.length(); // 길이
str.isEmpty();
str.charAt(2); // 인덱스롤 문자 찾기 : c
str.indexOf("c"); // 문자로 첫 번째 인덱스 찾기 : 2
str.lastIndexOf("c"); // 문자로 마지막 인덱스 찾기
str.substring(2,4); // 2-3위치의 문자열 반환 : cd
str.substring(3); // 3부터 끝까지의 문자열 반환 : dec
str = str.replace('b', 'k'); // 문자 변경 : b -> k
str.equals("akcdec"); // 문자열 동일하면 true : true
str.contains("de"); // 문자열 포함되어있으면 true : true
str.trim(); // 문자열 앞 뒤 공백 제거
str = str.toLowerCase(); // 소문자로
str = str.toUpperCase(); // 대문자로
str.compareTo("AKCDED"); // 사전 순 비교 : -1
String[] s = str.split(""); // 띄어쓰기 없는 문자열 한 문자씩 분리해서 String 배열로 반환
System.out.println(Arrays.toString(s)); // [A, K, C, D, E, C] 
str = String.join("", s); // String 배열을 ""안의 문자로 연결해서 다시 문자열로 반환
char[] charArr = str.toCharArray(); // 문자열 한 문자씩 분리해서 char 배열로 빈환
System.out.println(Arrays.toString(charArr)); // [A, K, C, D, E, C]
str = str.replaceAll("[^0-9]", " "); // 0-9가 아닌 아닌 것들을 공백으로 치환

StringBuilder 관련 함수

String은 한번 만들어지면, 문자를 추가하거나 삭제가 불가능하다! 문자열을 추가해야한다면, StringBuilder를 이용해야한다.

String str = "Hello Java!";
StringBuilder sb = new StringBuilder();

for (int i=0; i<str.length(); i++) {
    // String 문자열을 Stringbuilder로 변환
    sb.append(str.charAt(i)); // append : 문자열 추가

}
		
sb.insert(1, "eee"); // 0 위치에 삽입 : Heeeello Java!
sb.delete(1, 3); // 1-2 위치의 문자열 삭제 : Heello Java!
sb.deleteCharAt(1); // 1 위치의 문자열 삭제 : Hello Java!
int index = sb.indexOf("!"); // 해당 문자 첫 번째 인덱스 찾기
sb.setCharAt(index, '~'); // !위치의 문자를 ~로 변경 : Hello Java~
sb.reverse(); // 문자열 거꾸로 뒤집기 : ~avaJ olleH
sb.setLength(2); // 문자열 길이를 2로 줄임 : ~a

배열, 문자열, 리스트의 길이

• 배열 : arr.length

• 리스트 : arr.size()

• 문자열 : str.length()

👀 혹시 틀린 부분이나 성능상 더 좋은 점이 있다면, 댓글에 적어주시면 감사합니다 !