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)

코딩 테스트 합격자 되기 정리 #1

사전 준비

• 분석 먼저
• 예외 테스트 케이스
• 기록 - 못푼것도 기록은 해두자
• 나만의 언어로 요약

문제 분석

• 문제를 쪼개서 분석
• 제약사항과 테스트 케이스
• 입력값 분석하고 알고리즘 설정
• greedy, 완전 탐색 뭘로 할지
• 데이터 흐름과 구성 파악
• 의사 코드로 설계

채점기준

• 정확성 테스트
• 효율성 테스트

시간복잡도

• O(N) 허용 연산 횟수는 2000만
• 초당 연산 최대 횟수는 1억번, 제한시간이 1초면 연산 횟수가 3000만이 안넘도록
• 지수함수, 다항함수, 로그함수
• 입력 크기에 따른 연산 횟수의 추이를 활용해서 시간복잡도를 표현하는 방법 - 점근적 표기법
• 특정값을 계속 반으로 줄이는 동작을 한다면 O(logN)

코딩 테스트 필수 문법

프리미티브 타입 / 레퍼런스 타입

• int, long, float, double
• Integer, Long, Float, Double - 연산 속도는 느림
• 엡실론 epsilon - 부동소수형 데이터를 이진법으로 표현해서 생기는 오차
• 비트연산

&, |, ^ XOR, ~ NOT, <<, >>

• 논리연산

&&, ||, !(x>y)

컬렉션 프레임워크

배열

• 연속된 메모리 공간
• 생성이후 크기 변경 불가, 새 데이터를 삽입,삭제 불가. 변경만 가능
• index로 요소 접근 - index를 알고 있다면 접근,변경은 O(1)

int[] array = {1,2,3,4,5};
int[] array2 = new int[]{1,3,5,7,9};
int[] array3 = new int[5];

리스트 ArrayList (사실 LinkedList 도 있음)

• 가변 크기
• 맨 뒤 추가시 O(1), 삭제나 중간 삽입은 O(N)

해시맵 hashmap

• key, value

// Integer = 32bit = 4byte
HashMap<String, Integer> map = new HashMap<>();

// 삽입 
map.put("apple", 1);

// 검색
if(map.containsKey(key)) { ... }

map.get(key);

// 삭제
map.remove(key);

문자열

• immutable 객체 - 값을 변경할 수 없는 객체, 시간 복잡도 관점에서도 주의
• 추가, 삭제시 기존 객체를 수정하는 것이 아니라 새로운 객체를 반환한다.
• 수정

.replace("a", "");

StringBuffer, StringBuilder

Sytem.out.println(System.identityHashCode(s));

long start = System.currentTimeMillis();
StringBuilder s = new StringBuilder();
for(int i=0; i<=100_000; i++) {
    s.append(i);
} 
long end = System.currentTimeMillis();
System.out.println(((end-start)/1000.0) + "초"); 

• 차이 StringBuffer 는 Thread-Safe (코딩테스트에서는 거의 안씀)
• 속도면에서 StringBuilder 가 조금 더 빠름(코딩테스크 기준 권장)

sb.deleteCharAt(index)
sb.insert(index, 문자);

Stack

Queue

ArrayDeque (덱 혹은 데크 라고 읽음)

• 양방향 queue, 즉 앞쪽, 뒤쪽에서 pop 가능

메서드

• 람다식 / 익명함수 - 한번만 사용하거나 함수자체를 다른 함수의 인자로 전달(고차함수)

Node[] nodes = new Node[5];
Arrays.sort(nodes, (o1,o2) -> Integer.compare(o1.cost, o2.cost));


Arrays.sort(nodes, new Comparator<Node>() {
    @Override
    public int compare(Node o1, Node o2) {
        return Integer.compare(o1.cost, o2.cost);
    } 
}

• Integer.compare(int x, int y) 는 x<y면 -1, x>y면 1, x=y면 0

코드 구현 노하우

• 조기 반환
• 보호 구문

List<Integer> numbers
...
int total = numbers.stream().mapToInt(i->i).sum();

• 제네릭

List<Integer> genericList = new ArrayList<>();
// 빌드 레벨에서 타입체크하여 타입 강제

ReentrantLock은 Java에서 제공하는 고급 동기화 도구로, synchronized 블록보다 더 많은 제어를 제공하는 Lock 인터페이스의 구현체입니다.

🔐 ReentrantLock이란?

• Java의 java.util.concurrent.locks.ReentrantLock 클래스
• 재진입 가능(reentrant) 한 락
  → 같은 스레드가 여러 번 lock을 획득해도 deadlock 없이 동작
• synchronized와 유사하지만 더 세밀한 컨트롤 가능

🔸 기본 사용 예제

import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // 🔐 lock 획득
        try {
            count++;
        } finally {
            lock.unlock(); // 🔓 꼭 해제해줘야 함!
        }
    }

    public int getCount() {
        return count;
    }
}

⚠️ finally 블록에서 unlock()을 꼭 호출해야 합니다.
예외가 발생해도 락이 풀리지 않으면 데드락(deadlock) 발생할 수 있어요.

HashMap과 LinkedHashMap은 둘 다 Java에서 제공하는 Map 인터페이스의 구현체이지만, 동작 방식과 특징에 몇 가지 중요한 차이점이 있습니다:

🔹 1. 저장 순서 유지 여부

• HashMap은 내부적으로 순서를 신경 쓰지 않기 때문에, 데이터를 삽입한 순서와 꺼낼 때 순서가 다를 수 있음.
• LinkedHashMap은 이중 연결 리스트를 사용해 데이터를 저장한 순서를 기억함.

🔹 2. 성능

• LinkedHashMap은 연결 리스트를 유지해야 하므로 약간의 오버헤드가 있음.

🔹 3. null 허용 여부

둘 다 null 키 하나와 null 값 여러 개 허용함.