26. 라이브러리(Library)

1. 자바 라이브러리(Java Library)

1️⃣ 자바 라이브러리란?

“자주 쓰는 기능을 이미 구현해 둔 코드 묶음”

• 문자열 처리

• 날짜 계산

• 파일 입출력

• 네트워크 통신

2️⃣ JDK, JRE, 자바 라이브러리 관계

1) 구성 관계

JDK
 ├─ JRE
 │   ├─ JVM
 │   └─ Java Standard Library

2) 정리

• JDK : 개발 도구 + 라이브러리

• JRE : 실행 환경 + 라이브러리

• Java Standard Library : 자바 기본 라이브러리

3️⃣ 자바 표준 라이브러리(Standard Library)

1) 특징

• java.lang, java.util 같은 패키지

• 별도 설치 ❌

• import 해서 바로 사용 가능

4️⃣ 주요 패키지별 설명 ⭐

1) java.lang

String s = "hello";
int n = Integer.parseInt("10");

2) java.util

List<String> list = new ArrayList<>();
Map<String, Integer> map = new HashMap<>();

3) java.io

BufferedReader br = new BufferedReader(new FileReader("a.txt"));

4) java.time (Java 8+)

LocalDate today = LocalDate.now();

5) java.net

6) java.sql

5️⃣ import란?

import java.util.ArrayList;

import java.util.*;

6️⃣ 외부 라이브러리 (Third-party Library)

1) 예시

7️⃣ 라이브러리 관리 방법

1) Maven / Gradle

• 의존성 관리 도구

• 라이브러리 자동 다운로드

<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
  <version>2.10</version>
</dependency>

8️⃣ 라이브러리 vs 프레임워크

2. euqals() 메소드

1️⃣ equals() 메소드란?

1) 개념

public boolean equals(Object obj)

2) 목적

“이 객체와 다른 객체가 같은 의미의 객체인가?”

2️⃣ == 와 equals()의 차이 (핵심 ⭐)

1) == 연산자

• 참조(주소) 비교

• 두 변수가 같은 객체를 가리키는지 확인

String a = new String("hello");
String b = new String("hello");

System.out.println(a == b);  // false

2) equals() 메소드

• 내용(논리적 동등성) 비교

• 클래스가 정의한 기준으로 같으면 true

System.out.println(a.equals(b));  // true

3️⃣ Object 클래스의 기본 equals()

public boolean equals(Object obj) {
		return (this == obj);
}

4️⃣ String의 equals() (대표적인 예)

String s1 = "java";
String s2 = "java";

System.out.println(s1.equals(s2));  // true

5️⃣ 교재 실습

1) == 연산자

package ex08;

class Circle{
    int radius;
    public Circle(int radius){
        this.radius = radius;
    }
}

public class CircleTest2 {
    public static void main(String[] args) {
        Circle obj1 = new Circle(10);
        Circle obj2 = new Circle(10);

        if(obj1 == obj2){
            System.out.println("2개의 원은 같습니다.");
        } else {
            System.out.println("2개의 원은 같지 않습니다.");
        }
    }
}

2) equals() 메소드

package ex08;

class Circle3{
    int radius;
    public Circle3(int radius){
        this.radius = radius;
    }
    public boolean equals(Circle3 c1){
        if(radius == c1.radius) {
            return true;
        } else {
            return false;
        }
    }
}

public class CircleTest3 {
    public static void main(String[] args) {
        Circle3 obj1 = new Circle3(10);
        Circle3 obj2 = new Circle3(10);

        if(obj1.equals(obj2)){
            System.out.println("2개의 원은 같습니다.");
        } else {
            System.out.println("2개의 원은 같지 않습니다.");
        }
    }
}

3. 랩퍼 클래스(Wrapper Class)

1️⃣ 랩퍼 클래스란?

2️⃣ 랩퍼 클래스의 필요성

1) 기본형의 한계

• 객체가 아님

• 메소드 없음

• null 불가능

• 제네릭 사용 불가

List<int> list;  // 컴파일 에러 ❌

2) ✅ 랩퍼 클래스의 장점

• 객체로 사용 가능

• 메소드 제공

• null 가능

• 컬렉션, 제네릭 사용 가능

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

3️⃣ 랩퍼 클래스 생성 방법

1) 생성자 (비권장 ❌)

Integer a = new Integer(10);  // deprecated

2) valueOf() (권장 ✅)

Integer a = Integer.valueOf(10);

3) 오토 박싱 (Auto Boxing)

Integer a = 10;  // int → Integer 자동 변환

4️⃣ 언박싱(Unboxing)

Integer a = 10;
int b = a;       // 자동 언박싱

5️⃣ 랩퍼 클래스의 주요 메소드

1) 문자열 → 숫자 변환

int n = Integer.parseInt("123");

2) 타입 정보

Integer.MAX_VALUE;
Integer.MIN_VALUE;

3) 비교

Integer a = 100;
Integer b = 100;

System.out.println(a.equals(b));  // true

Integer a = 100;
Integer b = 100;
System.out.println(a == b);  // true (캐시 때문)

Integer x = 200;
Integer y = 200;
System.out.println(x == y);  // false

6️⃣ Integer 캐시 (중요 ⭐)

• 128 ~ 127 범위의 Integer 객체를 캐싱함

Integer a = 127;
Integer b = 127;   // 같은 객체

Integer a = 128;
Integer b = 128;  // 다른 객체

7️⃣ null과 언박싱 주의 ⚠️

Integer a = null;
int b = a;        // NullPointerException ❌

8️⃣ 랩퍼 클래스와 equals()

Integer a = 10;
Integer b = 10;

a.equals(b);     // true

9️⃣ 언제 랩퍼 클래스를 써야 할까?

• 컬렉션 (List, Map)

• 제네릭

• null 표현 필요할 때

• 값 비교(equals)

• DB 값 매핑

4. String 클래스

1️⃣ String 클래스란?

String s="hello";

String은 객체이고, 불변(immutable)이다

2️⃣ String은 객체다

String a = "java";               // 많이 사용되는 방법
String b = new String("java");   // 원칙

• 둘 다 String 객체

• == 비교하면 결과 다름 → 올바르지 않은 방법!

a == b;       // false
a.equals(b);  // true

3️⃣ String 불변성(Immutable) ⭐⭐⭐

1) 의미

한 번 만들어진 String 객체의 값은 절대 바뀌지 않는다

String s = "hello";
s = s + " world";

2) 실제로 일어나는 일

"hello"        → 기존 객체
"hello world"  → 새 객체 생성

4️⃣ String 주요 메소드 ⭐

1) 길이

String s = "Hello World!";  // 객체 생성
s.length();                 // 12가 반환됨

2) 문자 추출

String s = "Hello World!";  // 객체 생성
s.charAt(0);                // 'H'가 반환됨

3) 부분 문자열

String s = "Hello World!";  // 객체 생성
s.substring(0,3);           // 'hel'이 반환됨

• substring(int beginIndex, int endIndex)
➡️ beginIndex : 시작 인덱스 번호 (포함)
➡️ endIndex : 끝 인덱스 번호 (미포함)

4) 비교

s.equals("abc");             / == 연산자는 올바르지 않은 방법
s.equalsIgnoreCase("ABC");

5) 검색

s.contains("he");  // 단어의 포함 여부를 true/false로 반환
s.indexOf("l");    // 단어의 시작 위치 반환

6) 변환

s.toUpperCase();
s.toLowerCase();
s.trim();
s.replace("a","b");

7) 분리

String[] tokens = "I am a boy".split(" ");
for (String token : tokens)
	System.out.println(token);

I
am
a
boy.

7️⃣ String + 연산의 함정 ⚠️

Strings = "";
for (int i=0; i < 10000; i++) {
    s += i;
}

문제

• 반복할 때마다 새 String 객체 생성

• 성능 저하 + 메모리 낭비

해결책 : StringBuilder / StringBuffer

StringBuilder sb = new StringBuilder();
for (int i=0; i < 10000; i++) {
    sb.append(i);
}
String result = sb.toString();

8️⃣ StringBuffer

1) StringBuffer 란?

StringBuffer sb = new StringBuffer("hello");
sb.append(" world");
System.out.println(sb);  // hello world

2) StringBuffer가 필요한 이유

• String은 불변(immutable)
→ 문자열을 바꿀 때마다 새 객체 생성 ❌

• StringBuffer는 같은 객체 안에서 문자열 수정 가능 ⭕

3) 핵심 특징 3가지 ⭐

sb.append("!");
sb.insert(0,"Hi ");

• 내부 메소드에 synchronized 적용

• 멀티스레드 환경에서 안전

4) 자주 쓰는 메소드

sb.append("a");// 추가
sb.insert(1,"b");// 삽입
sb.delete(0,1);// 삭제
sb.reverse();// 뒤집기
sb.toString();// String 변환

5) 언제 쓰면 될까?

• 멀티스레드 환경에서 문자열 수정

• 동기화가 꼭 필요할 때

5. 기타 유용한 클래스

1️⃣ Math 클래스

1) Math 클래스란?

inta= Math.abs(-10);  // -10의 절댓값 = 10

2) 주요 특징

doubler= Math.sqrt(16);  // 결과: 4.0

3) 자주 쓰는 메서드

Math.abs(-5);     // 5
Math.max(3,10);   // 10
Math.min(3,10);   // 3

Math.pow(2,3);   // 8.0
Math.sqrt(25);   // 5.0
Math.exp(1);     // e ≈ 2.718
Math.log(10);    // 자연로그 ln(10)

Math.round(3.6);   // 4    -> 반올림
Math.floor(3.6);   // 3.0  -> 내림
Math.ceil(3.1);    // 4.0  -> 올림

doubler = Math.random();                // 0.0 <= r < 1.0
intdice = (int)(Math.random() *6) +1;   // 1~6 주사위

Math.sin(Math.PI /2);   // 1.0
Math.cos(0);            // 1.0
Math.tan(Math.PI /4);   // 1.0

4) Math 클래스의 상수

Math.PI   // 원주율 3.141592...
Math.E    // 자연상수 2.718281...

5) 한계 및 팁

• Math.random()은 단순한 난수 → 시드 제어 어렵고 예측 가능
→ 필요하면 Random, 예측 불가 난수는 SecureRandom 사용

• 고정밀 계산 필요 시 BigDecimal 활용

6) 정리

2️⃣ Random 클래스

1) Random 클래스란?

Random rand = new Random();

2) 주요 특징

Random r1 = new Random(100);
Random r2 = new Random(100);

// r1과 r2는 같은 순서의 난수를 생성

3) 자주 쓰는 메서드

rand.nextInt();     // int 전체 범위 (-2^31 ~ 2^31-1)
rand.nextInt(10);   // 0 ~ 9

int dice = rand.nextInt(6) +1;   // 1~6

rand.nextDouble();  // 0.0 <= < 1.0
rand.nextFloat();   // 0.0f <= < 1.0f

rand.nextBoolean();   // true 또는 false

rand.nextLong();       // Long 범위
rand.nextGaussian();   // 평균 0, 표준편차 1의 정규분포 값

4) Seed(시드) 이해하기

5) Math.random() 과 차이

6) 참고 : 보안 난수는 SecureRandom

• Random은 예측 가능한 난수

• 보안 필요한 경우(패스워드, 토큰, 암호화 키 등)
➡ java.security.SecureRandom 사용 권장

7) 요약

• 난수를 생성하는 객체 기반 클래스

• 다양한 자료형 난수 제공 (nextInt, nextBoolean, nextDouble 등)

• 시드를 지정하면 동일한 난수 재현 가능

• 보안 목적이라면 SecureRandom 추천

3️⃣ Arrays 클래스

1) Arrays 클래스란?

import java.util.Arrays;

2) 주요 기능 요약

3) 자주 쓰는 메서드

• 1차원 배열

int[] arr = {1,2,3};
System.out.println(Arrays.toString(arr));  // [1, 2, 3]

int[][] arr2 = {{1,2},{3,4}};
System.out.println(Arrays.deepToString(arr2));  // [[1, 2], [3, 4]]

int[] nums = {5,2,8,1};
Arrays.sort(nums);      // {1,2,5,8}

int index = Arrays.binarySearch(nums,5);  // 결과: 2

int[] copy = Arrays.copyOf(nums,3);           // 길이 3만 복사
int[] range = Arrays.copyOfRange(nums,1,3);   // 인덱스 1~2 복사

Arrays.equals(a, b);         // 1차원 배열 비교
Arrays.deepEquals(a2, b2);   // 2차원 이상 비교

int[] data = new int[5];
Arrays.fill(data,7);      // {7,7,7,7,7}

int sum = Arrays.stream(nums).sum();

4) Arrays는 어떤 때 쓸까?

• 배열의 내용을 쉽게 출력하고 싶을 때

• 데이터를 정렬하거나 검색할 때

• 배열을 부분 복사, 확장해야 할 때

• 다차원 배열을 비교/출력해야 할 때

• Stream API로 계산을 하고 싶을 때

5) Arrays vs Collections

6) 정리

• 배열을 다루는 필수 유틸리티 클래스

• 정렬, 검색, 복사, 비교, 채우기, 출력 기능 제공

• Collections는 컬렉션용, Arrays는 배열용

4️⃣ Calendar 클래스

1) Calendar 클래스란?

⚠️ 단, Java 8 이후에는 java.time 패키지(특히 LocalDate, LocalDateTime) 사용이 권장됨

2) 생성 방법

Calendar cal = Calendar.getInstance();

3) 사용 방법

int year = cal.get(Calendar.YEAR);
int month = cal.get(Calendar.MONTH) +1;     // 0~11이므로 +1 필요
int day = cal.get(Calendar.DAY_OF_MONTH);
int hour = cal.get(Calendar.HOUR_OF_DAY);

cal.set(Calendar.YEAR,2025);
cal.set(2025, Calendar.JUNE,15);  // 2025년 6월 15일

cal.add(Calendar.DATE,7);      // 7일 더하기
cal.add(Calendar.MONTH, -1);   // 1개월 빼기

cal.roll(Calendar.DATE,10);  // 해당 달 안에서만 이동

Calendar.YEAR            // 연도
Calendar.MONTH           // 월 (0~11)
Calendar.DATE            // 일
Calendar.HOUR            // 시 (12시간제)
Calendar.HOUR_OF_DAY     // 시 (24시간제)
Calendar.MINUTE          // 분
Calendar.SECOND          // 초
Calendar.DAY_OF_WEEK     // 요일(1=일요일, 7=토요일)

int dow = cal.get(Calendar.DAY_OF_WEEK);
String[] week = {"일","월","화","수","목","금","토"};
System.out.println(week[dow-1] +"요일");

4) Calendar의 한계

• 월이 0~11이라 직관적이지 않음

• 스레드 안전(thread-safe)하지 않음

• 코드가 다소 복잡하다

• LocalDate

• LocalDateTime

• ZonedDateTime

5) 정리