๋ฐ์ดํฐ ํ์ ์ด๋, ๋ฏธ๋ฆฌ ์ ํด๋์ ์ฝ์์ผ๋ก ๋ฐ์ดํฐ๋ง๋ค ๊ธฐ์ค์ ๋๋๋ฉฐ ๋ฐ์ดํฐ ์ฒ๋ฆฌ์ ์ด๋ฅผ ๊ตฌ๋ถ์ง๊ธฐ ์ํจ์ด๋ค.
์ซ์๋ฉด ์ซ์, ๋ฌธ์๋ฉด ๋ฌธ์๋ผ๊ณ ๋ง ์นญํ๋ฉด๋์ง ์ ๋๋๊ฒ ๋ ๊ฒ์ผ๊น?
๊ทธ ์ด์ ๋ ๋ฐ๋ก ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ์ ์๋ค.
๋ชจ๋ ์๋ฅผ 8byte์ธlong
ํ์ ์ผ๋ก ๋ํ๋์ ๋, 1 ํน์ 2 ์ ๊ฐ์ด ํ์๋ฆฌ ์๋ง ์ ์ฅํ๋ค๋ฉด ๋๋จธ์ง ๋นํธ๋ ๋๊ฒ๋๋ค.
์ด๋ฐ ์ด์ ๋ก ๋ฐ์ดํฐ๋ฅผ ์ฌ๋ฌ๊ฐ์ ํ์ ์ผ๋ก ๋๋์ด ์ฌ์ฉํ๋ ๊ฒ์ด๋ค.์๋ฐ์์๋ ๋ฐ์ดํฐ ํ์ ์ด ํฌ๊ฒ ๊ธฐ๋ณธํ ํ์ ๊ณผ ์ฐธ์กฐํ ํ์ ๋ก ๋๋๋ค.
์๋ฐ์์ ์ ๊ณตํ๋ ๊ธฐ๋ณธํ ๋ฐ์ดํฐ ํ์ ์ ์ด 8๊ฐ์ง์ด๋ค.
Data type | Default Value | Size |
---|---|---|
boolean(์ฐธ/๊ฑฐ์ง) | false | 1 bit |
char(๋ฌธ์) | '\u0000' | 2 byte |
byte(์ ์) | 0 | 1 byte |
short(์ ์) | 0 | 2 byte |
int(์ ์) | 0 | 4 byte |
long(์ ์) | 0L | 8 byte |
float(์ค์) | 0.0f | 4 byte |
double(์ค์) | 0.0d | 8 byte |
๊ธฐ๋ณธ์ ์ผ๋ก true
, false
๋ง ์ ์ฅํ ์ ์์ผ๋ฉฐ, ๊ธธ์ด๋ฅผ ๋ณ๊ฒฝํ ์ ์๋ค.
๋ฐ๋ผ์ ๊ฐ๋จํ๊ฒ ์ฐธ/๊ฑฐ์ง 2๊ฐ์ง ์ํ๋ฅผ ๊ฐ๋ ๊ฒฝ์ฐ ์ฌ์ฉ๋๋ค.
๋จ์ผ 16-bit ์ ๋์ฝ๋ ๋ฌธ์์ด๋ฉฐ, '\u0000' ~ '\uffff'
๊น์ง ๋ํ๋ผ ์์๋ค.
7bit์ ASCII ์ฝ๋์ ํ์ฅ์ผ๋ก 16bit์ ์ ๋์ฝ๋๋ฅผ ์ฌ์ฉ
8bit ๋จ์์ ์ ์๋ฅผ ์ ์ฅํ ์ ์๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ด ๋๋ ํ์
์ด๋ฉฐ, -128~127
๊น์ง ์๋ฅผ ๋ํ๋ผ ์ ์๋ค.
๋ณดํต ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ์ด ๊ฐ์ฅ ํ์ํ ํฐ ๋ฐฐ์ด ์์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ํ๋ด๋ ์ฉ๋๋ก ๋ง์ด ์ฌ์ฉ๋๋ค.
16bit์ ๋ถํธ๊ฐ ์กด์ฌํ๋ ์ ์๋ฅผ ์ ์ฅํ ์ ์์ผ๋ฉฐ, -32,768~32,757
์ฌ์ด์ ์๋ฅผ ๋ํ๋ผ ์ ์๋ค.
byte ํ์
๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ์ฝ ํ ์ ์๋ค.
๋ฉ๋ชจ๋ฆฌ ์ ์ฝ์ ์ํด byte์ short๋ฅผ ์ฌ์ฉํ์ง ์๋ํ ์ผ๋ฐ์ ์ผ๋ก ์ ์๋ฅผ ์ ์ฅํ๊ธฐ์ int ํ์ ๋ง์ด ์ฌ์ฉํ๋ค.
32bit์ ๋ถํธ๊ฐ ์กด์ฌํ๋ ์ ์๋ฅผ ์ ์ฅํ ์ ์๊ธฐ์ -2,147,483,648(-2^31^)~2,147,483,647(2^31^-1)
์ ์๋ฅผ ๋ํ๋ผ ์ ์๋ค.
int ํ์
๋ณด๋ค ๋ ๋ง์ ์๊ฐ ํ์ํ ๋๊ฐ ์กด์ฌํ๋๋ฐ ์ด ๋ ์ฌ์ฉํ๋ ๊ฒ์ด long ํ์
์ด๋ค.
-9,223,372,036,854,775,808(-2^63^)~9,223,372,036,854,775,807(2^63^ -1)
์ ์๋ฅผ ๋ํ๋ผ ์ ์๋ค.
int ํ๊ณผ ๊ตฌ๋ถ์ง๊ธฐ ์ํด ์ซ์ ๋ค์ L
์ ๋ถํ๋ค.
32bit์ ๋ถ๋ ์์์ ๊ฐ์ ๋ํ๋ด๋ฉฐ ๊ฐ์ ๋ฒ์๋ 3.4 X 10^-38^ ~ 3.4 X 10^38^
์ด๋ค.
๋ฌด์ ํ์ด์ง๋ง ๋งค์ฐ ํฐ ์๋ฅผ ๋ํ๋ผ ๋๋ double ํ์
์ผ๋ก ๋ํ๋ด๋ ๊ฒ์ด ์ข์ผ๋ฉฐ, ๋ถ๋ ์์์ ์ด๊ธฐ ๋๋ฌธ์ ์ค์ฐจ๊ฐ ์์ ์ ์๋ค.
๋ฐ๋ผ์ ์ ํํ ๊ฐ์ ์๊ตฌํ๋ ์์คํ
์์ ์ฌ์ฉํ๋ฉด ์๋๋ค.
double๊ณผ ๊ตฌ๋ถ์ง๊ธฐ ์ํด ์ซ์ ๋ค์ f
๋ฅผ ๋ถํ๋ค.
๋ถ๋ ์์์ ์ 1.11212... ๊ณผ ๊ฐ์ด ๋ฌด์ ํ์ผ๋ก ๋ํ๋ผ ์ ์๋ ์ค์ ๊ฐ์ ์ปดํจํฐ๊ฐ ์ ํํ๊ฒ ์ธก์ ํ ์ ์๊ธฐ ๋๋ฌธ์ ๊ทผ์ฌํ ๊ฐ์ผ๋ก ๊ณ์ฐ์ ํ๊ธฐ ์ํด ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ด๋ค.
1bit์ ๋ถํธ ๋นํธ๋ฅผ ๊ฐ์ง๊ณ , 8bit์ ์ง์๋นํธ(float, double์ 11bit) ๋๋จธ์ง ๋นํธ๋ฅผ ๊ฐ์๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ์ ๋ํ๋ธ๋ค.
64bit์ ๋ถ๋ ์์์ ๊ฐ์ ๋ํ๋ด๋ฉฐ, 1.7 X 10^-308^~1.7 X 10^308^
์ฌ์ด์ ๊ฐ์ ๋ํ๋ผ ์ ์๋ค.
์ด ๋ํ ๋ถ๋ ์์์ ์ ์ฌ์ฉํ๋ฏ๋ก ์ ํํ ๊ฐ์ ํ๋จํ๋ ๊ณณ์ ์ฌ์ฉํ๋ฉด ์๋๋ค.
float๊ณผ ๊ตฌ๋ถ์ง๊ธฐ ์ํด ์ซ์ ๋ค์ d
๋ฅผ ๋ถํ๋ค.
๊ธฐ๋ณธํ์ ์ ์ธํ ๋ชจ๋ ํ์
ํน์ java.lang.Object
๋ฅผ ์์ ๋ฐ๊ฒ ๋๋ค๋ฉด ์ฐธ์กฐํ ํ์
์ด ๋๋ค.
๊ธฐ๋ณธํ๊ณผ ๋ฌ๋ฆฌ ๊ธฐ๋ณธ๊ฐ์ผ๋ก ๋น ๊ฐ์ฒด๋ฅผ ์๋ฏธํ๋ Null
๊ฐ์ ์ฌ์ฉํ ์ ์๋ค.
์ฐธ์กฐํ์ ๊ฒฝ์ฐ, ์คํ ์์ญ์ ๋ฐ๋ก ๊ฐ์ ์ ์ฅํ๋ ๊ธฐ๋ณธํ๊ณผ๋ ๋ฌ๋ฆฌ ํ ์์ญ์ ์ธ์คํด์ค๋ฅผ ์์ฑํ๊ฒ ๋๋ค.
์ด๋ฅผ ํธ๋ค๋งํ๊ธฐ ์ํด ์คํ ์์ญ์ ํ ์์ญ์ ์ธ์คํด์ค๋ฅผ ์ฐธ์กฐํ ์ ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ฐ์ ๊ฐ์ง๊ณ ์๊ฒ ๋๋ค.
๋ค์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด array_1
,array_2
์ ๊ฐ์ด ๋ฐฐ์ด(์ฐธ์กฐํ ๋ฐ์ดํฐ ํ์
)์ ์ ์ธ์์๋ ํ ์์ญ์ ์์ฑ์ด ๋๋ค.(๊ฐ๋จํ ๊ทธ๋ฆผ)
๋ง์ฝ ๋ค์ ์ฝ๋์ ๊ฐ์ด array_2
์ array_1
๊ฐ ์์ฒด๋ฅผ ํ ๋นํ๋ค๋ฉด ์ด๋ป๊ฒ ๋ ๊น?
array_2 = array_1;
๋ฐ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ์คํ ์์ญ์ ๊ฐ์ ํ ์์ญ์ ์ฐธ์กฐํ๋ ์ฃผ์ ๊ฐ์ด๋ฏ๋ก array_2
๊ฐ์ array_1
์ ์ฃผ์ ๊ฐ์ด ๋ค์ด๊ฐ ์ฐธ์กฐํ๋ ์ธ์คํด์ค๊ฐ ๋ฐ๋๊ฒ ๋๋ค.
์ด๋ฅผ ์์ ๋ณต์ฌ๋ผ๊ณ ํ๋ฉฐ, ์ฐธ์กฐ๊ฐ ๋์ง ์๋ ์ธ์คํด์ค๋ ๊ฐ๋น์ง ์ปฌ๋ ํฐ์ ์ํด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํด์ ๋นํ๋ค.
๊ทธ ๋ฐ๋๋ก ๊น์ ๋ณต์ฌ๋ ๋ฐฐ์ด ์์ฒด์ ๊ฐ์ ๋ณ๊ฒฝํ์ฌ ๋ณต์ฌ๋ฅผ ํ๋ค.
for(int idx = 0; idx < array_1.size(); idx++){
array_2[idx] = array_1[idx];
}
์ด๋ฌํ ํน์ง์ ๊ฐ์ง ์ฐธ์กฐํ ๋ฐ์ดํฐ ํ์ ์ ๋ํ์ ์ธ ์๋ก ๋ฐฐ์ด(array), ์ด๊ฑฐ(enum), ์ธํฐํ์ด์ค(interface), ํด๋์ค(class) ํ์ ์ด ์กด์ฌํ๋ค.
๋ฐฐ์ด ํ์ ์ ๊ธฐ๋ณธํ ํน์ ์ฐธ์กฐํ์ผ๋ก๋ ๋ง๋ค ์ ์๋ค.
int [] numArr = new int[5]; //๊ธฐ๋ณธํ
int [][] twoDimenNumArr = new int[5][5]; //[][]๋ฅผ ์ฌ์ฉํ๋ฉด 2์ฐจ์ ๋ฐฐ์ด์ ๋ง๋ค ์ ์๋ค.
Object[] objectArr = new Object[5]; //์ฐธ์กฐํ
์ด๊ฑฐ ํ์ ์ ๊ฒฝ์ฐ, ๋ถ๋ณ ๊ฐ์ฒด์ด๋ฉฐ ์์๋ค์ ์งํฉ ํน์ ์ด๋ ํ ๊ฐ์ฒด์ ์ํ๋ค์ ์งํฉ์ ๋ง๋ค ๋ ๊ฐ๋ ์ฑ์ด ๋์ ์ฝ๋๋ฅผ ์ ๊ณตํ๋ค.
enum BloodType {
A, B, O, AB
}
์ธํฐํ์ด์ค๋ฅผ ์ ์ธํ๊ฒ ๋๋ฉด ์ฐธ์กฐํ ๋ฐ์ดํฐ ํ์
์ ๋ง๋๋ ๊ฒ๊ณผ ๊ฐ๋ค.
์ฆ, ์์ ์ ๊ตฌํํ ๊ฐ์ฒด์ ์ฃผ์๋ฅผ ๊ฐ์ง๊ณ ์๋ค๋ ๊ฒ์ด๋ค.
interface CalcInterface<T> {
T add(T value, T value);
T sub(T value, T value);
T mul(T value, T value);
T div(T value, T value);
}
ํด๋์ค ํ์ ์ ๊ฒฝ์ฐ, ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๋ ํํ๋ฅผ ๋๋ค.
class Person {
private String name;
private int age;
Person(String name, int age){
this.name = name;
this.age = age;
}
}
์๋ฐ์์ ๋ชจ๋ ํด๋์ค ํ์ ๋ค์ Object Class๋ฅผ ์ง์ ํน์ ๊ฐ์ ์ผ๋ก ์์ํ๊ณ ์๋ค.
-
Object Class
ํด๋์ค ๊ณ์ธต๊ตฌ์กฐ์์ ๋ฃจํธ ํด๋์ค๋ก ๊ธฐ๋ณธํ ๋ฐ์ดํฐ ํ์ ์ด ์๋ ๊ฒฝ์ฐ(๋ฐฐ์ด, ์ด๊ฑฐ, ์ธํฐํ์ด์ค ๋ฑ๋ฑ), ์ด Object ํด๋์ค๋ฅผ ์ง์ /๊ฐ์ ์ ์ผ๋ก ์์ํ๋ค.
์ด Object ํด๋์ค๋ java.lang ํจํค์ง ์์ ์กด์ฌํ๋ฉฐ, import ๋ฌธ์ ์ฌ์ฉํ์ง ์์๋ ๋ฐ๋ก ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
๋ชจ๋ ํด๋์ค๋ Object ํด๋์ค๋ฅผ ์์ํ๋ฏ๋ก ์ด ์์ ์๋ ๋ฉ์๋๋ค์ ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ฉฐ, ์ด๋ค์ ํด๋์ค ์ธ์คํด์ค ์์ฑ๊ณผ ์๋ฉธ ๋ฑ์ ์๋ช ์ฃผ๊ธฐ ๊ด๋ฆฌ ๋ฐ ๋น๊ต, ํด๋์ค ์ ๋ณด ํ์ธ ์์ ๋ฑ์ ์ํํ๋ค.- clone() - ๊ฐ์ฒด์ ๋์ผํ ํด๋์ค์ ์๋ก์ด ๊ฐ์ฒด๋ฅผ ์์ฑ
- toString() - ๊ฐ์ฒด๋ฅผ ํํํ๋ ๋ฌธ์์ด์ ๋ฐํ
- equals(Object) - ๋ ๊ฐ์ฒด์ ๋น๊ต
- finalize() - ๋ฉ๋ชจ๋ฆฌ ํ์์ ํธ์ถ
์ด๋ฌํ Object ํด๋์ค๋ฅผ ์์ํ๋ ๋ฐ์ดํฐ ํ์ ๊ด๋ จ ํด๋์ค๋ก๋ String, Wrapper ํด๋์ค๊ฐ ์กด์ฌํ๋๋ฐ ํ๋์ฉ ์ดํด๋ณด์.
-
String Class
String์ ๊ฒฝ์ฐ ์ฐธ์กฐํ์ ์ํ๋ ์ฌ์ฉ์ ๊ธฐ๋ณธํ๊ณผ ๊ฐ์ด ์ฌ์ฉํ ์ ์๋ค. ๋ํ, ๋ถ๋ณ(immutable) ๊ฐ์ฒด๋ก ํญ์ ์๋ก์ด ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด ํ ๋น์ ํ๋ค.
String name = "jongnan"; name += "a"; //๊ธฐ์กด ๋ฌธ์์ด์ ์ฌ์ฉํ๋ ๊ฒ์ด ์๋, jongnana์ด๋ผ๋ ์๋ก์ด ๋ฌธ์์ด์ ์์ฑ System.out.println(name); //output : jongnana
-
Wrapper Class
๊ธฐ๋ณธํ์ ๊ฒฝ์ฐ ๊ฐ์ฒด๊ฐ ์๋๋ฏ๋ก ๊ธฐ๋ณธ ๊ฐ์ด ๋ค ์ ํด์ ธ ์์ผ๋ฉฐ
null
๊ฐ์ผ๋ก ์ง์ ํ ์ ์๋ค.
๋ํ, ์๋ฐ์ ๊ฒฝ์ฐ ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ด๋ฏ๋ก ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํด์ผํ ๊ฒฝ์ฐ๊ฐ ์๋ค.-
์ง๋ ฌํ(Serialization)
์ง๋ ฌํ๋ฅผ ํ๊ธฐ ์ํด์๋ ๊ฐ์ฒด๋ก ๋ณ๊ฒฝ์ด ํ์
-
๋๊ธฐํ(Synchronization)
์๋ฐ์์ ๋ฉํฐ ์ค๋ ๋ฉ ์์์ ๋๊ธฐํ๋ ๊ฐ์ฒด๋ฅผ ๊ฐ์ง๊ณ ๋์ํ๋ค.
-
Collection Framework
์๋ฐ ์ปฌ๋ ์ ํ๋ ์์ํฌ๋ ๊ฐ์ ๊ฐ์ฒด๋ก๋ง ์ฒ๋ฆฌํ๋ค.
๋ค์๊ณผ ๊ฐ์ ๊ฒฝ์ฐ๊ฐ ์๊ธฐ ๋๋ฌธ์ ๊ธฐ๋ณธํ์์ ์ฐธ์กฐํ์ผ๋ก ๋ณ๊ฒฝ์ ํด์ผ๋๋๋ฐ ์ด๋ ์ฌ์ฉํ๋ ๊ฒ์ด Wrapper ํด๋์ค์ด๋ค.
Wrapper ํด๋์ค๋ ๋ค์๊ณผ ๊ฐ์ด ๊ธฐ๋ณธํ๊ณผ ๋งค์นญ์ด ๋๋ค.
Primitive Type Wrapper Class boolean Boolean byte Byte short Short int Integer long Long float Float double Double char Character ๋ณดํต ๊ธฐ๋ณธํ โ ์ฐธ์กฐํ์ Boxing, ๊ทธ ๋ฐ๋์ธ ์ฐธ์กฐํ โ ๊ธฐ๋ณธํ์ Unboxing์ด๋ผ๊ณ ํ๋ค.
JDK 1.5 ์ด์ ๋ฒ์ ์ ๊ฒฝ์ฐ ํด๋น ๊ณผ์ ์ ์๋์ผ๋ก ํด์ฃผ์ด์ผ ํ์ง๋ง, JDK 1.5 ์ด์๋ถํฐ๋ Autoboxing์ ์ง์ํ๋ค.int primNum = 20; Integer autoWrapperNum = primNum; //AutoBoxing Integer wrapperNum = new Integer(primNum); //Boxing int unBoxedNum = (int)wrapper; //Unboxing
-
- Data Types in Java - java T point
- Wrapper classes in Java - java T point
- ์๋ฐ์ ๋ณ์์ ๋ฐ์ดํฐ ํ์ (Java Variables & Data type)
- [JAVA] Primitive type๊ณผ Reference type ๊ทธ๋ฆฌ๊ณ Object ํด๋์ค
- ์๋ฐ์ ๋ฐ์ดํฐ ํ์ (Primitive type, Reference type)
- ์๋ฐ ์๋ฃํ ์ ๋ฆฌ(Java Data Type