모의 테스트

두개 뽑아서 더하기

public static int[] solution_03(int[] numbers) {
    TreeSet<Integer> result = new TreeSet<>();

    for (int i = 0; i < numbers.length - 1; i++) {
        for (int j = i + 1; j < numbers.length; j++) {
            result.add(numbers[i] + numbers[j]);
        }
    }

    return result.stream().sorted().mapToInt(Integer::intValue).toArray();
}

• stream 사용법

모의고사 (수포자)

public static int[] solution_04(int[] answers) {
    int[] pattern1 = {1, 2, 3, 4, 5};
    int[] pattern2 = {2, 1, 2, 3, 2, 4, 2, 5};
    int[] pattern3 = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};

    int[] scores = new int[3];

    for (int i = 0; i < answers.length; i++) {
        scores[0] += answers[i] == pattern1[i % pattern1.length % pattern1.length] ? 1 : 0;
        scores[1] += answers[i] == pattern2[i % pattern2.length % pattern2.length] ? 1 : 0;
        scores[2] += answers[i] == pattern3[i % pattern3.length % pattern3.length] ? 1 : 0;
    }

    int maxScore = Arrays.stream(scores).max().getAsInt();

    ArrayList<Integer> answer = new ArrayList<>();
    for (int i = 0; i < scores.length; i++) {
        if (scores[i] == maxScore) {
            answer.add(i + 1);
        }
    }
    return answer.stream().mapToInt(Integer::intValue).toArray();
}

• 패턴 파악, maxScore 구하는 방법 .max().getAsInt()

행렬의 곱셉

public static int[][] solution_05(int[][] arr1, int[][] arr2) {
    int[][] answer = new int[arr1.length][arr2[0].length];

    for (int i = 0; i < arr1.length; i++) {
        for (int j = 0; j < arr2[0].length; j++) {
            for (int k = 0; k < arr1[0].length; k++) {
                answer[i][j] += arr1[i][k] * arr2[k][j];
            }
        }
    }
    return answer;
}

• O(N^3) 의 index 유의

실패율

public static int[] solution_06(int N, int[] stages) {

    int[] challenger = new int[N+2];
    Arrays.stream(stages).forEach(stage -> challenger[stage]++);

    HashMap<Integer, Double> fails = new HashMap<>();
    double totalPlayer = stages.length;

    for( int i = 1; i <= N; i++) {
        if(challenger[i] == 0) {
            fails.put(i, 0.0);
        }else {
            fails.put(i, (double)challenger[i]/totalPlayer);
            totalPlayer -= challenger[i];
        }
    }

    return fails.entrySet().stream()
        .sorted((o1, o2) -> Double.compare(o2.getValue(), o1.getValue()))
        .mapToInt(HashMap.Entry::getKey).toArray();
}

• challenger 을 [N+2] 개로 잡는 이유
• for문에서 totalPlayer -= challenger[i];
• HashMap의 entrySet 사용 요령 기억하기

방문 길이

import java.util.HashMap;
import java.util.HashSet;

class Solution {

    private static HashMap<Character, int[]> location = new HashMap<>();

    private static void initLocation() {
        location.put('U', new int[]{0, 1});
        location.put('D', new int[]{0, -1});
        location.put('L', new int[]{-1, 0});
        location.put('R', new int[]{1, 0});
    }

    public int solution(String dirs) {
        initLocation();
        int x = 5, y = 5;

        HashSet<String> answer = new HashSet<>();

        for (int i = 0; i < dirs.length(); i++) {
            int[] move = location.get(dirs.charAt(i));
            int nx = x + move[0];
            int ny = y + move[1];

            if (!isValidMove(nx, ny)) {
                continue;
            }
            answer.add(x + " " + y + " " + nx + " " + ny);
            answer.add(nx + " " + ny + " " + x + " " + y);

            x = nx;
            y = ny;
        }

        return answer.size() / 2;
    }

    private static boolean isValidMove(int nx, int ny) {
        return nx < 11 && nx >= 0 && ny < 11 && ny >= 0;
    }
}

• A->B, B->A 도 하나의 이동경로로 파악되는 점 유의 answer.size() / 2 (문제에는 상세 설명이 없음)

Virtual Thread는 Java 19부터 도입되고 Java 21에서 정식으로 안정화된 Project Loom의 핵심 기능 중 하나로, 기존의 Java 플랫폼에서 사용되던 platform thread(또는 OS thread)와는 다른 개념입니다. Virtual thread는 **경량 스레드(lightweight thread)**로서, 수십만 개의 스레드를 동시에 실행할 수 있도록 설계되었습니다.

1. Virtual Thread의 핵심 개념

기존 Platform Thread vs Virtual Thread

2. 주요 특징

경량 스레드

• Virtual thread는 메모리 사용량이 훨씬 적고 생성 속도도 빠릅니다.
• 1:1 매핑이 아닌 M:N 구조로, 여러 virtual thread가 하나의 OS thread를 공유합니다.

차단 I/O와의 통합

• 기존에는 Thread.sleep()이나 InputStream.read() 같은 blocking I/O 호출이 OS thread를 점유하여 비효율적이었음.
• Virtual thread에서는 이러한 호출이 발생하면 JVM이 해당 virtual thread를 parking하고, 다른 작업을 실행시켜 병목을 피함.

코드 스타일 유지

• 기존의 CompletableFuture, Reactive API 없이도 전통적인 동기 코드 스타일을 유지하면서도 고성능 비동기 처리가 가능.

3. 사용 예시

Runnable task = () -> {
    System.out.println("Hello from " + Thread.currentThread());
};

Thread thread = Thread.ofVirtual().start(task);

혹은 Executors를 통해 수많은 스레드 처리도 가능:

대용량 처리를 위한 **비동기 Event Driven Architecture (EDA)**는 시스템이 이벤트(event)를 중심으로 작동하며, 확장성, 유연성, 성능을 확보하는 데에 효과적인 아키텍처입니다. 아래에 개념과 구성 요소, 장점 및 적용 사례에 대해 자세히 설명드릴게요.

✅ 1. 기본 개념

**Event Driven Architecture (EDA)**는 시스템 내에서 이벤트가 발생하면, 이를 감지하고 처리하는 구조로 구성됩니다. 이벤트는 어떤 상태의 변화를 의미하고, 이를 **프로듀서(생산자)**가 발생시키고, **컨슈머(소비자)**가 이를 처리합니다.

비동기 방식에서는 이 이벤트가 즉시 처리되지 않고, 큐나 버퍼를 통해 일시 저장되며, 컨슈머가 가능한 시점에 이벤트를 처리합니다. 이 구조는 시스템이 처리해야 할 데이터나 요청이 많을 때 부하를 완화하고 확장성을 제공합니다.

JPA에서 N+1 문제는 성능 저하를 유발할 수 있는 대표적인 ORM 사용 시의 이슈 중 하나입니다. 아래에 자세히 설명드릴게요.

N+1 문제란?

N+1 문제는 JPA에서 연관된 엔티티를 지연 로딩(LAZY loading) 방식으로 조회할 때 발생합니다.

예를 들어, 다음과 같은 상황을 가정해 봅시다:

• 게시글(Post)과 작성자(Member)는 다대일(N:1) 관계이다.
• 게시글 1개는 작성자 1명을 가진다.

@Entity
public class Post {
    @ManyToOne(fetch = FetchType.LAZY)
    private Member author;
}

게시글 리스트를 조회하는 쿼리를 날리면:

List<Post> posts = postRepository.findAll();

이때 JPA는 다음과 같은 방식으로 작동합니다:

stream().mapToInt()는 Java Stream API에서 사용되는 메서드 중 하나로, Stream의 요소를 int형 정수로 변환하여 IntStream을 생성하는 역할을 합니다.

💡 사용 목적

mapToInt()는 주로 객체 스트림에서 정수값을 추출하고자 할 때 사용됩니다. 예를 들어, 어떤 객체 리스트에서 특정 필드(예: 나이, 점수 등)를 정수로 뽑아낼 때 유용합니다.

📌 기본 구조

Stream<T> stream = ...;
IntStream intStream = stream.mapToInt(element -> 변환할 int 값);

✅ 예시

List<String> list = List.of("1", "2", "3");
int sum = list.stream()
              .mapToInt(Integer::parseInt)  // String → int
              .sum();                       // IntStream 연산 사용
System.out.println(sum); // 출력: 6

위 코드에서:

배열

선언

int[] arr = {0,0,0,0,0,0};
int[] arr = new int[6];

• ArrayList - 저장할 데이터 개수를 정확히 알 수 없다면…

차원

• 2차원

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

ArrayList

• 추가

ArrayList<Integer> list = new ArrayList<>();
list.add(1);

• 초기화

ArrayList<Integer> list = new ArrayList<>();
ArrayList<Integer> list2 = new ArrayList<>(list);

• 접근 - get(index)
• 삭제 - remove()

• length 변수
• Arrays.sort()
• toString()
• size()
• isEmpty()
• Collections.sort

ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));
Collections.sort(list); // array는 Arrays.sort()

• sort() 사용시 from 인덱스, to 인덱스로 특정범위만 정렬 가능

ArrayList 효율성

• 시간 복잡도

• 접근 O(1)
• 맨 뒤 삽입 O(1)
• 맨 앞이나 중간. O(N)

• 고려할 점
  • 할당할 수 있는 메모리 - 정수형 1차원 1000만개, 2차원은 3000*3000 정도
  • 중간에 데이터 삽입이 빈번한 경우 시간 초과할 수 있음.

몸풀기 문제

정렬

• Arrays.sort() -> Dual-Pivot QuickSort 혹은 Tim-Sort : 성능좋으니까 그냥 쓰자

// bubble sort 예
private static int[] bubbleSort(int[] org) {
    int[] arr = org.clone();
    int n = arr.length;
    for(int i=0; i< n; i++) {
        for(int j=0; j<n-i-1; j++) {
            if(arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

• 원본을 그대로 두고 싶으면

int[] clone = arr.clone();

배열 제어하기

• 중복 제거

Integer[] result = Arrays.stream(arr).boxed().distinct().toArray(Integer[]::new);

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

Arrays.stream(result).mapToInt(Integer::intValue).toArray(); // int[]로

• 가급적 표준 API를 사용해서 시간초과 발생하지 않도록

TreeSet<Integer> set = new TreeSet<>(Collections.reverseOrder());
int[] result = new int[set.size()];
for(int i = 0; i < result.length; i++) {
    result[i] = set.pollFirst();
} 
// 중복제거 O(N), 정렬 O(NlogN) => O(NlogN)