코테를 위한 Java 문법 정리

지금까지는 C++이나 파이썬으로 코테 문제를 풀어왔는데, 백엔드 직무의 경우 Java로 응시 언어를 제한하는 경우도 있는 듯 해서 Java를 주 언어로 채택해서 코테를 준비하기로 결정했다. 그리고 자바로 코테를 보기 위해 필요한 문법, 유용한 풀이 케이스 등을 정리하고자 한다.

 

배열

자바에서 배열에 값 추가하는 법

import java.util.ArrayList;

public class App {
    public static void main(String[] args) {
        ArrayList<Integer> a = new ArrayList<>();
        a.add(1);
    }
}

정적배열 vs 동적배열

import java.util.ArrayList;

public class App {
    public static void main(String[] args) {
        int [] b = new int[5]; // 정적 배열
        ArrayList<Integer> c = new ArrayList<>(); // 동적 배열
    }
}

동적으로 값을 바꿔줘야 하는 경우가 아닌 경우 정적 배열을 쓰는 것이 성능이 더 좋다.

하지만 정적배열은 메서드가 없다. remove, add가 가능은 하지만 껄끄럽다.

동적배열은 add, remove, contains 등 편한 메서드가 제공된다. 

배열 생성 및 전체 출력

import java.util.ArrayList;

public class App {
    public static void main(String[] args) {
        int a[] = {1,2,3,4,5}; 
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]); // 1 2 3 4 5
        }
    }
}

import java.util.ArrayList;

public class App { // 같은 결과
    public static void main(String[] args) {
        int a[] = new int[5];

        for (int i = 0; i < a.length; i++) {
            a[i] = i + 1;
        }
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
}

배열 정렬

오름차순

import java.util.*; // << 중요

public class App {
    public static void main(String[] args) {
        int a[] = {1, 3, 2, 1, 5};

        Arrays.sort(a)

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

내림차순

import java.util.*;

public class App {
    public static void main(String[] args) {
        Integer a[] = {1, 3, 2, 1, 5};

        Arrays.sort(a, Collections.reverseOrder());

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

자료형 설명

• int : 기본 타입, null 값 불가
• Integer : int의 래퍼클래스, 참조타입, null값 가능,
  • toString 등의 메서드 지원

배열을 Integer 형으로 바꿔주고, Array.sort()의 두번째 인수로 Collections.reverseOrder() 메서드를 사용해주면 된다.

2차원 Pair 배열

2차원 배열을 받는 경우 Pair 클래스를 생성해서 사용하면 됨.

y는 오름차순, x는 내림차순으로 정렬한다고 하면 다음과 같다.

import java.util.*;

class Pair{
    int y;
    int x;
    public Pair(int y, int x) {
        this.y = y;
        this.x = x;
    }
}

public class App {
    public static void main(String[] args) {
        // 정적배열을 쓰는 경우
        Pair[] a = { 
            new Pair(1, 2),
            new Pair(3, 4),
            new Pair(2, 5),
            new Pair(10, 23),
            new Pair(10, 12)
        };
        // 동적배열을 써도됨 ArrayList<Pair>b = new ArrayList<>();
        Arrays.sort(a, (p1,p2)->(p1.y == p2.y) ? Integer.compare(p2.x, p1.x): Integer.compare(p1.y, p2.y));

        for(Pair pair: a) {
            System.out.println(pair.y + " , " + pair.x); // 1,2|2,5|3,4|10,23|10,12
        }
    }
}

• 람다식
  • 함수형 인터페이스를 기반으로 하는 문법으로. 메서드가 딱 하나 있는 인터페이스만 람다로 대체 가능
• Integer.compare()
• 삼항연산자

사용해서 정렬

배열에서 특정 값을 찾는 경우 - 스트림 활용

import java.util.*;

public class App {
    public static void main(String[] args) {
        int [] a = {1,2,3,4,5};
        int target = 3;
        boolean found = Arrays.stream(a).anyMatch(value -> value == target);
        System.out.println(found); // true
    }
}

• 스트림 : 데이터 컬렉션을 람다식으로 표현식과 함께 선언적으로 처리할 수 있는 도구
  • 배열, 맵 같은 특정 자료형을 처리하기 위한 메서드들을 가지고 있는 인터페이스로, 특정 자료형을 가리키는(참조하는) 객체를 인스턴스화 하여 해당 자료형에 원하는 연산을 하고 원하는 값을 가져올 수 있음
  • 반복문보다 훨씬 간결하고 가독성이 좋다. + 병렬 처리가 용이함
  • 생성 - 중간연산 - 종단연산 세 단계가 있음. 중간연산은 체이닝이 가능하며, 종단연산이 호출되어야 작업을 수행함
  • Arrays.stream() : 배열을 스트림으로 만드는 메서드(컬렉션에도 가능하다)
• stream.anyMatch(Predicate<T> predicate) : 스트림의 요소가 주어진 Predicate에 일치하는지 여부를 boolean 으로 반환한다. anyMatch는 하나라도 일치하면 true(allMatch, noneMatch 존재)

Reduce 활용 - 배열을 모두 합쳐라

import java.util.*;

public class App {
    public static void main(String[] args) {
        int [] array = {1,2,3,4,5};
        int ret = Arrays.stream(array).reduce(0, (a,b)->a+b);
        System.out.println(ret); //15
    }
}

• reduce: 스트림의 종단연산으로 스트림의 모든 요소를 하나의 결과로 집계 하는데에 사용된다.
  • 다양한 오버로드 형식이 있음
  • 첫번째 인자 : 초기값 → 연산의 누적합을 시작하는 지점 스트림에 요소가 없는 경우 최종 결과로 반환되는 값
  • 두번째 인자: accumlator (a,b)→a+b ⇒ 두 개의 같은 타입 인자를 받아 같은 타입 결과를 반환하는 함수형 인터페이스(람다표현식)
    • a는 현재까지 누적된 중간결과
    • b는 스트림에서 현재 처리중인 다음 요소.
    • a+b에서 a와 b를 더한 값을 반환하고 이 반환 값이 다음 a가 된다.

배열의 요소에 각각 n을 곱해서 새로운 배열을 만들어라

for문을 사용할 수도 있지만 스트림을 쓰면 좀 더 고급지게 가능

import java.util.*;

public class App {
    public static void main(String[] args) {
        int [] array = {1,2,3,4,5};
        int [] ret = Arrays.stream(array).map(e -> e*2).toArray();
        for (int i : ret) {
            System.out.println(i); // 2 4 6 8 10
        }
    }
}

짝수만 골라내서 2를 곱한다면

import java.util.*;

public class App {
    public static void main(String[] args) {
        int [] array = {1,2,3,4,5};
        int [] ret = Arrays.stream(array).filter(e -> e % 2 == 0).map(e -> e*2).toArray();
        for (int i : ret) {
            System.out.println(i); // 4 8
        }
    }
}

해쉬 테이블(HashMap)

스트림은 배열에 한정되지 않음(컬렉션에도 적용이 가능)

• HashMap은 java.util 패키지에 속하는 대표적인 컬렉션 클래스 중 하나(해시테이블기반)
  • 컴퓨팅에서 키를 값에 매핑할 수 있는 구조인, 연관 배열 추가에 사용되는 자료 구조
• Key와 Value의 쌍을 저장하는 Map인터페이스의 구현체이다.

HashMap 자료형의 mp에 대해서, 값들을 뽑으려면

import java.util.*;

public class App {
    public static void main(String[] args) {
        HashMap<String, Integer> mp = new HashMap<>();
        mp.put("a", 1);
        mp.put("b", 10);
        mp.put("c", 100);
        mp.values().stream().forEach(e->System.out.println(e)); //1 10 100
    }
}

• put으로 넣고 values().stream().forEach() 로 값을 뽑는다.

값이 아니라 key들을 뽑으려면

import java.util.*;

public class App {
    public static void main(String[] args) {
        HashMap<String, Integer> mp = new HashMap<>();
        mp.put("a", 1);
        mp.put("b", 10);
        mp.put("c", 100);
        mp.keySet().forEach(e->System.out.println(e)); // a b c
        for(String a: mp.keySet()) { // 똑같이 Key값 출력
            System.out.println(a); // a b c
        }
    }
}

문자열

순회

import java.util.*;

public class App {
    public static void main(String[] args) {
       String a = "lavine is zagabi";
       for(char b : a.toCharArray()) {
            System.out.println(b); // 문자열 한글자씩 출력
       }
    }
}

• String 타입에 toCharArray()

문자열 기반 로직의 대표 - 카운트 배열

문자열 안에 각 문자가 몇 개 들어가 있는지 카운트

import java.util.*;

public class App {
    public static void main(String[] args) {
       String a = "lavine is zagabi";
       int [] cnt = new int[26];
       for(char b : a.toCharArray()) {
            System.out.println(b);// 문자열 한글자씩 출력
            if(b >= 'a' && b <= 'z'){
                cnt[b-'a']++;
            }
       }
       for (int i : cnt) {
            System.out.println(i); //3 1 0 0 1 0 1 .... 
       }
    }
}

import java.util.*;

public class App {
    public static void main(String[] args) {
       String a = "lavine is zagabi";
       int [] cnt = new int[26];
       for(char b : a.toCharArray()) {
            System.out.println(b);// 문자열 한글자씩 출력
            if(b >= 'a' && b <= 'z'){
                cnt[b-'a']++;
            }
       }
       for (int i = 0; i < 26; i++) {
            if (cnt[i] > 0) {
                System.out.println((char) (i + 'a') + ": " + cnt[i]); // a:3, b:1, e:1, g:1, i:3 ....
            }
       }
    }
}

 

chars를 쓰면 char를 스트림으로 만들어서 쓸 수 있다

import java.util.*;

public class App {
    public static void main(String[] args) {
       String a = "lavine is zagabi";
       int [] cnt = new int[26];
       a.chars().filter(e -> e >= 'a' && e <= 'z').forEach(e -> cnt[e - 'a']++);

       for (int i = 0; i < 26; i++) {
            if (cnt[i] > 0) {
                System.out.println((char) (i + 'a') + ": " + cnt[i]); // 출력 동일
            }
       }
    }
}

문자열 주요 메소드 1 - split

import java.util.*;

public class App {
    public static void main(String[] args) {
       String a = "lavine is zagabi";
       String [] b = a.split(" "); // 공백 기준으로 나눠서
       for(String c : b) {
        System.out.println(c);// lavine is zagabi 하나씩 출력
       }
    }
}

split은 구분자를 기준으로 문자열을 배열로 만들어줌

대신 정규표현식이 매개변수로 들어가므로 만약 공백 대신 .이 구분자라면

import java.util.*;

public class App {
    public static void main(String[] args) {
       String a = "lavine.is.zagabi";
       String [] b = a.split("\\."); // .를 구분자로 lavine is zagabi가 배열 0,1,2 인덱스로 생성
       for(String c : b) {
        System.out.println(c);
       }
    }
}

문자열 주요 메소드 2 - indexOf

배열에서 찾는 문자가 몇번째 위치에 있는지(가장 처음 찾은 위치 기준)

import java.util.*;

public class App {
    public static void main(String[] args) {
       String a = "lavine.is.zagabi";
       int b = a.indexOf("a"); // 1 , 만약 없는 문자열을 인자로 받으면 -1 리턴
       System.out.println(b);
    }
}

문자열 주요 메소드 2 - substring

배열에서 원하는 부분을 빼다가 새 배열을 만드는 법

import java.util.*;

public class App {
    public static void main(String[] args) {
       String a = "lavine.is.zagabi";
       String b = a.substring(0, 3); // lav
       System.out.println(b);
    }
}

• 첫번째 인자: 시작 인덱스
• 두번째 인자: 마지막 인덱스

형변환

문자열→정수 , 정수→문자열

import java.util.*;

public class App {
    public static void main(String[] args) {
       String a = "1234";
       int b = Integer.parseInt(a);
       System.out.println(b);
    }
}

import java.util.*;

public class App {
    public static void main(String[] args) {
       String a = "1234";
       int b = Integer.parseInt(a);
       String c = Integer.toString(b);
       System.out.println(b);
    }
}

배열 초기화

import java.util.*;

public class App {
    public static void main(String[] args) {
        int [] a = new int[5];  // 전부 0으로 초기화, boolean은 false, string은 null
        Arrays.fill(a,30); // 30 30 30 30 30 으로 초기화
        for (int b : a) {
            System.out.println(b);
        }

    }
}

1차원 배열은 fill 메서드쓰면 쉽다.

2차원 배열 전체를 초기화하는건 한번에 불가능. 그냥 포문 돌리면됨

import java.util.*;

public class App {
    public static void main(String[] args) {
        int [][] a = new int[5][5];
        for(int i = 0; i < 5; i++) {
            Arrays.fill(a[i], 30);
        }
        for(int i = 0; i < 5; i++) {
            for(int j=0; j<5; j++) {
                System.out.println(a[i][j]); // 30이 25개 나올거임 카운트 코드 구현해보자
            }
        }
    }
}

• a[0]에 fill 해서 a[0][0]~a[0][4] 채우는걸 a[4][4]까지 반복하는것

배열 복사

import java.util.*;

public class App {
    public static void main(String[] args) {
        int [] a = {1,2,3,4,5};
        int [] b = new int[a.length]; // 같은 크기 배열 만든다음
        System.arraycopy(a, 0, b, 0, a.length);
        for(int i : b) {
            System.out.println(i); // 1 2 3 4 5
        }
    }
}

a의 값을 복사해서 b 배열을 만든다. 복사된 후 a 값 아무리 변동해도 b에 영향 없음

DFS BFS

노드간에 간선이 있다 한들 방문했던 곳은 방문하지 않는다.
BFS는 너비우선으로 방문한다.

 

visted의 경우

• BFS는 int → BFS는 가중치가 같은 그래프 내에서 최단거리 알고리즘으로 쓰이기 때문에 초기 정점의 값을 1로 만들고, 문제에 따라 다른 노드까지의 거리를 …0부터 시작하는 경우 초기 정점에 대한 방문 처리를 다시 해줘야 한다
• DFS는 boolean

Adj[0].add(1) = 0번째 정점에서 1번째 정점으로 가는 간선이 있다는 뜻

import java.util.*;

public class App {
    private static List<List<Integer>> adj; // 인접리스트 2차원
    private static boolean[] visited; // DFS visted
    private static int[] visited2; // BFS visited
    private static void DFS(int here) {
        visited[here] = true;
        System.out.print(here + " ");
        for (int v : adj.get(here)) {
            if (!visited[v]) { // 방문이 안되어있다면 DFS 재귀
                DFS(v);
            }
        }
    }

    private static void BFS(int here) {
        Queue<Integer> queue = new LinkedList<>();
        visited2[here] = 1 ;
        queue.add(here);
        while (!queue.isEmpty()) { // queue가 비어있을때까지 반복
            here = queue.poll(); // queue 가장 위에있는걸 빼면서 가져온다.
            System.out.print(here+" ");
            for (int there : adj.get(here)) {
                if (visited2[there] == 0) { //방문이 안된경우
                    visited2[there] = visited2[here] + 1; // 방문 하면서 
                    queue.add(there); // 최단거리 걸어!
                }
            }
        }
    }
    public static void main(String[] args) {
        int num = 5;
        adj = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            adj.add(new ArrayList<>()); // 빈 arrayList에 arrayList를 추가 ex. {{}, {}, {}, ...}
        }
        adj.get(0).add(1);
        adj.get(0).add(2); // 0에서 1가는 간선과 2가는 간선 존재
        adj.get(1).add(0); // 1에서 0,3,4 로 가는 간선 존재
        adj.get(1).add(3);
        adj.get(1).add(4);
        visited = new boolean[num]; // static으로 만든 visited에 값 부여(보통 문제에서 입력으로 주어짐 그런 num값을 받아서 설정함)
        DFS(0);
        System.out.print("\n");
        visited2 = new int[num]; // 최단거리 배열을 만들어야함 <- int써야하는이유
        BFS(0);
    }
}

출력
0 1 3 4 2 
0 1 2 3 4

DP

대표적으로 피보나치 수열이 있다.

 import java.util.*;

public class App {
    private static int[] memo; // 취향, 전역변수로 하는게 좋으면 이렇게
    private static int fibo(int n) {
        if (n <= 1) return n;
        if (memo[n] == 0) { // DP 에 값이 없으면 계산
            memo[n] = fibo(n - 1) + fibo(n - 2);
        }
        return memo[n]; // 값이 있으면 그냥 return
    }
    public static void main(String[] args) {
        int num = 5; // 늘려도 잘됨
        memo = new int[num + 1];
        for (int i = 0; i <= num; i++) {
            System.out.println("fibo(" + i + ") = " + fibo(i));
        }
    }
}

//fibo(0) = 0
//fibo(1) = 1
//fibo(2) = 1
//fibo(3) = 2
//fibo(4) = 3
//fibo(5) = 5

Binary Search

정렬된 배열에서 하면 된다

Arays.binarySearch() 쓰면 됨

import java.util.*;

public class App {
    public static void main(String[] args) {
        int [] a = {1,2,3,4,5};
        int target = 3;

        int index = Arrays.binarySearch(a, target);
        if ( index >= 0 ) {
            System.out.println("Found at: " + index); // 2
        } else {
            System.out.println("Not found");
        }
    }
}