API (Application Programming Interface)는 두 소프트웨어가 기능이나 데이터를 주고받기 위해 정해놓은 규칙(명세)이다.

쉽게 말해, 서로 다른 프로그램이 정해진 방식에으로 소통할 수 있게 해주는 설명서 또는 사용법을 말한다.

List<String> list = new ArrayList<>();
list.add("추가");

위 코드에서 add()는 우리가 직접 구현한 메서드가 아니지만, Java API에 정의된 메서드를 호출함으로써 리스트에 데이터를 추가할 수 있다.

add()가 아니라 추가해줘() 같은 임의의 이름을 사용하면 동작하지 않는다. Java API가 정의한 명세를 따라야만 우리가 의도한 기능이 수행되는 것이다.

2. Java API와 패키지 구조

Java API는 Java에서 기본적으로 제공하는 기능들의 집합이다.

우리가 Java에서 사용하는 List, Map, Math, Stream 등은 모두 Java API에 포함되어 있으며, 다음과 같이 기능별로 패키지(package)라는 단위로 나뉘어 관리된다.

• java.util → 유틸리티 클래스 (List, Map 등)
• java.io → 입출력 기능 (InputStream 등)
• java.util.stream → 스트림 처리 기능 (Stream 등)

3. Java에서 말하는 "Stream"이란?

Stream의 사전적 의미는 흐름, 연속적인 흐름이며, 프로그래밍에서는 일련의 데이터를 한 방향으로 흘려보내며 처리하는 구조를 의미한다.

대표적인 예:

• 파일을 읽을 때 사용하는 InputStream
• 데이터를 출력하는 OutputStream
• 영상/음악을 실시간으로 전송하는 스트리밍 서비스

Java Stream API를 설명하기 전, 먼저 "Stream"은 데이터를 흐름처럼 처리하는 방식 이라는 개념부터 이해하면 된다.

4. Java Stream API란?

Java Stream API는 위에서 설명한 Stream 개념을 Java에서 공식적으로 구현해 제공하는 기능 집합이다.

Java Stream API에는 다음과 같은 클래스들이 포함되어 있으며, java.util.stream 패키지 안에 정의되어 있다.

• Stream, IntStream, LongStream 등 스트림 인터페이스
• Collectors, StreamSupport, Spliterator 등 보조 유틸리티 클래스

이해하기 쉽게 비유로 포현해보자면 다음과 같다.

비유 대상| 실제 의미 |---|---| |📦 java.util.stream 패키지| 기능이 정리되어 담긴 서랍| |🔧 Stream API |서랍 안에 있는 공구 세트 (기능 집합)| |🛠️ Stream, Collectors, map, filter...| 우리가 직접 사용하는 공구들| |🧑‍🔧 개발자| 공구를 조합해 데이터를 가공하는 사람 = Stream 사용자|

5. 정리하자면

• Stream: 데이터를 흐름처럼 처리하는 개념
• API: 기능을 사용할 수 있도록 정의된 명세
• Java Stream API: Java에서 Stream 기능을 사용할 수 있도록 제공하는 기능 모음

이 기능들은 java.util.stream 패키지 안에 포함되어 있고, 우리는 그 안의 메서드들(map, filter, collect 등)을 조합해 데이터를 처리한다.

이러한 과정을 우리는 흔히 "Stream을 사용한다"고 말하는 것이다.

Queue는 FIFO(First-In-First-Out) 구조를 따르는 자료구조 인터페이스이며,
PriorityQueue는 이를 구현한 클래스 중 하나로 우선순위 기반 정렬 큐를 제공한다.

1. Queue란?

Queue는 선입선출(FIFO) 구조를 따르는 컬렉션으로,
먼저 추가된 요소가 먼저 제거되는 구조를 가진 인터페이스이다.

인터페이스이므로 직접 객체 생성은 불가능하고, LinkedList, PriorityQueue 등 구현체를 사용한다.

Queue<String> queue = new LinkedList<>();
queue.add("A");
queue.add("B");
System.out.println(queue.poll()); // A

2. PriorityQueue란?

PriorityQueue는 Queue 인터페이스를 우선순위 기반으로 구현한 클래스다. 즉, 먼저 넣은 순서가 아닌 값의 크기나 지정한 우선순위 기준에 따라 요소가 처리된다.

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.add(30);
pq.add(10);
pq.add(20);
System.out.println(pq.poll()); // 10

위 코드처럼 30 → 10 → 20 순으로 데이터를 넣어도, 우선순위가 가장 높은 값인 10이 먼저 poll()로 꺼내진다.

기본 정렬 방식

기본적으로 오름차순 정렬(Min-Heap) 으로 작동하며, Comparator.reverseOrder()를 통해 내림차순(Max-Heap)으로 바꿀 수 있다.

// 오름차순 정렬 (기본)
PriorityQueue<Integer> minHeap = new PriorityQueue<>(); 
// 내림차순 정렬
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Comparator.reverseOrder()); 

🔧 내부 구조

Java의 PriorityQueue는 힙(Heap) 자료구조를 기반으로 구현되어 있다.

힙(Heap)은 완전 이진 트리 형태로 구성되며, 요소를 삽입하거나 제거할 때마다 자동으로 우선순위를 유지하도록 정렬된다.

• 기본적인 PriorityQueue는 최소 힙(Min-Heap)이며, 가장 작은 값이 루트에 위치
• Comparator.reverseOrder()를 사용하면 최대 힙(Max-Heap)으로 동작 가능

힙은 정렬된 배열이 아니며, 항상 우선순위가 가장 높은 요소만 빠르게 꺼낼 수 있도록 정렬된 트리 구조다.

3. Queue와 PriorityQueue의 주요 메서드

1. offer(E e)

Queue<String> queue = new LinkedList<>();
queue.offer("A");  // 큐에 "A" 추가

설명 : 큐의 끝에 요소를 추가한다. 공간이 부족하면 false 반환 시그니처 : boolean offer(E e)
매개변수 : e – 큐에 추가할 요소
사용 상황 : 큐에 안전하게 요소를 추가하고, 실패 시 예외 대신 false를 받고 싶을 때

2. poll()

Queue<String> queue = new LinkedList<>();
queue.offer("A");
String item = queue.poll(); // "A" 반환 및 제거

설명 : 큐의 맨 앞 요소를 제거하고 반환한다. 비어 있으면 null 반환
시그니처 : E poll()
매개변수 : 없음
사용 상황 : 큐에서 안전하게 요소를 꺼내고, 비어 있을 경우 null 처리하고 싶을 때

3. remove()

Queue<String> queue = new LinkedList<>();
queue.offer("A");
String item = queue.remove(); // "A" 반환 및 제거

설명 : 큐의 맨 앞 요소를 제거하고 반환한다. 비어 있으면 예외 발생 시그니처 : E remove()
매개변수 : 없음
사용 상황 : 큐가 비어 있지 않다고 확신할 수 있을 때, 예외로 처리하고 싶은 경우

4. peek()

Queue<String> queue = new LinkedList<>();
queue.offer("A");
String front = queue.peek(); // "A" 반환, 큐는 그대로

설명 : 큐의 맨 앞 요소를 제거하지 않고 반환한다. 비어 있으면 null 반환 시그니처 : E peek()
매개변수 : 없음
사용 상황 : 현재 큐의 앞에 있는 값을 미리 확인하고 싶을 때

5. element()

Queue<String> queue = new LinkedList<>();
queue.offer("A");
String front = queue.element(); // "A" 반환, 큐는 그대로

설명 : 큐의 맨 앞 요소를 제거하지 않고 반환한다. 비어 있으면 예외 발생.
시그니처 : E element()
매개변수 : 없음
사용 상황 : 큐가 비어 있지 않을 때, 요소가 반드시 존재해야 할 때

6. isEmpty()

Queue<String> queue = new LinkedList<>();
boolean empty = queue.isEmpty(); // true

설명 : 큐가 비어 있는지 여부를 반환한다.
시그니처 : boolean isEmpty()
매개변수 : 없음
사용 상황 : 큐가 비어있는지 확인하고 처리 분기하고 싶을 때

7. size()

Queue<String> queue = new LinkedList<>();
queue.offer("A");
queue.offer("B");
int count = queue.size(); // 2

설명 : 큐에 현재 저장된 요소의 개수를 반환한다.
시그니처 : int size()
매개변수 : 없음
사용 상황 : 큐의 상태(비어있는지/가득 찼는지 등)를 판단하고자 할 때

4. Queue와 PriorityQueue의 차이점

Queue는 요소가 들어온 순서대로(FIFO) 처리되는 반면,
PriorityQueue는 요소의 값에 따라 우선순위가 높은 요소부터 처리된다.

Queue는 LinkedList로 구현될 경우 null 을 추가할 수 있지만, PriorityQueue는 내부 정렬 로직(Heap 구조) 때문에 null을 추가하면 NullPointerException이 발생하므로 주의해야 한다.

5. 알고리즘 활용 팁

☑️ Queue

• BFS (너비 우선 탐색)

  • 그래프 탐색 알고리즘에서 노드를 순차적으로 방문할 때 사용
  • FIFO 구조 덕분에 레벨 단위 탐색이 가능함
  • 예시: 미로 탈출, 최소 이동 거리 계산 등

• 작업 대기열 (Task Queue)

  • 순차적으로 실행해야 하는 작업을 저장하는 큐
  • 예: 웹 요청 처리 순서, 비동기 이벤트 큐

• Producer-Consumer 패턴

  • 멀티스레드 환경에서 BlockingQueue로 안전하게 데이터 전달
  • 예: 로그 수집, 메시지 큐 시스템 구현

☑️ PriorityQueue

• 다익스트라 알고리즘 (최단 경로)

  • 거리가 가장 짧은 노드를 우선 처리해야 하므로
  • 우선순위 큐를 사용해 O(log n)으로 꺼낼 수 있음

• 힙 정렬 (Heap Sort)

  • PriorityQueue에 모두 넣고 하나씩 꺼내면 자동 정렬
  • 최대 힙: 내림차순 정렬, 최소 힙: 오름차순 정렬

• 시뮬레이션 문제 (우선순위 처리)

  • 예: 응급환자 먼저 처리, 문서 인쇄 순서, CPU 스케줄링 등
  • 값 외에도 우선순위를 정의하고 Comparator로 커스터마이징 가능

☑️ JVM Runtime Data Areas

• PC Register: 각 스레드의 현재 실행 중인 명령어의 주소 저장
• JVM Stacks: 각 스레드의 메서드 호출 시 생성되는 프레임, 지역 변수, 참조 변수 주소 저장
• Heap: new로 생성된 실제 객체 인스턴스와 배열 저장 (GC가 관리)
• Method Area: 클래스 정보, static 변수, 메서드 코드 저장
• Run-Time Constant Pool: 클래스 로딩 시 생성되는 상수 테이블
• Native Method Stack: C/C++ 네이티브 코드 실행 위한 공간

여기서 복사와 가장 밀접한 부분은 스택(Stack)과 힙(Heap)이다.

스택에는 객체의 참조값(주소)이 저장되고,
힙에는 new로 생성한 실제 객체 인스턴스가 저장된다.

즉, JVM 메모리 공간은 참조값(주소) → 스택, 실제 데이터 → 힙에 있는 구조를 가지며 이 구조가 바로 복사 시 어떤 값이 복사되는지를 결정하는 핵심이다.

얕은 복사(Shallow Copy) 는 스택에 있는 참조값(주소값)만 복사 하여, 두 변수가 같은 힙 객체를 공유 하는 방식이고, 깊은 복사(Deep Copy) 는 힙에 있는 객체를 새롭게 생성해서 스택에 새로운 참조값을 저장 하는 방식이다.

아래 String 형태의 name과 address를 필드로 가지는 Person 클래스가 있다.

private static class Person {
    private String name;
    private String address;

    public Person(final String name, final String address) {
        this.name = name;
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public void setName(final String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(final String address) {
        this.address = address;
    }
}

✔️ 얕은 복사(Shallow Copy)

Person person1 = new Person("길동", "서울");
Person person2 = person1;

person2.setAddress("부산");

System.out.println(person1.address);
System.out.println(person2.address);

이름이 '길동', 주소가 '서울'인 person1을 생성한 후, person1을 person2에 복사했다.

그 후 person2의 주소를 '부산'으로 변경했다.

System.out.println(person1.address); // 부산
System.out.println(person2.address); // 부산

System.out.println(person1); // example$Person@2f7a2457
System.out.println(person2); // example$Person@2f7a2457

person2의 주소만 변경했음에도 person1의 주소도 함께 '부산'으로 변경됐다. 또한, 두 객체 모두 Person@2f7a2457이라는 동일한 주소 를 가지고 있다는 것을 확인할 수 있다.

이렇게 얕은 복사는 주소값만 복사하여 같은 객체를 공유하는 방식으로 person2는 새로 생성된 것이 아니라, 기존 person1이 가리키는 객체의 주소를 그대로 참조한다. 따라서 person2의 값을 변경하면, 같은 객체를 공유하는 person1의 값도 함께 변경된다.

얕은 복사는 하나의 물체에 이름표만 하나 더 붙인 것이라고 생각하면 이해가 쉽다. 이름표가 늘어나도 물체는 하나뿐이기 때문에, 어떤 이름으로 접근하든 동일한 물체에 영향을 주게 되는 것이다.

✔️ 깊은 복사(Deep Copy)

Person person1 = new Person("길동", "서울");
Person person2 = new Person(person1.getName(), person1.getAddress());

person2.setAddress("부산");

이번에는 person1을 복사할 때 새로운 Person 객체를 생성하여 person2에 담았다. person1의 이름과 주소 값을 생성자에 전달해 새로운 Person 객체 person2를 만들었다.

그 후 이전과 동일하게 person2의 주소를 '부산'으로 변경했다.

System.out.println(person1.address); // 서울
System.out.println(person2.address); // 부산

System.out.println(person1); // example$Person@2f7a2457
System.out.println(person2); // example$Person@6d06d69c

이전과 달리 person1의 주소는 여전히 '서울' 그대로이고 person2의 주소만 '부산'으로 변경됐다. 또한 두 객체가 서로 다른 주소값을 가지고 있는 것을 확인할 수 있다.

이렇게 깊은 복사(Deep Copy) 는 기존 객체의 데이터를 바탕으로 새로운 객체를 완전히 복제하여 생성하는 방식이다. 힙 메모리 상에 새로운 객체 인스턴스를 생성하고, 스택에는 해당 객체의 새로운 참조값이 저장된다. 따라서 하나의 객체를 수정해도, 다른 객체에는 전혀 영향을 주지 않는다.

깊은 복사는 같은 설계도를 가지고 새로 물체를 하나 더 만든 것이라고 생각하면 이해가 쉽다. 외형은 같지만, 물리적으로 완전히 다른 물체이기 때문에 하나를 바꾸더라도 다른 쪽에는 영향이 전혀 없다.

• 얕은 복사는 참조값만 복사해서 같은 객체를 공유하는 방식
• 깊은 복사는 새로운 객체를 생성해서 각자 독립된 객체로 관리하는 방식

차이를 이해하지 못하면 의도치 않게 객체가 공유되어 값이 바뀌는 문제가 발생할 수 있다.

결국 복사의 본질의, 객체 간의 독립성 에 대한 문제다.

참조값만 복사되면 하나를 바꾸면 둘 다 바뀌고, 객체 자체를 복사하면 각각 독립적으로 유지된다.

1. BigInteger란?

• Java에서 기본 제공하는 정수형 자료형(int, long)으로 표현할 수 없는 초대형 정수를 다룰 수 있는 클래스이다
• 메모리가 허용하는 한 무한대 크기의 정수를 저장할 수 있다
• 불변 객체(Immutable Object) 로 연산할 때도 기존 값이 변경되지 않고 새로운 BigInteger 객체가 생성된다
• double과 달리 정확한 정수 연산이 가능해 부동소수점 오차 가 없다
• +, -, *, / 같은 기본 연산자 대신 메서드로 연산 해야 한다

2. 사용 예시

import java.math.BigInteger;

public class Main {
    public static void main(String[] args) {
        BigInteger x = new BigInteger("123456789012345678901234567890");
        System.out.println(x); // 123456789012345678901234567890
    }
}

3. 연산 메서드

사용 예시

import java.math.BigInteger;

public class Main {
    public static void main(String[] args) {
        BigInteger num1 = new BigInteger("987654321987654321987654321");
        BigInteger num2 = new BigInteger("123456789123456789123456789");

        BigInteger sum = num1.add(num2);       // 덧셈
        BigInteger subtract = num1.subtract(num2); // 뺄셈
        BigInteger multiply = num1.multiply(num2); // 곱셈
        BigInteger divide = num1.divide(num2);  // 나눗셈
        BigInteger mod = num1.mod(num2);    // 나머지

        System.out.println("덧셈: " + sum);
        System.out.println("뺄셈: " + subtract);
        System.out.println("곱셈: " + multiply);
        System.out.println("나눗셈: " + divide);
        System.out.println("나머지: " + mod);
    }
}

4. 주요 메서드

✅ 요약

1. compareTo(BigInteger val)

BigInteger a = new BigInteger("100");
BigInteger b = new BigInteger("200");

int result = a.compareTo(b); // 결과: -1 (a < b)

설명 : a와 b를 비교하여 결과를 반환
시그니처 : public int compareTo(BigInteger val)
매개변수 : val - 비교할 BigInteger 값
사용 상황 : 두 수의 대소 비교가 필요할 때 (a < b, a > b, a == b 판단 가능)

2. gcd(BigInteger val)

BigInteger a = new BigInteger("48");
BigInteger b = new BigInteger("18");

BigInteger result = a.gcd(b); // 결과: 6

설명 : 두 수의 최대공약수(GCD, Greatest Common Divisor) 계산
시그니처 : public BigInteger gcd(BigInteger val)
매개변수 : val - 최대공약수를 구할 BigInteger 값
사용 상황 : 유클리드 호제법을 사용하여 최대공약수를 구할 때

3. mod(BigInteger m)

BigInteger a = new BigInteger("10");
BigInteger b = new BigInteger("3");

BigInteger result = a.mod(b); // 결과: 1

설명 : a를 b로 나눈 나머지를 반환
시그니처 : public BigInteger mod(BigInteger m)
매개변수 : m - 나눌 값
사용 상황 : 나머지 연산이 필요할 때 (예: 모듈러 연산, 암호학 등)

4. pow(int exponent)

BigInteger a = new BigInteger("2");

BigInteger result = a.pow(10); // 결과: 1024

설명 : a의 exponent 거듭제곱 계산
시그니처 : public BigInteger pow(int exponent)
매개변수 : exponent - 거듭제곱 할 지수
사용 상황 : 큰 수의 거듭제곱 연산이 필요할 때

5. isProbablePrime(int certainty)

BigInteger a = new BigInteger("17");

boolean isPrime = a.isProbablePrime(10); // 결과: true

설명 : 주어진 숫자가 소수인지 확률적으로 판별
시그니처 : public boolean isProbablePrime(int certainty)
매개변수 : certainty - 소수 판별 신뢰도 (값이 클수록 정확함)
사용 상황 : 암호학, 소수 판별 문제 등

6. toString(int radix)

BigInteger a = new BigInteger("255");

String binaryStr = a.toString(2); // 결과: "11111111"
String hexStr = a.toString(16);   // 결과: "ff"

설명 : BigInteger를 특정 진법(2진수, 16진수 등) 문자열로 변환
시그니처 : public String toString(int radix)
매개변수 : radix - 변환할 진법 (예: 2, 8, 16 등)
사용 상황 : 숫자를 이진수, 16진수 등으로 변환할 때

7. abs()

BigInteger a = new BigInteger("-100");

BigInteger absNum = a.abs(); // 결과: 100

설명 : BigInteger의 절댓값을 반환
시그니처 : public BigInteger abs()
매개변수 : 없음
사용 상황 : 음수를 양수로 변환할 때

8. negate()

BigInteger a = new BigInteger("100");

BigInteger negNum = a.negate(); // 결과: -100

설명 : BigInteger의 부호를 반전 (양수 → 음수, 음수 → 양수)
시그니처 : public BigInteger negate()
매개변수 : 없음
사용 상황 : 부호를 바꿔야 할 때

9. bitCount()

BigInteger a = new BigInteger("15"); // 1111 (2진수)

int count = a.bitCount(); // 결과: 4

설명 : BigInteger의 이진수 표현에서 1의 개수 반환
시그니처 : public int bitCount()
매개변수 : 없음
사용 상황 : 이진수 내 1의 개수를 셀 때 (비트마스킹 활용 가능)

‼️ 주의할 점

• 연산할 때마다 새로운 객체가 생성 됨 → 연산이 많으면 성능이 저하 될 수 있다
• 소수점 이 필요하면 BigDecimal을 사용해야 한다
• toString()을 사용하여 출력해야 제대로 된 값을 확인할 수 있다

Java는 초기부터 날짜와 시간을 다루는 다양한 API를 제공해왔다. 하지만 이런 API들은 사용하기에 여러 불편점과 문제점이 있었다. 이런 불편점들을 점차 보완한 뒤 Java 8부터 java.time 패키지가 도입되어 현대적인 날짜와 시간 처리가 가능해졌다 .

1. Java 8 이전의 API들

1.1 Java.util.Date

가장 먼저 등장한 클래스는 java.util.Date로 Java 1.0부터 도입되었다. 하지만 여러가지 단점이 존재했다.

• 가변 객체로 설계되어 멀티스레드 환경에서 안전하지 않다.
• 월(Month)이 0부터 시작하는 비직관적인 설계로 혼란을 유발할 수 있다.
• 시간대(Time Zone) 처리 기능이 부족하여 글로벌 애플리케이션 개발에 한계가 있다.

1.2 Java.util.Calendar

이러한 문제를 개선하기 위해 Java 1.1부터 도입된 java.util.Calendar 클래스는 다양한 캘린더 시스템을 지원하며, Date 클래스의 단점을 보완하려 했으나 여전히 몇 가지 단점이 남아있었다.

• 여전히 가변 객체로 설계되어 멀티스레드 환경에서 안전하지 않다.
• 복잡한 API 설계로 인해 사용하기 어려웠다.

2. Java 8 이후: java.time 패키지

Java 8에서는 이러한 문제를 해결하기 위해 java.time 패키지가 도입다. 이 패키지는 JSR-310 명세를 기반으로 설계되었으며, _Modern Date-Time API_로 불리며 현재 Java에서 날짜와 시간을 처리하는 표준으로 자리잡았다.

2.1 java.time 패키지의 주요 특징

1. 불변 객체와 Thread-Safe java.time의 모든 클래스는 불변(Immutable) 객체로 설계되어 멀티스레드 환경에서도 안전하게 사용할 수 있다.

2. 직관적이고 간단한 API 클래스와 메서드 이름이 직관적이어서 쉽게 이해하고 사용할 수 있다.

   • 예: LocalDate(날짜), LocalTime(시간), LocalDateTime(날짜와 시간), ZonedDateTime(시간대 포함).

3. 시간대(Time Zone) 지원 글로벌 애플리케이션 개발에 유용한 시간대 처리 기능을 제공한다. ZoneId와 ZonedDateTime 클래스를 통해 명확한 시간대 처리가 가능해졌다.

4. 편리한 날짜와 시간 계산 plusDays(), minusMonths() 과 같이 직관적인 메서드를 사용해 간단하게 날짜와 시간을 계산할 수 있게 되었다.

5. 포맷팅과 파싱 DateTimeFormatter 클래스를 사용하여 날짜와 시간을 간단하고 안전하게 포맷하거나 파싱할 수 있다.

6. 다양한 목적의 클래스 특정 목적에 맞는 클래스를 제공하여 더 명확하고 효과적인 코드를 작성할 수 있다.

   • LocalDate: 날짜만 필요할 때
   • LocalTime: 시간만 필요할 때
   • LocalDateTime: 날짜와 시간을 함께 다룰 때
   • Instant: UTC 기준 타임스탬프 표현

2.2 사용 예시

import java.time.*;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        // 현재 날짜와 시간
        LocalDate date = LocalDate.now();                 // 2024-11-19
        LocalTime time = LocalTime.now();                 // 21:53:07.250832
        LocalDateTime dateTime = LocalDateTime.now();    // 2024-11-19T21:53:07.250857

        // 날짜 계산
        LocalDate nextWeek = date.plusWeeks(1);
        System.out.println("오늘: " + date);            // 오늘: 2024-11-19
        System.out.println("1주 후: " + nextWeek);    // 1주 후: 2024-11-26

        // 포맷팅
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedDate = dateTime.format(formatter);
        System.out.println("formattedDate);    // 2024-11-19 21:53:07

        // 시간대 포함
        ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of("Asia/Seoul"));
        System.out.println("zonedDateTime); 
        // 2024-11-19T21:53:07.281712+09:00[Asia/Seoul]
    }
}

2.3 주요 클래스

2.4 주요 메서드

// 현재 날짜 및 시간 가져오기
LocalDate.now();        // 현재 날짜
LocalTime.now();        // 현재 시간
LocalDateTime.now();    // 현재 날짜와 시간
ZonedDateTime.now();    // 현재 날짜와 시간 (시간대 포함)

// 날짜 계산
LocalDate today = LocalDate.now();
today.plusDays(5);       // 5일 추가
today.minusMonths(1);    // 1개월 빼기

// 비교
LocalDate date1 = LocalDate.of(2023, 1, 1);
LocalDate date2 = LocalDate.of(2024, 1, 1);
boolean isBefore = date1.isBefore(date2); // true
boolean isAfter = date1.isAfter(date2);   // false

// 포맷팅
LocalDate date = LocalDate.now();
String formatted = date.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));

// 파싱
LocalDate parsedDate = LocalDate.parse("2024-01-01", DateTimeFormatter.ofPattern("yyyy-MM-dd"));

인프런 김영한 님의 스프링 입문 - 코드로 배우는 스프링 부트, 웹, MVC, DB 접근 기술 강의를 보고 정리한 내용입니다.

웹 개발은 크게 3가지 방식으로 볼 수 있다.

1. 정적 컨텐츠 (파일을 그대로 웹 브라우저에 전달)
2. MVC와 템플릿 엔진 (서버에서 변형을 해서 전달)
3. API (json 전달, 서버끼리 통신, …)

1. 정적 컨텐츠

• 스프링 부트는 정적 컨텐츠 기능을 자동으로 제공한다.
• 원하는 html을 추가하면 그대로 view로 출력된다.

정적 컨텐츠란 ?

• Spring.io 링크

• 스프링 부트는 기본적으로 /static(/public, /resources, /META-INF/resources) 경로로부터 정적 콘텐츠 기능을 제공한다.

• Spring MVC의 ResourceHttpRequestHandler를 사용하여 정적 리소스를 처리하고, ebMvcConfigurer를 추가해 addResourceHandlers 메서드를 오버라이드하여 동작을 수정할 수 있다.

• 독립 실행형 web application에서는 기본 서블릿이 활성화되어, 스프링이 요청을 처리하지 않을 경우 ServletContext 의 루트에서 콘텐츠를 제공하지만, 대부분의 경우 스프링이 DispatcherServlet을 통해 모든 요청을 처리한다.

• 기본적으로 정적 리소스는 /** 경로에 매핑되고, properties에 spring.mvc.static-path-pattern 속성을 사용해 경로를 지정할 수 있다.

    spring.mvc.static-path-pattern=/resources/**

• properties에 spring.resources.static-locations 속성을 사용해 정적 리소스 위치를 커스터마이징할 수 있다.

동작 환경 그림

1. 웹 브라우저에서 localhost:8080/hello-static.html 요청
2. 톰캣 서버가 이 요청을 받아 스프링 컨테이너로 전달
3. 스프링 컨테이너는 해당 요청에 대한 컨트롤러가 있는지 먼저 확인
4. 없을 경우, 스프링 부트가 resources/static 경로에서 hello-static.html 파일을 찾음
5. 파일이 존재하면 해당 정적 컨텐츠 반환

2. MVC와 템플릿 엔진

MVC: Model, View, Controller

• View: 화면을 그리는데 모든 역량을 집중
• Controller, Model: 비즈니스 로직, 내부적 처리에 집중

동작 환경 그림

1. 웹 브라우저에서 http://localhost:8080/hello-mvc?name=spring 요청
2. 톰캣 서버가 이 요청을 받아 스프링 컨테이너로 전달
3. 스프링 컨테이너는 해당 요청에 대한 컨트롤러가 있는지 확인 후 해당 요청에 대한 메서드 호출
4. 내부 메서드 실행
   1. @RequestParam 값이 있는지 확인(required = true가 기본값이라)
   2. 없을 경우, MissingServletRequestParameterException 반환
   3. Model에 RequestParam으로 받은 값 추가 후 반환
5. ViewResolver (뷰를 찾아주고 템플릿 엔진 연결) 스프링 부트가 resources/tempaltes 경로에서 return의 StringName(ViewName) 파일을 찾음
6. Thymeleaf 템플릿 엔진에게 처리 요청
7. Thymeleaf 템플릿 엔진이 렌더링 후 변환된 HTML을 웹 브라우저에 반환

3. API

@ResponseBody 문자 반환

@GetMapping("hello-string")
@ResponseBody // http body에 데이터를 직접 넣겠다
public String helloString(@RequestParam("name") String name) {
    return "hello " + name;
}

• @ResponseBody 를 사용하면 ViewResolver를 사용하지 않음

• 대신에 HTTP의 body에 문자 내용을 직접 반환(HTML body tag를 말하는 것이 아님)

• 실행 결과

  

@ResponseBody 객체 반환

@GetMapping("hello-api")
@ResponseBody
public Hello helloApi(@RequestParam("name") String name) {
    Hello hello = new Hello();
    hello.setName(name);
    return hello;
}
static class Hello {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

• @ResponseBody 를 사용하고, 객체를 반환하면 객체가 JSON으로 변환됨
• 실행 결과

동작 환경 그림

1. 웹 브라우저에서 http://localhost:8080/hello-api?name=spring 요청
2. 톰캣 서버가 이 요청을 받아 스프링 컨테이너로 전달
3. 스프링 컨테이너는 해당 요청에 대한 컨트롤러가 있는지 확인 후 해당 요청에 대한 메서드 호출
4. @ResponseBody Annotation을 확인
5. HttpMessageConverter가 작동
   1. 문자일 경우, StringConverter(StringHttpMessageConverter)가 return String Value 그대로
   2. 객체일 경우, JsonConverter(MappingJackson2HttpMessageConverter)가 객체를 json 형식의 데이터로 만듬
6. HTTP Body로 반환

• @ResponseBody 를 사용
  • HTTP의 BODY에 문자 내용을 직접 반환
  • viewResolver 대신에 HttpMessageConverter가 동작
  • 기본 문자처리: StringHttpMessageConverter
  • 기본 객체처리: MappingJackson2HttpMessageConverter
  • byte 처리 등등 기타 여러 HttpMessageConverter가 기본으로 등록되어 있음

💡 Jackson: 범용적으로 사용되는 객체 → json 스타일 변환 라이브러리

인프런 김영한 님의 스프링 입문 - 코드로 배우는 스프링 부트, 웹, MVC, DB 접근 기술 강의를 보고 정리한 내용입니다.

1. 프로젝트 생성

프로젝트 생성

1. Java 설치 필수 → oracle jdk (원하는 버전) 검색 후 다운로드

2. 스프링 부트 스타터 사이트에서 스프링 프로젝트 생성

   • https://start.spring.io
   • 스프링에서 운영하는 스프링 부트 기반으로 스프링 관련 프로젝트를 생성해주는 사이트

3. 프로젝트 선택

   • Gradle(요즘 추세, 스프링 라이브러리 관리 자체도 넘어오는 추세)
   • Java
   • Spring Boot Version
     • 원하는 버전 선택 (SNAPSHOT이 아닌 제일 최근 버전)
   • Project Metadata
     • Group : 기업명, 기업 도메인 명
     • Artifact : build 나올 때 결과물, 프로젝트 명
     • Name
     • Description
     • Package name
   • Dependencies
     • Spring Web
     • Thymeleaf : html을 만들어주는 템플릿 엔진

4. 다운로드 → intellij open → 다운로드 한 파일의 build.gradle 선택 → open as project

💡 gradle build가 안될 때

1. ⌘; (File → Project structure) Project의 SDK 버전 다운로드 받은 파일의 버전과 같이 변경
2. ⌘, (Intellij → Settings → Build, Execution, Deployment → Build tools → Gradle) gradle JVM 버전 다운로드 받은 파일의 버전과 같이 변경

프로젝트 구조

• .idea (intellij가 사용하는 설정 파일)

• gradle (gradle 관련 파일)

• src

  • main

    • java
    • resources (실제 Java 코드 파일을 제외한 xml이나 propertices 설정 파일, html …)

  • test (테스트 코드들)

  • build.gradle (gradle 설정 파일, 버전 설정하고 라이브러리 땡겨오기)

      plugins {  // 버전 관련
          id 'java'
          id 'org.springframework.boot' version '3.3.5'
          id 'io.spring.dependency-management' version '1.1.6'
      }
    
      group = 'hello'
      version = '0.0.1-SNAPSHOT'
    
      java { // java 버전
          toolchain {
              languageVersion = JavaLanguageVersion.of(17)
          }
      }
    
      repositories { // 라이브러리를 여기서 다운받아라 라고 설정해두는,,
          mavenCentral()
      }
    
      dependencies { //라이브러리
          implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
          implementation 'org.springframework.boot:spring-boot-starter-web'
          testImplementation 'org.springframework.boot:spring-boot-starter-test'
          testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
      }
    
      tasks.named('test') {
          useJUnitPlatform()
      }
    

  • .gitignore (git에 올라가면 안되는 파일 관리)

  • gradlew

  • gradlew.bat

  • settings.gradle

2. 라이브러리 환경 살펴보기

라이브러리 살펴보기

• Gradle이 프로젝트를 시작할 때 선택한 라이브러리와 의존 관계가 있는 라이브러리를 함께 다운로드 한다.
• Intellij의 왼쪽 Gradle 버튼을 클릭하면 라이브러리 간의 의존 관계로 함께 당겨와진 라이브러리들을 확인할 수 있다.

주요 라이브러리

스프링 부트 라이브러리

• spring-boot-starter-web
  • spring-boot-starter-tomcat: 톰캣(웹 서버)
  • spring-webmvc: 스프링 웹 MVC
• spring-boot-starter-thymeleaf: 타임리프 템플릿 엔진(View)
• spring-boot-starter(공통): 스프링 부트 + 스프링 코어 + 로깅
  • spring-boot
    • spring-core
  • spring-boot-starter-logging
    • slf4j, logback

테스트 라이브러리

• spring-boot-starter-test
  • junit: 테스트 프레임워크
  • mockito: 목 라이브러리
  • assertj: 테스트 코드를 좀 더 편하게 작성하게 도와주는 라이브러리
  • spring-test: 스프링 통합 테스트 지원

3. View 환경 설정

Welcome Page 만들기

1. 정적 페이지

• resources/static 경로에 index.html 생성
  • 홈 화면(Welcome 페이지)가 된다.

• 스프링 부트가 제공하는 Welcome Page 기능 → Spring.io Welcome Page 설명
  • static/index.html 을 올려두면 Welcome page 기능을 제공한다.
  • Spring Boot는 정적 및 템플릿 기반의 Welcome Page를 지원한다.
    1. Spring Boot는 먼저 index.html 파일을 미리 설정된 위치 (resources/static)에서 찾는다.
    2. 만약 정적 페이지를 찾지 못하면, 템플릿 엔진(Thymeleaf, Mustache 등)이 사용할 수 있는 index 템플릿을 찾는다.
  • 이 중 하나라도 찾게 되면, 해당 파일이 Application의 Welcome Page로 설정된다.

💡 Welcome Page는 Application에 실제로 index 의 경로가 정의되어 있지 않을 경우에만 동작한다. → Application이 index 라는 경로에 (ex: /index, /)에 대한 명시적인 라우트(route)를 가지고 있다면, 그 라우트가 우선 사용된다. 없을 경우 index.html 파일이나 index 템플릿을 찾아 Welcome Page로 사용한다.

2. thymleaf 템플릿 엔진

thymeleaf 공식 사이트: https://www.thymeleaf.org/ 스프링 공식 튜토리얼: https://spring.io/guides/gs/serving-web-content/ 스프링부트 메뉴얼: https://docs.spring.io/spring-boot/docs/2.3.1.RELEASE/reference/html/spring-boot-features.html#boot-features-spring-mvc-template-engines

특징

• Thymeleaf는 자바 기반의 server-side 템플릿 엔진으로, HTML, XML, JavaScript, CSS 등의 파일을 서버에서 동적으로 생성하여 클라이언트에 전송할 수 있게 도와준다.
• 주로 Spring Boot와 함께 사용되며, HTML 파일을 템플릿으로 사용하여 데이터 바인딩, 루프 처리, 조건부 렌더링 등을 쉽게 처리할 수 있다.

주요 개념

1. 템플릿 엔진: HTML 문서에서 동적으로 데이터를 삽입하고, 반복 처리나 조건문을 적용할 수 있게 해주는 엔진이다.
2. 스프링과의 통합: Thymeleaf는 Spring MVC와 통합되어, Model 객체에 담긴 데이터를 템플릿으로 쉽게 전달할 수 있다 (Spring Boot에서는 기본 템플릿 엔진으로 Thymeleaf가 설정되어 있어 쉽게 사용할 수 있음)
3. 표현식:
   • ${}: 모델에 있는 데이터를 출력할 때 사용 (예: <span>${user.name}</span>).
   • th:if, th:each: 조건문과 반복문을 HTML 안에서 처리할 수 있게 해줌 (예: <li th:each="item : ${items}">${item.name}</li>).

동작 환경 그림

1. Spring Boot는 내장 톰캣 서버를 포함하고 있다.
   • Spring Boot 애플리케이션을 실행하면, 내장된 톰캣 서버가 함께 시작되어 HTTP 요청을 수신하고 처리할 수 있다.
2. 웹 브라우저에서 localhost:8080/hello 입력
   • 사용자가 브라우저를 통해 http://localhost:8080/hello로 접근하면 해당 요청이 애플리케이션으로 전달된다.
3. 요청이 톰캣 서버로 전달됨
   • 내장 톰캣 서버가 이 요청을 받고, 스프링 컨테이너에 요청을 전달한다.
4. 스프링 컨테이너가 /hello 경로에 매핑된 메서드가 있는지 확인
5. 매핑된 메서드 실행
   • 모델 생성: 메서드 내에서 Model 객체가 생성된다.
   • 모델에 데이터 추가 (addAttribute)
   • ViewName 반환 (return): 메서드는 "hello"라는 View 이름을 반환한다. Spring Boot는 이 이름을 사용해 특정 HTML 파일을 찾는다.
6. ViewResolver가 View를 찾아 렌더링
   • 기본적으로 Spring Boot는 resources/templates 경로의 ViewName을 찾아서 렌더링 한다.
   • resources:templates/ + {ViewName} + .html

1. append(String str)

StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" World");
// sb = Hello World

설명 : 문자열의 끝에 문자열 추가

시그니처 : public StringBuilder append(String str)

매개변수 : str - 추가할 문자열

사용 상황 : 여러 문자열을 하나로 합치거나, 문자열의 끝에 새로운 문자열을 추가하고 싶을 때 사용

2. insert(int offset, String str)

StringBuilder sb = new StringBuilder("Hello");
sb.insert(5, " World");
// sb = Hello World

설명 : 특정 위치에 문자열 삽입

시그니처 : public StringBuilder insert(int offset, String str)

매개변수 : offset - 삽입할 위치의 인덱스, str - 삽입할 문자열

사용 상황 : 특정 위치에 문자열을 삽입해야 할 때 사용

3. delete(int start, int end)

StringBuilder sb = new StringBuilder("Hello World");
sb.delete(5, 11);
// sb = Hello

설명 : 시작 인덱스에서 끝 인덱스 전까지의 문자열 삭제

시그니처 : public StringBuilder delete(int start, int end)

매개변수 : start - 시작 인덱스(포함), end - 끝 인덱스(포함 X)

사용 상황 : 특정 범위의 문자열을 제거할 때 사용

4. deleteCharAt(int index)

StringBuilder sb = new StringBuilder("Hello World");
sb.deleteCharAt(5);
// sb = HelloWorld

설명 : 특정 위치의 문자를 삭제

시그니처 : public StringBuilder deleteCharAt(int index)

매개변수 : index - 삭제할 위치의 인덱스

사용 상황 : 특정 위치의 문자를 삭제할 때 사용

5. replace(int start, int end, String str)

StringBuilder sb = new StringBuilder("Hello World");
sb.replace(6, 11, "Java");
// sb = Hello Java

설명 : 시작 인덱스에서 끝 인덱스까지의 문자열을 원하는 문자열로 대체

시그니처 : public StringBuilder replace(int start, int end, String str)

매개변수 : start - 시작 인덱스(포함), end - 끝 인덱스(포함 X), str - 대체할 문자열

사용 상황 : 특정 범위의 문자열을 다른 문자열로 교체할 때 사용

6. reverse()

StringBuilder sb = new StringBuilder("Hello");
sb.reverse();
// sb = olleH

설명 : 문자열을 역순으로 변경

시그니처 : public StringBuilder reverse()

사용 상황 : 문자열을 뒤집어야 할 때 사용

7. setCharAt(int index, char ch)

StringBuilder sb = new StringBuilder("Hello");
sb.setCharAt(1, 'a');
// sb = Hallo

설명 : 특정 인덱스의 문자를 원하는 문자로 변경

시그니처 : public void setCharAt(int index, char ch)

매개변수 : index - 변경할 문자의 인덱스, ch - 새로 설정할 문자

사용 상황 : 특정 위치의 문자를 다른 문자로 교체할 때 사용

8. charAt(int index)

StringBuilder sb = new StringBuilder("Hello");
char ch = sb.charAt(1);
// ch = e

설명 : 특정 인덱스의 문자 반환

시그니처 : public char charAt(int index)

매개변수 : index - 반환할 문자의 인덱스

사용 상황 : 특정 위치의 문자를 확인할 때 사용

9. substring(int start, int end)

StringBuilder sb = new StringBuilder("Hello World");
String sub = sb.substring(0, 5);
// sub = Hello

설명 : 시작 인덱스에서 끝 인덱스 전까지의 부분 문자열 반환

시그니처 : public String substring(int start, int end)

매개변수 : start - 시작 인덱스(포함), end - 끝 인덱스(포함 X)

사용 상황 : 특정 범위의 문자열을 추출할 때 사용

10. toString()

StringBuilder sb = new StringBuilder("Hello");
String str = sb.toString();
// str = Hello

설명 :  StringBuilder 객체를 String으로 변환

시그니처 : public String toString()

사용 상황 : 최종 문자열을 얻을 때 사용

문자열을 조작할 때 특히 알고리즘을 풀이하며 반복하여 문자열을 계속 추가해야 하는 경우나 문자열에서 삽입, 삭제, 변경 등의 작업이 자주 발생하는 경우 불변 객체인 String을 사용하여 새로운 문자열을 계속 생성하는 것보다 내부 배열을 직접 수정하는 StringBuilder를 사용해 성능을 향상시킬 수 있다.

String[] split(String regex) : regex 구분자를 기준으로 문자열을 분할 (limit = 0 과 같이 작동), 분리된 문자열은 배열로 반환

String[] split(String regex, int limit) : regex 구분자를 기준으로 문자열을 분할(= 패턴), 분리된 문자열은 배열로 반환

• limit < 0 : 패턴이 가능한 한 많이 적용, 마지막 패턴 뒤 빈 문자열이 있다면 결과 배열에 포함

• limit = 0 : 패턴이 가능한 한 많이 적용, 마지막 패턴 뒤 빈 문자열이 있어도 결과 배열에 포함되지 않음

• limit > 0 : 패턴이 최대 limit - 1번 적용되고, 결과 배열의 최대 길이는 limit

split(String regex) vs split(String regex, int limit)

문자열을 기준 문자로 분리하려고 할 때 split() 메소드를 자주 사용하게 된다.

java 공식문서에 따르면 split 메소드는 regex만 인자로 가지는 메소드와 regex, limit 두 가지를 인자로 가지는 메소드로 나뉘어져 있다.

좀 더 자세히 알아보자

java 공식문서의 split 메소드에 대한 설명이다.

두번째 줄에 "이 메소드는 주어진 표현식(regex)과 limit 인수로 0을 사용하는 두 인자를 받는 split 메소드를 호출 한 것처럼 동작합니다." 라는 문장이 있다.

limit 인자를 신경쓰지 않고 사용해왔는데 내부적으로 limit의 인수로 0이 들어간 것처럼 작동되고 있던 것이다.

두 가지 인자를 가진 split 메소드는 regex (주어진 정규 표현식)와 일치하는 부분을 기준으로 문자열을 분리해 배열로 반환하며, limit 는 _regex와 일치하는 부분을 기준으로 문자열을 분리하는 패턴이 적용되는 횟수를 제어하는 매개변수_로 배열의 길이를 조절하는데 사용 된다.

1. limit > 0

String str = "one,two,three,four";
String[] result = str.split(",", 3);
// result = {"one", "two", "three,four"}

limit가 양수, 0 이상일 때는 최대 limit - 1 번 만큼 regex 구분자를 사용하여 문자열을 분리한다.

결과 배열의 길이는 최대 limit 이고, 배열의 마지막 요소는 마지막 구분자 이후의 모든 문자열 이 된다.

2. limit == 0

String str = "one,two,,three,";
String[] result = str.split(",", 0);
// result = {"one", "two", "", "three"}

limit가 0일 때는 그동안 사용해왔던 split() 메소드 와 같이 동작한다.

패턴이 가능한 한 많이 적용되며 배열의 최대 길이도 제한이 없지만 분리하려는 문자열의 끝에 빈 문자열이 있을 경우 제거 된다.

3. limit < 0

String str = "one,two,,three,";
String[] result = str.split(",", -1);
// result = {"one", "two", "", "three", ""}

limit가 음수일 때도 0일 때와 마찬가지로 패턴이 가능한 한 많이 적용되며 배열의 최대 길이 제한도 없지만

0일때와 다른 점은 빈 문자열도 결과 배열에 포함 된다는 것이다

마지막 빈 문자열도 결과 배열 안에 포함하고 싶을 때 사용할 수 있다

Java에서 배열을 복사하는 방법에는 여러가지가 있다. 각 방법들의 장단점과 사용법, 쓰이는 상황에 대해 알아보자.

1. Arrays.copyOfRange

int[] originalArray = {1, 2, 3, 4, 5};
int[] copiedArray = Arrays.copyOfRange(originalArray, 1, 4);
// copiedArray는 {2, 3, 4}를 포함

메서드 시그니처: Arrays.copyOfRange(T[] original, int from, int to) 사용법: Arrays.copyOfRange(원본 배열, 시작 인덱스, 종료 인덱스)

Arrays.copyOfRange()는 내부적으로 System.arraycopy() 메소드를 사용해 기본적으로 복사 성능이 빠르다. 하지만 내부적으로 범위 검사와 길이 계산으로 인해 약간의 오버헤드가 발생한다.  원본 배열의 시작 인덱스부터 종료 인덱스-1 까지 범위를 복사하여 새로운 배열을 만드는 메소드로 배열의 특정 범위를 복사하거나 자를 때 유용하다. 종료 인덱스가 복사된 배열에 포함되지 않으므로 범위 사용에 주의가 필요하다 !

2. Arrays.copyOf

int[] originalArray = {1, 2, 3, 4, 5};
int[] copiedArray = Arrays.copyOf(originalArray, 3);
// copiedArray는 {1, 2, 3}을 포함

메서드 시그니처: Arrays.copyOf(T[] original, int newLength) 사용법: Arrays.copyOf(원본 배열, 복사할 길이)

Arrays.copyOf()도 Arrays.copyOfRange()와 마찬가지로 내부적으로 System.arraycopy() 메소드를 사용해 성능이 빠르다. 내부적으로 길이를 검사하는 로직으로 인해 약간의 오버헤드가 발생한다. 원본 배열을 복사할 길이 만큼 복사한 새로운 배열을 만드는 메소드로 배열의 처음부터 일정길이만큼 복사하거나 자를 때 유용하다.

3. System.arraycopy

int[] originalArray = {1, 2, 3, 4, 5};
int[] copiedArray = new int[3];
System.arraycopy(originalArray, 1, copiedArray, 0, 3);
// copiedArray는 {2, 3, 4}를 포함

메서드 시그니처: System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 사용법: System.arraycopy(원본 배열, 원본 시작 인덱스, 복사 배열, 복사 시작 인덱스, 복사할 길이)

System.arraycopy()는 네이티브 메소드 호출로 인해 배열 복사 시 성능적으로 가장 뛰어나다. 원본 배열의 시작 인덱스부터 복사할 길이만큼을 복사 배열의 복사 시작 인덱스에 복사하는 메소드로 사용법이 다른 메소드들과 비교해 다소 복잡하게 느껴질 수 있다. 원본 배열과 복사 배열의 타입이 호환되지 않거나 타입 변환이 불가능 한 경우, 복사할 인덱스의 길이가 배열의 크기를 초과하는 경우와 같이 잘못된 사용으로 인해 여러가지 예외가 발생할 수 있어 주의해야 한다.

Arrays.copyOfRange()와 Arrays.copyOf()의 내부 코드를 살펴보면 내부적으로 System.arraycopy()를 사용하고 있다.

public static int[] copyOfRange(int[] original, int from, int to) {
    int newLength = to - from;
    if (newLength < 0)
        throw new IllegalArgumentException(from + " > " + to);
    int[] copy = new int[newLength];
    System.arraycopy(original, from, copy, 0,
                     Math.min(original.length - from, newLength));
    return copy;
}

public static int[] copyOf(int[] original, int newLength) {
    int[] copy = new int[newLength];
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

때문에 기본적인 복사 성능은 거의 동일하지만, Arrays.copyOfRange()는 범위 검사와 길이 계산에서의 추가 로직이, Arrays.copyOf()는 길이 체크에서의 추가 로직으로 인해 System.arraycopy()보다 약간의 오버헤드가 있을 수 있다.

4. ArrayList 생성

int[] originalArray = {1, 2, 3, 4, 5};
List<Integer> list = new ArrayList<>();
for (int i = 1; i < 4; i++) {
    list.add(originalArray[i]);
}
Integer[] copiedArray = list.toArray(new Integer[0]);
// copiedArray는 {2, 3, 4}를 포함

사용법:   ArrayList를 생성하여 add()를 통해 요소를 추가한 후 toArray()로 배열로 변환

ArrayList를 사용하는 경우 동적으로 배열의 크기를 조절할 수 있어 배열의 크기가 정해지지 않은 경우 사용하기에 좋고, 리스트 작업이 필요한 경우 유용하다. 다만 오토박싱과 언박싱으로 인한 오버헤드와 배열에 비해 느려 대량의 데이터를 처리할 때 성능 저하가 발생할 수 있으므로 주의하자.

5. Stream 사용 (Java 8 이상)

int[] originalArray = {1, 2, 3, 4, 5};
int[] copiedArray = Arrays.stream(originalArray, 1, 4).toArray();
// copiedArray는 {2, 3, 4}를 포함

사용법: Arrays.stream(원본 배열, 시작 인덱스, 종료 인덱스).toArray()

Arrays.stream()은 Java 8부터 제공되는 Stream을 사용해 원본 배열의 시작 인덱스부터 종료 인덱스-1 까지 범위를 복사하여 새로운 배열을 만드는 메소드다. 스트림을 사용해서 병렬 처리 등 다양한 스트림 기능들을 사용할 수 있다. 스트림에 익숙한 사람이라면 코드를 짧고 간결하게 작성하며 사용할 수 있겠지만, 익숙하지 않으면 사용하고 이해하는데 어려움을 겪을 수 있으며 성능적으로도 배열 복사보다 떨어질 수 있다.

6. for문 사용(수동 복사)

int[] originalArray = {1, 2, 3, 4, 5};
int[] copiedArray = new int[3];
for (int i = 1; i < 4; i++) {
    copiedArray[i - 1] = originalArray[i];
}
// copiedArray는 {2, 3, 4}를 포함

사용법: for 루프를 사용하여 원본 배열에서 원하는 범위를 복사

가장 간단하고 원시적인 방법으로 for문을 사용해 복사하면 특정 로직을 추가하기 쉬워 유연성이 높은 코드를 작성할 수 있다. 직접 복사로 인해 성능도 준수한 편이다. 다만 코드가 길어지고 복잡해질 수 있으며 인덱스를 직접 관리해야하니 주의하자.

인터프리터 언어(Interpreter Language) : 소스 코드를 한 줄씩 읽고, 즉시 실행하는 언어 컴파일 언어(Compiled Language) : 소스 코드를 실행하기 전에 한 번에 기계어로 컴파일하여 실행 파일을 생성하는 언어  

인터프리터 언어

인터프리터(Interpreter) 가 프로그램이 실행될 때 소스 코드를 한 줄씩 읽고 해석하여 즉시 실행하는 언어다. 대표적인 언어로는 파이썬(Python), 자바스크립트(JavaScript), 루비(Ruby) 가 있다.  

특징

1. 소스 코드를 한 줄씩 읽고 해석하며 실행하므로 별도의 컴파일 과정 없이 즉시 실행할 수 있다. 빠른 프로토타이핑과 테스트가 가능하다. API 엔드포인트를 빠르게 수정하고 결과를 즉시 확인할 수 있다.
2. 오류 발생 시 해당 줄에서 멈추기 때문에, 디버깅에 용이하다. 런타임 에러 발생 시 스택 트레이스를 통한 트러블 슈팅에 용이하다.
3. 프로그램을 실행할 때마다 소스 코드를 해석해야 해서 실행 속도가 비교적 느리다. 요청 처리 속도가 중요한 경우, 성능상 불리하다.  

   컴파일 언어

   소스 코드를 실행하기 전 한 번에 기계어로 컴파일하여 실행 파일을 생성하는 언어이다. 대표적인 언어로는 C, C++, 자바(Java) 등이 있다.  

   특징

4. 소스 코드가 기계어로 컴파일 된 실행 파일로 실행하므로, 실행 속도가 빠르다. 높은 성능을 요구하는 애플리케이션에 적합하다. ex) 고속 트랜잭션 처리, 실시간 데이터 처리
5. 코드 수정 후 새로 실행할 때, 수정된 코드를 새로 컴파일 하는 과정이 필요하다. 개발 속도가 느려질 수 있다.
6. 컴파일 시 모든 코드를 한 번에 처리하기 때문에, 컴파일 과정에서 오류를 미리 발견할 수 있다. 타입 안정성과 컴파일 시점의 오류 검출로, 런타임 오류를 줄일 수 있다.  

   인터프리터 언어 vs 컴파일 언어

range(시작 인덱스, 종료 인덱스) → 시작 인덱스부터 종료 인덱스 - 1 까지 rangeClosed(시작 인덱스, 종료 인덱스) → 시작 인덱스 부터 종료 인덱스 까지 (end_index 포함)  

예시 및 출력

int[] array1 = IntStream.range(0, 6)
        .toArray();

int[] array2 = IntStream.rangeClosed(0, 6)
        .toArray();
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 3, 4, 5, 6]

내부 코드

public static IntStream range(int startInclusive, int endExclusive) {
    if (startInclusive >= endExclusive) {
        return empty();
    } else {
        return StreamSupport.intStream(
                new Streams.RangeIntSpliterator(startInclusive, endExclusive, false), false);
    }
}

public static IntStream rangeClosed(int startInclusive, int endInclusive) {
    if (startInclusive > endInclusive) {
        return empty();
    } else {
        return StreamSupport.intStream(
                new Streams.RangeIntSpliterator(startInclusive, endInclusive, true), false);
    }
}