Java 프로그래밍을 시작하면서 가장 먼저 접하게 되는 패키지 중 하나가 바로 java.lang입니다. 이 패키지는 자바 애플리케이션의 기본적인 동작에 필수적인 클래스들로 구성되어 있으며, 별도의 import 문 없이도 사용할 수 있도록 특별히 설계되어 있습니다.
예외 처리, 문자열 처리, 수치 연산, 객체 비교 등 일상적인 프로그래밍 작업 대부분에 필요한 기능들이 이 패키지 안에 포함되어 있으며, 자바의 철학과 설계 사상을 가장 잘 보여주는 패키지이기도 합니다.
이번 글에서는 java.lang 패키지의 주요 클래스들과 그 역할에 대해 체계적으로 정리하고, 실무에서 자주 마주치는 대표 메서드들을 예제와 함께 살펴보겠습니다. Java의 기반을 탄탄하게 다지고자 하는 개발자라면 반드시 익혀야 할 내용입니다.
Object 클래스 – 모든 클래스의 뿌리
자바의 모든 클래스는 자동으로 Object 클래스를 상속받습니다. 이는 개발자가 명시적으로 상속을 지정하지 않더라도, 자바 컴파일러가 자동으로 extends Object를 삽입하기 때문입니다.
그만큼 Object 클래스는 Java 언어의 가장 기본적인 클래스이며, 자바 객체가 공통적으로 가져야 할 최소한의 동작들을 정의합니다.
Object 클래스의 특징
-
Object는 모든 클래스의 최상위 조상 클래스입니다.
-
단 하나의 멤버 변수도 없고, 오직 11개의 메서드만 정의되어 있습니다.
-
이 메서드들은 모든 객체가 갖추어야 할 기본 동작(비교, 문자열 표현, 복제 등)을 담당합니다.
equals() – 객체 비교의 기준
기본적으로 equals() 메서드는 두 객체의 주소값(즉, 참조가 동일한지)을 비교합니다.
public boolean equals(Object obj) {
return (this == obj);
}
🔍 예제 1 - 주소값 비교
class Value {
int value;
Value(int value) {
this.value = value;
}
}
class Ex1 {
public static void main(String[] args) {
Value v1 = new Value(10);
Value v2 = new Value(10);
System.out.println(v1.equals(v2)); // false
}
}- 위 예제에서 v1과 v2는 같은 값을 가지고 있지만, 서로 다른 메모리 주소를 참조하므로
false를 반환합니다.
✔ equals() 오버라이딩 – 내용 비교로 변경
내용을 기준으로 비교하고자 한다면 equals() 를 오버라이딩해야 합니다.
class Person {
long id;
public Person(long id) {
this.id = id;
}
@Override
public boolean equals(Object obj) {
// obj의 상속계층도에 Person이 있는지 확인
if (obj instanceof Person)
return this.id == ((Person) obj).id; // 형변환
return false;
}
}
class Ex2 {
public static void main(String[] args) {
Person p1 = new Person(123L);
Person p2 = new Person(123L);
System.out.println(p1.equals(p2)); // true
}
}✅ 실무 팁
equals()를 오버라이딩할 경우에는 반드시hashCode()도 함께 오버라이딩해야 합니다. 둘의 계약(Contract)을 위반하면 컬렉션에서의 검색이나 비교 연산이 잘못 작동할 수 있습니다.
hashCode() – 해시 기반 자료구조의 핵심
이 메서드는 해싱(hashing)기법에 사용되는 해시함수(hash function)를 구현한 것입니다. 해싱은 데이터관리기법 중의 하나인데 다량의 데이터를 저장하고 검색하는 데 유용합니다. 해시함수는 찾고자하는 값을 입력하면, 그 값이 저장된 위치를 알려주는 해시코드(hashcode)를 반환합니다.
일반적으로 해시코드가 같은 두 객체가 존재하는 것이 가능하지만, Object 클래스에 정의된 hashCode 메서드는 객체의 주소값을 이용해서 해시코드를 만들어 반환하기 때문에 서로 다른 두 객체는 결코 같은 해시코드를 가질 수 없습니다. 단, 64 bit JVM에서는 주소가 64 bit이므로 주소를 해시코드(32 bit)로 변환하면 중복된 값이 나올 수 있습니다.
hashCode() 메서드는 객체의 해시코드를 반환합니다. 기본 구현은 객체의 메모리 주소를 기반으로 정수값을 반환합니다.
🔍 예제 2 – 문자열 비교와 해시코드
class Ex3 {
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1.equals(s2)); // true
System.out.println(s1.hashCode()); // 96354
System.out.println(s2.hashCode()); // 96354
System.out.println(System.identityHashCode(s1)); // 942731712
System.out.println(System.identityHashCode(s2)); // 971848845
}
}-
String 클래스는
equals()와hashCode()를 모두 오버라이딩하여 문자열 내용이 같으면 같은 해시코드를 반환하도록 설계되어 있습니다. -
반면
System.identityHashCode()는 객체의 실제 주소기반 해시코드를 반환합니다.
✅ 실무 팁
-
해시 기반 자료구조(HashMap, HashSet, Hashtable 등)를 사용할 때는
equals()와hashCode()의 일관성을 반드시 보장해야 합니다. -
동일한 객체라고 판단되면 동일한 해시코드를 반환해야 검색과 저장이 정확히 작동합니다.
toString() – 객체 정보의 문자열 표현
toString() 은 객체를 문자열로 표현할 때 호출됩니다. 예를 들어 System.out.println(obj) 와 같이 객체를 출력하면 내부적으로 obj.toString()이 호출됩니다.
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}🔍 예제 3 – 기본 toString() 출력
클래스를 작성할 때 toString() 을 오버라이딩하지 않는다면, 클래스이름과 16진수의 해시코드를 얻을 수 있습니다.
class Card {
String kind;
int number;
Card(String kind, int number) {
this.kind = kind;
this.number = number;
}
}
class Ex4 {
public static void main(String[] args) {
Card c1 = new Card("SPADE", 1);
System.out.println(c1); // Card@762efe5d
}
}✔ toString() 오버라이딩 – 가독성 향상
@Override
public String toString() {
return "kind : " + kind + ", number : " + number;
}
class Ex5 {
public static void main(String[] args) {
Card c1 = new Card("SPADE", 1);
Card c2 = new Card("HEART", 10);
System.out.println(c1); // kind : SPADE, number : 1
System.out.println(c2); // kind : HEART, number : 10
}
}✅ 실무 팁
-
객체의 상태를 빠르게 파악해야 하는 디버깅 상황이나 로깅 시 유용합니다.
-
toString()을 오버라이딩할 때는 민감 정보가 노출되지 않도록 주의해야 합니다.
요약
| 메서드명 | 기본 역할 | 오버라이딩 필요 여부 |
|---|---|---|
equals() | 객체 주소 비교 | 객체 내용 비교 시 필요 |
hashCode() | 해시코드 반환 | equals()를 오버라이딩하면 필수 |
toString() | 객체 정보 문자열 반환 | 출력 결과 개선 시 유용 |
String 클래스 – 자바에서 문자열을 다루는 기본 도구
자바에서 문자열 처리는 String 클래스를 통해 이루어집니다. String 클래스는 문자열을 저장하고 다양한 조작 메서드를 제공하며, Java 프로그래밍의 거의 모든 영역에서 필수적으로 사용되는 핵심 클래스입니다.
클래스 정의 및 특징
public final class String implements java.io.Serializable, Comparable<String> {
private final char[] value;
...
}-
String 클래스는
final로 선언되어 있어 상속이 불가능합니다. -
문자열 데이터는 내부적으로 문자 배열(char[])에 저장됩니다.
-
문자열 비교, 결합, 추출 등 문자열 처리를 위한 다양한 메서드를 제공합니다.
변경 불가능한(Immutable) 클래스
String 객체는 한 번 생성되면 그 내부 값을 변경할 수 없는 immutable 객체입니다.
String a = "a";
String b = "b";
a = a + b; // 새로운 String 인스턴스 생성위 예제에서 문자열을 결합하면 기존의 a 인스턴스를 수정하는 것이 아니라, 새로운 String 인스턴스가 생성되어 그 참조값이 a에 재할당됩니다.
문자열 변경이 빈번하게 발생하는 상황(예: 반복문 내 문자열 누적)에서는 StringBuffer 나 StringBuilder 를 사용하는 것이 성능상 유리합니다.
문자열 생성 방식 – 리터럴 vs 생성자
| 방식 | 예시 | 특징 |
|---|---|---|
| 문자열 리터럴 | String str1 = "abc"; | JVM의 상수 풀(Constant Pool)을 사용하여 동일한 문자열을 재사용 |
| 생성자 사용 | String str2 = new String("abc"); | 항상 새로운 인스턴스를 생성하며, 리터럴과 다른 주소값을 가짐 |
class Ex {
public static void main(String[] args) {
String str1 = "abc";
String str2 = "abc";
// 재사용으로 인해 str1과 str2가 동일한 주소를 참조
System.out.println(str1 == str2); // true
System.out.println(str1.equals(str2)); // true
String str3 = new String("abc");
String str4 = new String("abc");
System.out.println(str3 == str4); // false
System.out.println(str3.equals(str4)); // true
}
}
-
==: 참조(주소) 비교 -
.equals(): 문자열 내용 비교
따라서 String str = new String("문자열"); 처럼 생성자를 사용하는 방식은 특별한 이유가 없다면 피하는 것이 좋습니다.
문자열 리터럴과 상수 풀(Constant Pool)
자바 컴파일러는 모든 문자열 리터럴을 클래스 파일의 상수 풀(Constant Pool)에 저장합니다. 동일한 리터럴이 여러 번 등장해도 한 번만 메모리에 저장되고, 해당 값을 참조하도록 최적화됩니다.
class Ex {
public static void main(String[] args) {
String s1 = "AAA";
String s2 = "AAA";
System.out.println(s1 == s2); // true
}
}-
s1과 s2는 동일한 "AAA" 문자열을 참조합니다.
-
이와 같은 동작은 메모리 절약과 성능 향상에 도움을 줍니다.
String.join()과 StringJoiner – 문자열 결합의 새로운 방법
Java 8부터는 문자열 배열 또는 컬렉션을 구분자로 연결할 수 있는 기능이 도입되었습니다.
✅ String.join()
String[] arr = { "dog", "cat", "bear" };
System.out.println(String.join("-", arr)); // dog-cat-bear-
배열 또는 Iterable 타입 요소들을 하나의 문자열로 합칩니다.
-
간단하고 직관적인 API입니다.
✅ StringJoiner
StringJoiner sj = new StringJoiner("/", "[", "]");
sj.add("dog").add("cat").add("bear");
System.out.println(sj.toString()); // [dog/cat/bear]-
접두사, 구분자, 접미사를 지정하여 포맷된 문자열을 생성할 수 있습니다.
-
반복문이나 조건문과 조합하여 유연한 문자열 처리가 가능합니다.
요약
| 항목 | 요약 설명 |
|---|---|
| 불변 객체 | String은 한 번 생성되면 내부 값 변경 불가 |
| 문자열 생성 방식 | 리터럴은 재사용, 생성자는 항상 새 인스턴스 생성 |
| 상수 풀 | 같은 문자열 리터럴은 JVM에서 공유 저장 |
String.join() | 간단한 문자열 배열 결합 |
StringJoiner | 접두/접미 포함한 고급 문자열 조합 가능 |
StringBuffer 클래스 – 변경 가능한 문자열을 위한 선택
앞서 살펴본 String 클래스는 불변(immutable) 객체로 설계되어 있어 한 번 생성된 문자열은 변경이 불가능합니다. 이러한 특성은 보안성과 안정성 측면에서는 이점을 가지지만, 문자열 변경이 빈번한 경우에는 성능 저하를 유발할 수 있습니다.
이러한 문제를 해결하기 위해 자바에서는 문자열의 수정이 가능한 StringBuffer 클래스를 제공합니다. StringBuffer는 내부에 편집 가능한 버퍼(buffer)를 갖고 있으며, 문자열의 삽입, 삭제, 수정 등이 모두 가능합니다.
클래스 정의 및 구조
public final class StringBuffer implements java.io.Serializable {
private char[] value;
}-
char[] value배열은 실제 문자열 데이터를 저장합니다. -
StringBuffer 역시
final클래스로 상속이 불가능합니다. -
버퍼란 문자 데이터를 임시로 저장하고 조작할 수 있는 메모리 공간을 의미합니다.
생성자와 버퍼 초기화
StringBuffer 인스턴스는 내부에 문자 배열(char[]) 기반의 버퍼를 생성합니다. 버퍼 크기를 개발자가 지정하지 않으면, 기본 크기(16자)가 할당됩니다.
| 생성자 | 설명 |
|---|---|
new StringBuffer() | 기본 16자의 버퍼 생성 |
new StringBuffer(int length) | 지정된 길이의 버퍼 생성 |
new StringBuffer(String str) | 초기 문자열과 16자의 여유 공간을 포함한 버퍼 생성 |
StringBuffer sb1 = new StringBuffer(); // 16자 버퍼
StringBuffer sb2 = new StringBuffer(50); // 50자 버퍼
StringBuffer sb3 = new StringBuffer("hello"); // "hello" + 16자 버퍼⚠️ 버퍼 크기 주의
문자열이 버퍼의 크기를 초과하게 되면 내부적으로 버퍼 확장 작업이 수행되며, 이는 다음과 같은 추가 연산을 포함합니다:
char newValue[] = new char[newCapacity];
System.arraycopy(value, 0, newValue, count); // count는 현재 문자열 길이
value = newValue;이 연산은 성능에 영향을 줄 수 있으므로, 예상 문자열 크기를 고려하여 적절한 초기 버퍼 크기를 지정하는 것이 좋습니다.
문자열 비교 시 주의점
StringBuffer는 equals() 메서드를 오버라이딩하지 않았기 때문에, 인스턴스의 주소(참조)를 비교합니다.
StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = new StringBuffer("abc");
System.out.println(sb1.equals(sb2)); // false
System.out.println(sb1 == sb2); // false올바른 비교 방법
StringBuffer의 문자열 내용을 비교하고 싶다면, 반드시 toString() 메서드를 사용하여 String으로 변환한 후 비교해야 합니다.
String s1 = sb1.toString();
String s2 = sb2.toString();
System.out.println(s1.equals(s2)); // true참고로, toString() 메서드는 오버라이딩되어 있어 저장된 문자열을 반환합니다.
StringBuffer vs StringBuilder
StringBuffer는 멀티쓰레드에 안전(thread safe)하도록 동기화되어 있다. 멀티쓰레드로 작성된 프로그램이 아닌 경우, StringBuffer의 동기화는 불필요하게 성능만 떨어뜨립니다.
| 항목 | StringBuffer | StringBuilder |
|---|---|---|
| 동기화 여부 | O (thread-safe) | X (단일 쓰레드 환경에서 권장) |
| 성능 | 상대적으로 느림 | 빠름 |
| 사용 대상 | 멀티쓰레드 환경 | 단일 쓰레드 환경 |
| API 호환성 | 동일 (append, insert 등) | 동일 |
// StringBuilder 예시
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" World");
System.out.println(sb.toString()); // Hello WorldStringBuffer를 사용 중이던 코드를 단일 쓰레드 환경에서 최적화하고자 할 때, StringBuilder로의 전환은 매우 간단하며 효과적입니다.
요약
| 항목 | 설명 |
|---|---|
| 불변성 여부 | StringBuffer는 가변(mutable) 객체 |
| 성능 팁 | 예상 문자열 길이만큼 버퍼 크기를 지정하여 생성하는 것이 바람직 |
| 문자열 비교 | equals()가 아니라 toString().equals() 사용 |
| 쓰레드 안전성 | StringBuffer는 thread-safe, StringBuilder는 thread-unsafe |
| 사용 시점 구분 | 멀티쓰레드 환경 – StringBuffer, 단일 쓰레드 환경 – StringBuilder |
래퍼(Wrapper) 클래스 – 기본형을 객체처럼 다루는 방법
Java는 성능을 고려하여 int , double , char 등과 같은 8개의 기본형(primitive type) 데이터를 객체가 아닌 값 자체로 처리합니다. 이는 자바가 완전한 의미의 순수 객체지향 언어가 아니라는 평가를 받는 이유이기도 합니다.
하지만 프로그래밍을 하다 보면, 기본형 변수도 객체로 다뤄야 하는 상황이 종종 발생합니다. 대표적인 예로는 컬렉션 프레임워크, 제네릭, Object 타입의 파라미터 등이 있습니다.
이러한 상황에서 기본형을 객체로 감싸는 역할을 하는 것이 바로 래퍼 클래스(wrapper class)입니다.
래퍼 클래스란?
래퍼 클래스는 기본형 값을 내부에 저장하면서, 다양한 유틸리티 메서드를 제공하는 클래스입니다. 예를 들어, int 를 객체처럼 다루고 싶을 때는 Integer 클래스를 사용합니다.
public final class Integer extends Number implements Comparable<Integer> {
private final int value;
...
}-
래퍼 클래스는
final로 정의되어 있으며 상속이 불가능합니다. -
내부에 해당 기본형 값을 저장하고, 관련된 메서드들을 제공합니다.
기본형과 대응되는 래퍼 클래스 목록
| 기본형 | 래퍼 클래스 | 주요 생성자 | 예시 코드 |
|---|---|---|---|
boolean | Boolean | Boolean(boolean value), Boolean(String s) | new Boolean(true), new Boolean("true") |
char | Character | Character(char value) | new Character('a') |
byte | Byte | Byte(byte value), Byte(String s) | new Byte((byte)10), new Byte("10") |
short | Short | Short(short value), Short(String s) | new Short((short)10), new Short("10") |
int | Integer | Integer(int value), Integer(String s) | new Integer(100), new Integer("100") |
long | Long | Long(long value), Long(String s) | new Long(100L), new Long("100") |
float | Float | Float(float value), Float(String s) | new Float(1.0f), new Float("1.0") |
double | Double | Double(double value), Double(String s) | new Double(1.0), new Double("1.0") |
📌 주의: JDK 9부터는 대부분의 생성자가 Deprecated 되었으며, 객체 생성을 위해 valueOf() 또는 auto-boxing 방식을 사용하는 것이 권장됩니다.
Boxing & Unboxing
📦 Boxing
기본형 → 래퍼 클래스 객체로 변환
int n = 10;
Integer i = Integer.valueOf(n); // 권장
Integer i2 = n; // auto-boxing (자동 변환)📤 Unboxing
래퍼 클래스 객체 → 기본형으로 변환
Integer i = 20;
int n = i.intValue(); // 명시적 언박싱
int n2 = i; // auto-unboxing (자동 변환)실무에서 래퍼 클래스가 필요한 이유
| 사용 사례 | 설명 |
|---|---|
| 컬렉션 사용 시 | List<int>는 불가능하지만, List<Integer>는 가능 |
| 제네릭 사용 시 | 기본형은 타입 파라미터로 사용할 수 없으므로 객체 필요 |
| null 처리가 필요한 경우 | 기본형은 null을 가질 수 없지만, 래퍼 클래스는 가능 |
| Object 파라미터와의 통합 처리 | 모든 래퍼 클래스는 Object 타입으로 전달 가능 |
주의할 점
-
래퍼 클래스는 기본형보다 메모리 사용량이 크고 연산 속도가 느립니다.
-
빈번한 auto-boxing/unboxing은 성능 저하의 원인이 될 수 있습니다.
-
==비교 시 객체 주소를 비교하므로equals()를 사용해야 정확한 값 비교가 가능합니다.
Integer a = 100;
Integer b = 100;
System.out.println(a == b); // true ([-128~127] 캐시 범위)
System.out.println(a.equals(b)); // true
Integer c = 1000;
Integer d = 1000;
System.out.println(c == d); // false (캐시 범위 밖)
System.out.println(c.equals(d)); // true요약
| 항목 | 내용 |
|---|---|
| 정의 | 기본형을 객체로 다루기 위한 클래스 |
| 총 개수 | 8개 (boolean, char, byte, short, int, long, float, double) |
| 생성 방식 | valueOf() 또는 auto-boxing 권장 |
| 사용 용도 | 컬렉션, 제네릭, null 처리, Object 파라미터 등 |
| 주의 사항 | == 대신 equals()로 비교, auto-boxing 성능 유의 |
Number 클래스 – 숫자형 래퍼 클래스들의 공통 조상
자바의 래퍼 클래스 중에서도 int , double , long 등 숫자와 관련된 기본형을 객체로 다루기 위한 클래스들이 있습니다. 이러한 숫자형 래퍼 클래스들은 모두 java.lang.Number 클래스를 공통 조상으로 상속받습니다.
Number 클래스는 자바에서 숫자형 객체 계층의 기반 클래스로 정의되어 있으며, 객체에 저장된 값을 다양한 기본형 숫자 타입으로 변환할 수 있는 메서드들을 제공합니다.
Number 클래스 개요
public abstract class Number implements java.io.Serializable {
public abstract int intValue();
public abstract long longValue();
public abstract float floatValue();
public abstract double doubleValue();
public byte byteValue() {
return (byte) intValue();
}
public short shortValue() {
return (short) intValue();
}
}-
추상 클래스이므로 직접 인스턴스를 생성할 수 없습니다.
-
핵심 기능은 다양한 숫자형으로의 변환 메서드를 제공하는 데 있습니다.
-
Integer,Long,Float,Double,Byte,Short등의 래퍼 클래스는 모두 Number 클래스를 상속받습니다.
상속 구조
Object
▲
Number (추상 클래스)
┌────┬────┬────┬────┬────┬────┐
Integer Long Float Double Byte Short
이 구조 덕분에 다양한 숫자형 래퍼 객체를 다형성(polymorphism)을 활용해 하나의 인터페이스로 다룰 수 있습니다.
예시:
public void printDoubleValue(Number number) {
System.out.println(number.doubleValue());
}- 위 메서드는
Integer,Double,BigDecimal등 다양한 숫자 객체를 하나의 파라미터 타입으로 처리할 수 있습니다.
주요 메서드 설명
| 메서드 | 반환형 | 설명 |
|---|---|---|
intValue() | int | 객체의 값을 int 타입으로 변환하여 반환 |
longValue() | long | 객체의 값을 long 타입으로 변환하여 반환 |
floatValue() | float | 객체의 값을 float 타입으로 변환하여 반환 |
doubleValue() | double | 객체의 값을 double 타입으로 변환하여 반환 |
byteValue() | byte | intValue()를 바탕으로 변환된 byte 반환 (명시적 형변환 포함) |
shortValue() | short | intValue()를 바탕으로 변환된 short 반환 (명시적 형변환 포함) |
✅ 실무 팁
-
Number타입을 활용하면 다양한 숫자 래퍼 클래스를 하나의 메서드에서 유연하게 처리할 수 있습니다. -
단, 명시적 캐스팅이 수행되는
byteValue(),shortValue()는 오버플로우 위험이 있으므로 사용 시 주의가 필요합니다.
BigInteger와 BigDecimal – 확장 숫자 타입
Number 클래스의 자손에는 기본형 래퍼 클래스 외에도 아래와 같은 정밀 수치 계산용 클래스도 포함됩니다:
| 클래스 | 설명 |
|---|---|
BigInteger | long보다 더 큰 범위의 정수 처리 가능 (예: 암호화, 금융 연산 등) |
BigDecimal | double보다 더 정밀한 부동 소수점 계산 가능 (예: 통화 단위 계산) |
import java.math.BigInteger;
import java.math.BigDecimal;
BigInteger bigInt = new BigInteger("12345678901234567890");
BigDecimal bigDec = new BigDecimal("1234567890.12345678901234567890");
System.out.println(bigInt.multiply(BigInteger.TEN));
System.out.println(bigDec.add(new BigDecimal("0.00000000000000000001")));✅ 실무 팁
-
금융 및 과학 계산과 같이 정밀한 수치 연산이 필요한 경우, BigDecimal을 사용하는 것이 필수적입니다.
-
BigInteger, BigDecimal은 기본형처럼 연산자가 아닌 메서드를 통해 사칙연산을 수행합니다 (add, subtract, multiply, divide 등).
요약
| 항목 | 설명 |
|---|---|
| 클래스 유형 | 추상 클래스 (abstract) |
| 주요 자손 클래스 | Integer, Long, Double, Float, Short, Byte |
| 주요 기능 | 다양한 기본형 숫자 타입으로 변환하는 메서드 제공 |
| 확장 자손 | BigInteger, BigDecimal |
| 실무 적용 포인트 | 숫자 래퍼 객체를 다형적으로 처리 가능, 고정 소수점 계산에 BigDecimal 활용 |
마무리하며
자바 프로그래밍의 핵심이자 가장 기본이 되는 java.lang 패키지의 주요 클래스들을 체계적으로 살펴보았습니다.
-
Object 클래스에서 출발해 모든 클래스의 공통 기반이 되는 메서드들을 이해하고,
-
String, StringBuffer, StringBuilder 클래스를 통해 문자열 처리의 원리와 성능 고려사항을 짚어보았으며,
-
Wrapper 클래스들과 Number 클래스를 통해 기본형을 객체로 다루는 방식과 정밀 수치 계산까지 확장할 수 있는 기반을 확인했습니다.
java.lang 패키지의 클래스들은 import 문 없이도 사용 가능한 만큼, 자바 언어 설계자가 "자바 개발자가 반드시 알아야 하는 클래스들"로 판단한 집합입니다. 단순히 자주 쓰인다는 이유를 넘어서, 이들 클래스는 객체지향의 철학, 성능과 안정성의 균형, 그리고 자바라는 언어의 정체성을 고스란히 담고 있습니다.
자바 개발에 있어 java.lang 패키지에 대한 이해는 더 이상 기초가 아닌 핵심 역량입니다. 단순히 문법적인 사용법을 넘어, 클래스의 설계 의도와 내부 구조를 이해하고 응용하는 습관이 쌓이면 실무에서도 더 강력하고 신뢰할 수 있는 코드를 작성할 수 있습니다.
