โ 1. java.lang ํจํค์ง๋?
import java.lang.*;
- Java์์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ด๊ณ ์์ฃผ ์ฌ์ฉ๋๋ ํด๋์ค๋ค์ ๋ชจ์๋์ ํจ์งํค๋ฅผ ์๋ฏธํ๋ค.
- java.lang ํจํค์ง๋ ๋ชจ๋ ํด๋์ค์ ์๋์ผ๋ก import๊ฐ ๋๊ธฐ ๋๋ฌธ์ ๋ณ๋๋ก import๋ฅผ ์ด์ฉํด ์ฌ์ฉ์ ํ์ง ์์๋ ๋๋ค.
- ์์ ์ฝ๋์ฒ๋ผ ์ปดํ์ผ ์ ๋ชจ๋ ์ฝ๋์ ํด๋น import ๋ฌธ์ด ์๋จ์ ๋ถ๊ฒ ๋๋ค.
- java.lang ํจํค์ง ๋ด๋ถ์๋ String, Object, Thread, System ๋ฑ ์๋ฐ์์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ด ๋๋ ํด๋์ค๋ค์ด ๋ค์ด๊ฐ ์์.
โ 2. Object ํด๋์ค
// ์ปดํ์ผ ์
public class MyClass {
}
// ์ปดํ์ผ ํ -> .class
public class MyClass extends Object {
}
- ์๋์ผ๋ก ๋ชจ๋ ํด๋์ค์ ์กฐ์์ด ๋๋ ํด๋์ค์ด๋ฉฐ, ํด๋์ค ๊ณ์ธต ๊ตฌ์กฐ์์ ๋ฃจํธ๊ฐ ๋๋ ํด๋์ค์ด๋ค.
- ํด๋น Object ํด๋์ค๋ ๋ชจ๋ ํด๋์ค๊ฐ ์๋์ผ๋ก ์์์ ๋ฐ๊ณ ์๊ธฐ์ ์์ ๊ตฌ์กฐ์์ ์ต์์ ํด๋์ค๊ฐ ๋๋ค.
- ์ด๊ฑด ์ปดํ์ผ ์์ ์ ์ปดํ์ผ๋ฌ๊ฐ ์๋์ผ๋ก ์์์ด ์๋ ํด๋์ค์ extends Object๋ฅผ ์๋์ผ๋ก ๋ถ์ฌ์ฃผ๊ธฐ ๋๋ฌธ์ด๋ค.
(1) Object ํด๋์ค๊ฐ ๊ฐ์ง๊ณ ์๋ ์ฃผ์ ๋ฉ์๋
protected Object clone() // ๊ฐ์ฒด๋ฅผ ๋ณต์ ํ์ฌ ๋ฐํ
public boolean equals(Object obj) // ๊ฐ์ ๊ฐ์ฒด์ธ์ง ์ฐธ์กฐ๊ฐ์ผ๋ก ๋น๊ต
public int hashCode() // ๊ฐ์ฒด๋ฅผ ์๋ณํ๋ ์ ์๊ฐ์ ๋ฐํ
public String toString() // ๊ฐ์ฒด๋ฅผ ๋ฌธ์์ด๋ก ๋ฐํ
(2) toString()
// Object.class
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
- ๊ฐ์ฒด๋ฅผ ๋ฌธ์์ด๋ก ํํํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ๋ฉ์๋์ด๋ค.
- ํด๋์ค์ด๋ฆ@16์ง์ํด์์ฝ๋๋ก ํํ์ ํด์ String ์ฆ, ๋ฌธ์์ด๋ก ๋ฐํ์ ํด์ค๋ค.
(3) equals()
// Object.class
public boolean equals(Object obj) {
return (this == obj);
}
- ๋ ๊ฐ์ฒด ๋ณ์๋ฅผ ๋น๊ตํด์, ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ฒด์ ์ฐธ์กฐ๊ฐ์ด ๊ฐ์ผ๋ฉด true๋ฅผ ๋ฐํ ( ์ฆ, ๊ฐ์ฒด ๊ฒ์ฆ์ ํ ๋ ์ฌ์ฉ )
- ํด๋น ๋ฉ์๋๋ ์๋ฐ์ == (๋๋ฑ๋น๊ต์ฐ์ฐ์) ๋ฅผ ์ฌ์ฉํด์ ๋น๊ต๋ฅผ ํ๊ณ ์์. ์ฆ, ๊ทธ๋ฅ ๋๋ฑ๋น๊ต์ฐ์ฐ์๋ผ๊ณ ์๊ฐํ๋ฉด๋จ.
(4) clone()
// Object.class
@IntrinsicCandidate
protected native Object clone() throws CloneNotSupportedException;
// Cloneable interface
package java.lang;
public interface Cloneable {
}
- Java์์ ๊ฐ์ฒด๋ฅผ ๋ณต์ ํ๊ธฐ ์ํด ์ฌ์ฉํ๋ ๋ฉ์๋์ด๋ค.
- ๋ชจ๋ ํด๋์ค๋ Object๋ฅผ ์์ ๋ฐ๊ณ ์๊ธฐ ๋๋ฌธ์ ๋ชจ๋ ํด๋์ค์์ ์ฌ์ฉ์ด ๊ฐ๋ฅํ์ง๋ง ์กฐ๊ฑด์ด ๋ถ๋๋ค.
- ํด๋น ํด๋์ค๊ฐ Cloneable ์ธํฐํ์ด์ค๋ฅผ implements ํด์ผํ๋ฉฐ, ํด๋น clone()๋ฅผ ์ง์ ๊ตฌํํด์ผ์ง๋ง ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค.
- clone์ ํ๋ฉด, ํด๋น ๊ฐ์ฒด ๋ด๋ถ์ ๋ค์ด๊ฐ์๋ ๊ฐ ์์ฒด๋ ๋ณต์ฌ๊ฐ ๋๋ฉฐ, ์ฐธ์กฐ๊ฐ์ด ๋ค๋ฅธ ๋๊ฐ์ด ์๊ธด ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด์ค๋ค.
- ์ด๋ฌํ ๋ถ๋ถ์ ์์ธ์ฒ๋ฆฌ ํ ๋ try() ๋ฉ์๋๋ฌธ์ ์๋ ์ธํฐํ์ด์ค -> close() ๋ฉ์๋์ ๊ฐ์ ๋ฐฉ์์ผ๋ก ๋์์ ํ๋ค.
(5) getClass()
// Object.class
@IntrinsicCandidate
public final native Class<?> getClass();
- ํ์ฌ ๊ฐ์ฒด์ ์ค์ ํด๋์ค ์ ๋ณด๋ฅผ ๋ฐํํ๋ค. ์ฆ, ํด๋์ค ์ ๋ณด๋ฅผ ๊ฐ์ง Class ๊ฐ์ฒด๋ฅผ ๋ฆฌํดํ๊ฒ ๋๋ค.
- ํด๋น ๋ฉ์๋๋ native ์ฆ, JVM์ด ๋ค์ดํฐ๋ธ ์ฝ๋(C/C++)๋ก ๊ตฌํํ๋ค๋ ์๋ฏธ์ด๋ค.
- ์ฆ, Java ์์ค ์ฝ๋๊ฐ ์๋ JVM ๋ด๋ถ์์ ๋ค๋ฅธ ์ธ์ด๋ฅผ ํตํด ์ฒ๋ฆฌ๊ฐ ๋๋ฏ๋ก, ๋ฉ์๋ ๋ฐ๋๋ ํ์ธ ํ ์ ์๋ค.
- ๋ฐํ ํ์ Class<?>์ ๋ณดํต Java์ ๋ฆฌํ๋ ์ ์์ ์ฌ์ฉ์ด ๋๋ค.
- JVM์ Dogํด๋์ค๊ฐ ์๋ค์น๋ฉด, ํด๋์ค๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ๋ก๋ํ๋ฉด์ Class<Dog> ๊ฐ์ฒด๋ ๋ด๋ถ์์ ์๋์ผ๋ก ์์ฑ์ ํด๋๋ค.
- ์ด๊ฑด ๋ค์ดํฐ๋ธ ์์ญ์์ ์งํ์ด ๋๋ค.
- JVM์ ํด๋์ค๋ฅผ ์ฒ์ "๋ก๋(load)"ํ ๋, Class<?> ๊ฐ์ฒด๋ฅผ ๋ด๋ถ์์ ์์ฑํ๋ฉฐ, ๊ทธ ์์ ํด๋น ํด๋์ค์ ๋ชจ๋ ์ ๋ณด๋ฅผ "๋ด์ฅ๋ ๊ตฌ์กฐ"๋ฅผ ํตํด ์ฑ์ ๋ฃ์ต๋๋ค.
- "JVM์ ํด๋์ค๋ฅผ ํ๋์ ๋ฐ์ดํฐ ๊ฐ์ฒด๋ก ๋ค๋ฃฐ ์ ์๋๋ก Class<?>๋ผ๋ ๊ตฌ์กฐ๋ฅผ ๋ฏธ๋ฆฌ ์ค๊ณํด๋๊ณ , ํด๋์ค๋ฅผ ๋ก๋ฉํ๋ฉด์ ๊ฑฐ๊ธฐ์ ์ ๋ณด๋ฅผ ์ฑ์๋ฃ๋ ์ผ์ข ์ ํ๋ ์์ํฌ์ฒ๋ผ ์๋ํ๋ค."
โ 3. String ํด๋์ค
- ๋ฌธ์์ด์ ํํํ๊ณ ์ฒ๋ฆฌํ๊ธฐ ์ํ ํด๋์ค๋ฅผ ์๋ฏธํ๋ค.
- String ํด๋์ค ์์ฑ ๋ฐฉ์์ ๋ฆฌํฐ๋ด ๋ฐฉ์๊ณผ ๊ฐ์ฒด ์์ฑ ๋ฐฉ์ ๋ ๊ฐ์ง ๋ฐฉ์์ด ์กด์ฌํ๋ค.
- String์ ๋ถ๋ณํด๋์ค์ด๋ฉฐ, ํ๋์ ํด๋์ค์๋ final๋ก ๊ฐ์ ๋ณ๊ฒฝ์ ๋ง๊ณ ์์.
(1) String ๋ฆฌํฐ๋ด ์์ฑ ๋ฐฉ์
String a = "Hello";
- ๋ฆฌํฐ๋ด ๋ฐฉ์์ ํด๋น ๋ฌธ์์ด ๊ฐ์ด String Constant Pool(๋ฌธ์์ด ์์ ํ)์ ์ ์ฅ์ด ๋๋ค.
- ์์ํ์ ์กด์ฌํ๋ ํด๋น ๋ฌธ์์ด ๊ฐ์ ๋ค๋ฅธ ๋ณ์๋ก ์ด์ฉ์ ํ๊ฒ ๋๋ค๋ฉด ์ฌ์ฌ์ฉ์ ํ๊ฒ ๋๋ค.
- ์ฆ, Hello ๋ผ๋ ๋ฌธ์๊ฐ ์กด์ฌํ๋ฉด ํด๋น ๋ฌธ์๋ฅผ ๋ณ์๋ค์ด ์ฐธ์กฐํด์ ์ด์ฉ์ ํ๊ฒ ๋๋ค๋ ์๋ฏธ์ด๋ค.
- ๋ฌธ์์ด์ ๋ฐ๋ณต๋๋ ๋ฌธ์๊ฐ ๋ง์ด ์ ์ธ๋ ์ ์๊ธฐ์, ๊ฐ์ฒด๋ก์จ ๊ฐ์ง๊ณ ์๊ฒ ๋๋ฉด ๊ฐ์ ๋ฌธ์ ๊ฐ์ฒด๋ฅผ ๋ฐ๋ณต์ ์ผ๋ก ๋ง๋ค๊ฒ๋จ.
- ์ฆ, ๋ฉ๋ชจ๋ฆฌ ์ธก๋ฉด์์ ๋ง์ ๋นํจ์จ๊ณผ ์ฑ๋ฅ์ ๋จ์ด์ง์ด ์กด์ฌํ ์ ์์.
- ๊ทธ๋์ ์์ํ์ ํ์ฉํ๋ฉด, ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ด ๋๊ณ ์๋๊ฐ ๋น ๋ฅด๋ค๋ ์ฅ์ ์ด ์์.
[1] String Constant Pool(๋ฌธ์์ด ์์ ํ) ์ด๋?
- ์ฒ์ String ๋ฆฌํฐ๋ด ๋ฐฉ์ ๋๋ intern() ๋ฉ์๋๊ฐ ํธ์ถ์ด ๋๋ฉด ๊ทธ๋ ํด๋น ์์ํ์ด ๋ง๋ค์ด์ง๋ค.
- ์ฆ, ํด๋์ค๋ก๋๊ฐ ํด๋น ํด๋์ค๋ฅผ ์ฒ์ ๋ก๋ ํ๋ ์์ ์ ์์ํ์ด ๋ง๋ค์ด์ง๋ค๊ณ ๋ณด๋ฉด ๋๋ค.
- ํด๋น ์์ํ์ ๋ฐ๋ณต์ ์ผ๋ก ๋ง๋ค์ด์ง๋ ๋ฌธ์์ด์
[2] intern() ๋ฉ์๋๋?
// String.class
public native String intern();
- new String("Hello")๋ก ๋ง๋ค์ด์ง ๊ฐ์ฒด ๋ฌธ์์ด์ intern() ๋ฉ์๋๋ฅผ ํตํด ์์ํ์ ๋ฃ์ ์ ์๊ฒ ๋จ.
- String ํด๋์ค์ ๋ฉ์๋๋ก, native ์ฝ๋ ์ฆ, ๋ฉ์๋ ๋ฐ๋๋ C๋ C++๋ก ๊ตฌํ ๋์ด์์ผ๋ฉฐ, ํด๋น ์ฝ๋๋ฅผ ์คํํ๋ ๋ฉ์๋์.
- JVM ์์ ํด๋น C๋ C++๋ก ๊ตฌํ ๋๊ณ , ์ปดํ์ผ ๋ ์ฝ๋๋ฅผ ํธ์ถํ๋ ์ฝ๋๊ฐ ๋ด์ฅ์ด ๋์ด์์.
- ์ฆ, ํ์ผ์ ์ฝ๋ ๋ฑ์ ์ฝ๋๋ ๋ด์ฅ์ด ๋์ด์์ด์, ๋ฐ๋ก ๋ฉ์๋ ํธ์ถ๋ก ํด๋น C++ ์ฝ๋๋ฅผ ์คํ ํ ์ ์์.
- ์๋ํ๋ฉด, ์ด๋ฏธ JVM์ด ํด๋น ์ฝ๋๋ฅผ JVM ๋ด๋ถ์์ ๊ฐ์ง๊ณ ์๊ธฐ ๋๋ฌธ์.
(2) String ๊ฐ์ฒด ์์ฑ ๋ฐฉ์
String b = new String("hello"); // Heap ๋ฉ๋ชจ๋ฆฌ ์ ๊ฐ์ฒด
- ํด๋น ๋ฌธ์์ด์ ์๋ก์ด Heap ๋ฉ๋ชจ๋ฆฌ์ ์๋ก์ด ๊ฐ์ฒด๋ก ๋ง๋๋ ๋ฐฉ์์ด๋ค.
- ์ฆ, ๊ฐ์ ๋ฌธ์์ด์ ๋๊ฐ์ ๋ฐฉ์์ผ๋ก ์์ฑ์ ํ๊ฒ ๋๋ ์ฃผ์๊ฐ์ด ๋ค๋ฅธ ์๋ก์ด ๊ฐ์ฒด๊ฐ ๋ง๋ค์ด์ง๋ค.
String a = new String("hello"); // Heap ๋ฉ๋ชจ๋ฆฌ ์ ๊ฐ์ฒด
String b = new String("hello"); // Heap ๋ฉ๋ชจ๋ฆฌ ์ ๊ฐ์ฒด
System.out.println(a == b); // false
- String ๊ฐ์ฒด ์์ฑ ๋ฐฉ์์ ๋์ผํ ๋ฌธ์์ด์ ์ฌ์ฌ์ฉ ํ ์ ์๋ ๋ถ๋ถ์ด ๋งค์ฐ ํฐ ๋จ์ ์ด๋ผ ๋ณดํต์ ์ฌ์ฉ์ด ๋์ง ์๋ ๋ฐฉ์์ด๋ค.
- ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ์ด๋ฌํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ๊ฐ์ฒด๋ก ์์ฑํ ๋ฌธ์์ด์ ์์ํ์ ๋ฃ๋ ๋ฐฉ๋ฒ์ด ์กด์ฌํ๋ค.
- ์ด ๋ฐฉ๋ฒ์ ์์ ์ค๋ช ์์ ๋์จ intern() ๋ฉ์๋๋ฅผ ํธ์ถํด์ ์์ํ์ ๋ฃ๋ ๋ฐฉ์์ด๋ค.
String a = "hello"; // Constant Pool ํ์ฉ (๋ฆฌํฐ๋ด)
String b = new String("hello"); // Heap ๋ฉ๋ชจ๋ฆฌ ์ ๊ฐ์ฒด
System.out.println(a == b); // false
System.out.println(a == b.intern()); // true
(3) String - ๋ฌธ์์ด ๋น๊ต ๋ฉ์๋
[1] compareTo ๋ฉ์๋ - ์ ์๊ฐ ๋ฐํ
String a = "Hello";
String b = new String("Hello");
System.out.println(a.compareTo(b)); // ๊ฒฐ๊ณผ: 0
- ๋ ๋ฌธ์์ด์ด ๊ฐ์ผ๋ฉด 0์ ๋ฆฌํดํ๊ณ , ๋ค๋ฅด๋ฉด 0์ด ์๋ ์ ์๊ฐ์ ๋ฆฌํดํจ.
- ์ฃผ์๊ฐ์ด ์๋ ๋ด๋ถ์ ๊ฐ ์์ฒด๋ฅผ ๋น๊ตํจ.
[2] equals ๋ฉ์๋ - ๋ ผ๋ฆฌ๊ฐ ๋ฐํ
String a = "Hello";
String b = new String("Hello");
System.out.println(a.equals(b)); // true
System.out.println(a == b); // false
- Object ํด๋์ค์ equals() ๋ฅผ ์ฌ์ ์ ํ๊ณ ์์ด, ์ฃผ์๊ฐ์ด ์๋ ๋ฌธ์์ด ์์ฒด์ ๊ฐ์ ๋น๊ตํจ.
โ 4. StringBuffer ํด๋์ค
(1) String ํด๋์ค์ ๋ฌธ์ ์
- String์ ๋ฌธ์์ด ์์ํ์ ๋ฌธ์์ด์ ์ค๋ณต๊ฐ ์ ์ฅ์ ๋ฐฉ์งํ๊ธฐ ์ํด์ ์ฌ์ฉ์ ํ๋ค.
- ํ์ง๋ง, ๋ฌธ์์ด์ด ๋์ด๋จ์ ๋ฐ๋ผ ์๋ก์ด ๊ฐ์ฒด๊ฐ ์์ฑ๋๋ ๋ฌธ์ ์ ์ ๊ทธ๋๋ก ์๋ค.
- ์ด๋ฌํ ๋ฌธ์ ๋ก์ธํด, ์ฆ์ ๋ณ์๊ฐ์ ์์ ์ ์๋ก์ด String ๊ฐ์ฒด๋ฅผ ๋ง๋ค๊ธฐ ๋๋ฌธ์ ์ฑ๋ฅ์ ์ ํ๋ฅผ ์ผ์ผํฌ ์ ์๋ค.
(2) StringBuffer ํด๋์ค
StringBuffer sb = new StringBuffer(); // ์ด๊ธฐ ๋น ๋ฌธ์์ด ๋ฒํผ
sb.append("์๋
ํ์ธ์");
sb.append(" ");
sb.append("XXX์
๋๋ค.");
sb.insert(6, "[๊ฐ๋ฐ์] ");
sb.replace(0, 5, "Hello");
sb.delete(17, sb.length()); // ๋ง์ง๋ง ๋ฌธ์ฅ ์ผ๋ถ ์ญ์
System.out.println(sb.toString()); // ์ถ๋ ฅ ๊ฒฐ๊ณผ: Hello [๊ฐ๋ฐ์] XXX
- StringBuffer ํด๋์ค๋ ๊ฐ์ฒด ์์ฑ ์ดํ ๋ฌธ์์ด์ ๋ณ๊ฒฝํ ์ ์๋ ํด๋์ค์ด๋ค.
- ๋ด๋ถ์ ์ผ๋ก ๋ฌธ์์ด์ ์ ์ฅํ๊ธฐ ์ํด ํฌ๊ธฐ๊ฐ ์กฐ์ ๋๋ ๋ฒํผ(๋ฐฐ์ด์ด๋ผ๊ณ ๋ณด๋ฉด๋จ)๋ฅผ ์ฌ์ฉ์ ํ๋ค.
- ๋ฌธ์์ด์ ์์ฃผ ์์ ํด์ผ ํ๋ ์ํฉ์์ ๋ง์ด ์ฐ์ด๋ ํด๋์ค๋ผ๊ณ ๋ณด๋ฉด ๋๋ค.
- ๋ฉ์๋๋ฅผ ํตํด ๋ฌธ์๋ฅผ ์ถ๊ฐํ๊ฒ ๋๋ฉด, ๊ฐ์ฒด๋ฅผ ์์ฑํ์ง ์๊ณ ๋ด๋ถ์ ๋ฒํผ์ ์ถ๊ฐ๊ฐ ๋๋ค๊ณ ๋ณด๋ฉด ๋๋ค.
(3) StringBuilder ํด๋์ค
- StringBuffer ํด๋์ค์ ๊ฑฐ์ ๋๊ฐ์ด ์๊ธด ํด๋์ด๋ฉฐ, ์ฐจ์ด๋ก๋ ๋๊ธฐํ ์ฌ๋ถ์์์ ์ฐจ์ด๊ฐ ์๋ค.
- StringBuffer์ ์ค๋ ๋ ์์ ํ์ง๋ง, StringBuilder์ ๋น๋๊ธฐ๋ก ์ค๋ ๋ ์์ ํ์ง ๋ชปํ๋ค๋ ํน์ง์ด ์์.
- ๋์ ์, ์๋ ์ธก๋ช ์์ StringBuilder๊ฐ ๋น ๋ฅด๋ค.
- ๋ฉํฐ์ค๋ ๋์์ StringBuffer๋ฅผ ์ฌ์ฉํ๋ฉฐ, ๋จ์ผ ์ค๋ ๋์์ StringBuilder๋ฅผ ์ฃผ๋ก ์ฌ์ฉํจ.
- ๊ทธ๋์ ๋ณดํต์ StringBuilder๋ฅผ ์ฌ์ฉํ์ง๋ง, ์ค๋ ๋ ์์ ์ฑ์ด ์ ๋ง ํ์ํ ๊ฒฝ์ฐ StringBuffer๋ฅผ ์ด๋ค.
(4) String vs StringBuffer vs StringBuilder
public class Main {
public static void main(String[] args) {
final String tmp = "test";
long start, end;
String str = new String();
StringBuffer sb1 = new StringBuffer();
StringBuilder sb2 = new StringBuilder();
start = System.nanoTime();
for(int i = 0; i < 100; i++) str += tmp;
end = System.nanoTime();
System.out.println((end-start) / 1000000.0 + " msecs"); // 4.155299 msecs
start = System.nanoTime();
for(int i = 0; i < 100; i++) sb1.append(tmp);
end = System.nanoTime();
System.out.println((end-start) / 1000000.0 + " msecs"); // 0.054601 msecs
start = System.nanoTime();
for(int i = 0; i < 100; i++) sb2.append(tmp);
end = System.nanoTime();
System.out.println((end-start) / 1000000.0 + " msecs"); // 0.047 msecs
}
}
- String = 4.155299 msecs
- StringBuffer = 0.054601 msecs
- StringBuilder = 0.047 msecs
- StringBuilder๊ฐ ๊ฐ์ฅ ๋น ๋ฅด๊ณ ๋ค์์ผ๋ก StringBuffer๊ฐ ๋น ๋ฅด๊ณ ๋ค์์ผ๋ก String์ด ๋์์.
โ 5. ํฌ์ฅ ํด๋์ค ( ๋ํผ ํด๋์ค )
Double double = new Double(2.59) // ์์ฑ์ ๋ฐฉ์, ๊ถ์ฅ ์๋จ
DOuble double = Double.valueOf(10.4); // ValueOf() ์ฌ์ฉ ๋ฐฉ์ ๊ถ์ฅ
Double double = 3.14; // ์๋ boxing
- ๊ธฐ๋ณธ์๋ฃํ์ ์ฐธ์กฐ์๋ฃํ์ผ๋ก ํํํ๊ธฐ ์ํ ํด๋์ค์ด๋ค. ๊ธฐ๋ณธ์๋ฃํ์ int, double, char, boolean ๋ฑ์ ์๋ฏธํจ.
- ๊ธฐ๋ณธํ๊ณผ ์์ํ๋ ๊ฐ์ฒด ์ฌ์ด์ ํ๋ณํ ๊ธฐ๋ฅ์ ์ ๊ณตํจ.
- ๋ฉ์๋์ ์ธ์๋ก ์ฐธ์กฐํ ์ฆ, ๊ฐ์ฒด ์์ฒด๊ฐ ํ์ํ ๊ฒฝ์ฐ ํด๋น ๊ธฐ๋ณธ์๋ฃํ์ ์ฐธ์กฐํ์ผ๋ก ๋ฐ์ฑํด์ ๋ณด๋ด์ค ์ ์์.
- ๋ํ. ๋ํผ ํด๋์ค๋ ๋ค์ํ ๋ฉ์๋๋ฅผ ์ ๊ณต์ ํด์ค.
- Number ์ถ์ ํด๋์ค๋ฅผ ์์ ๋ฐ์์ ๊ตฌํ ๋ ํด๋์ค๋ค์ ์๋ฏธํจ.
(1) ๋ฐ์ฑ(Boxing)
Double d = Double.valueOf(10.4); // ValueOf() ์ฌ์ฉ ๋ฐฉ์ ๊ถ์ฅ
Double pi = 3.14; // ์๋ boxing
// ๋ด๋ถ์ ์ผ๋ก Double.vlauleOf(3.14) ๋ก ์ฒ๋ฆฌ๊ฐ ๋จ.
- ๊ธฐ๋ณธ์๋ฃํ์ ๊ฐ์ ๋ฐ์ฑํด์ ๊ฐ์ฒด๋ก ๋ง๋๋ ๋ฐฉ๋ฒ์ ์๋ฏธํ๋ฉฐ, ์๋๊ณผ valueOf() ๋ฐฉ์์ด ์กด์ฌํ๋ค.
- ์๋ ๋ํ ์ด์ฐจํผ valueOf() ๋ฐฉ์์ ํ์ฉํ๊ธฐ ๋๋ฌธ์, valueOf()๊ฐ ๋งค์ฐ ์ค์ํ๊ฒ ์์ฉ๋จ.
- ์ธ์์ ์ ๋ฌ๋๊ฑฐ๋ ๋ณ์์ ๋์ ๋ ๋ ์๋์ผ๋ก ๋ฐ์ฑ๋์ด์ ์ ์ฉ์ด ๋จ.
(2) ์ธ๋ฐ์ฑ(Unboxing)
Double pi = 3.14; // ์๋ boxing
double d = Double.doubleValue(pi); // doubleValue() : ๊ธฐ๋ณธ์๋ฃํ์ผ๋ก ๋ณ๊ฒฝ ๋ฉ์๋
double d = pi; // ์๋ unboxing
- ๋ํผํด๋์ค์ ์ฐธ์กฐ๊ฐ์ ๊ธฐ๋ณธ์๋ฃํ์ ๊ฐ์ผ๋ก ๋ณ๊ฒฝํ๋ ๊ฒ์ ์๋ฏธํ๋ฉฐ, ์๋๊ณผ doubleValue() ๋ฐฉ์์ด ์กด์ฌํจ
- ๋ฐ์ฑ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก, ์๋ ์ธ๋ฐ์ฑ ๋ํ doubleValue()๊ฐ ๋ด๋ถ์ ์ผ๋ก ๋์ํ๋ค๊ณ ๋ณด๋ฉด๋จ.
- ๋ง์ฐฌ๊ฐ์ง๋ก ์ธ์์ ์ ๋ฌ๋๊ฑฐ๋ ๋ณ์์ ๋์ ๋ ๋ ์๋์ผ๋ก ๋ฐ์ฑ๋์ด์ ์ ์ฉ์ด ๋จ.
โ 6. System ํด๋์ค
- System ํด๋์ค๋ ์๋ฐ์์ ๋งค์ฐ ์ค์ํ ์ ํธ๋ฆฌํฐ ํด๋์ค๋ก, ์ด์์ฒด์ ์์ ์ธํฐํ์ด์ค๋ฅผ ์ผ๋ถ ์ ๊ณตํ๋ ํ์ค ์ ์ถ๋ ฅ, ์์คํ ์์ฑ, ์๊ฐ ์ธก์ , ์ข ๋ฃ ๋ฑ ๋ค์ํ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ค. ํ๋ง๋๋ก, ์๋ฐ ํ๋ก๊ทธ๋จ์ด JVM ๋ฐ OS์ ์ํธ์์ฉํ๋ ์๋จ ์ค ํ๋์.
- ๋ชจ๋ ๋ฉค๋ฒ๋ static, ์ฌ์ฉํ ๋ ๊ฐ์ฒด๋ฅผ ์์ฑํ ํ์๋ ์ ํ ์์.
- ํ์ค ์ ์ถ๋ ฅ ๊ฐ์ฒด ์ ๊ณต, JVM ์์ฑ๊ณผ ์์คํ ํ๊ฒฝ ๋ณ์์ ์ฌ์ฉ๊ณผ ์ ์ด, ๋ฐฐ์ด ๋ณต์ฌ, ์๊ฐ ์กฐํ, ํ๋ก๊ทธ๋จ์ ์ ์ด ๋ฑ์ ํด์ค.
(1) System ํด๋์ค - ํ์ค ์ ์ถ๋ ฅ ํ๋
- System.in: ํ์ค ์ ๋ ฅ ์คํธ๋ฆผ์ผ๋ก InputStream ์ ํ, ํค๋ณด๋๋ก๋ถํฐ ์ ๋ ฅ์ ๋ฐ์ ๋ ์ฌ์ฉํจ.
- Systme.out: ํ์ค ์ถ๋ ฅ ์คํธ๋ฆผ PrintStream ์ ํ, ํ๋ฉด์ ๋ฐ์ดํฐ๋ฅผ ์ถ๋ ฅํ ๋ ์ฌ์ฉํจ.
- System.err: ํ์ค ์๋ฌ ์ถ๋ ฅ ์คํธ๋ฆผ PrintStream ์ ํ, ์ค๋ฅ ๋ฉ์์ง๋ฅผ ํ๋ฉด์ ์ถ๋ ฅํ ๋ ์ฌ์ฉํจ.
โ 7. ๊ทธ ์ธ
- java.lang ํจํค์ง์๋ ๊ทธ ์ธ Process, Thread, Exception, Package, Class, Math ๋ฑ์ด ์์.