1. ๋ž˜ํผ ์œ ํ˜• ๋ชฉ๋ก

Java์—๋Š” ํด๋ž˜์Šค๊ฐ€ ์•„๋‹Œ ์œ ํ˜•์ธ 8๊ฐœ์˜ ๊ธฐ๋ณธ ์œ ํ˜•์ด ์žˆ๋‹ค๋Š” ๊ฒƒ์„ ์•Œ๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. ํ•œํŽธ์œผ๋กœ ์ด๊ฒƒ์€ ์ข‹์Šต๋‹ˆ๋‹ค. ๊ฐ„๋‹จํ•˜๊ณ  ๊ณต๊ฐ„์„ ๊ฑฐ์˜ ์ฐจ์ง€ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ๋ฐ˜๋ฉด์— ๋•Œ๋•Œ๋กœ ์ˆ˜์—…์€ ์šฐ๋ฆฌ์—๊ฒŒ ๊ผญ ํ•„์š”ํ•œ ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๋‹ค์Œ ๊ฐ•์˜์—์„œ ๊ทธ ์ด์œ ๋ฅผ ์ •ํ™•ํžˆ ์•Œ๊ฒŒ ๋  ๊ฒƒ์ž…๋‹ˆ๋‹ค.

๊ทธ๋ž˜์„œ ๋ฌด์—‡์„ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๊นŒ?

Java์˜ ๋‹ค์„ฏ ๋ฒˆ์งธ ๋ฒ„์ „๋ถ€ํ„ฐ ๊ฐ ๊ธฐ๋ณธ ์œ ํ˜•์— ํŠธ์œˆ ํด๋ž˜์Šค๊ฐ€ ์ถ”๊ฐ€๋˜์—ˆ์Šต๋‹ˆ๋‹ค. ์ด๋Ÿฌํ•œ ๊ฐ ํด๋ž˜์Šค๋Š” ํŠน์ • ์œ ํ˜•์˜ ๊ฐ’์ด ์žˆ๋Š” ๋‹จ์ผ ํ•„๋“œ๋ฅผ ์ €์žฅํ•ฉ๋‹ˆ๋‹ค. ์ด๋Ÿฌํ•œ ํด๋ž˜์Šค๋Š” ๊ธฐ๋ณธ ๊ฐ’์„ ํด๋ž˜์Šค๋กœ ๋ž˜ํ•‘ํ•˜๊ธฐ ๋•Œ๋ฌธ์— ๋ž˜ํผ ์œ ํ˜• ์ด๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค .

๋‹ค์Œ์€ ์ด๋Ÿฌํ•œ ์œ ํ˜•์˜ ๋ชฉ๋ก์ž…๋‹ˆ๋‹ค. ์•Œ๊ณ  ๊ณ„์‹ญ๋‹ˆ๊นŒ?

์›์‹œ ์œ ํ˜• ๋ž˜ํผ ํด๋ž˜์Šค
byte
Byte
short
Short
int
Integer
long
Long
float
Float
double
Double
char
Character
boolean
Boolean

๊ธฐ๋ณธ ์œ ํ˜•์˜ ์ด๋ฆ„์€ ์†Œ๋ฌธ์ž๋กœ ์‹œ์ž‘ํ•˜์ง€๋งŒ ๋ž˜ํผ ํด๋ž˜์Šค์˜ ์ด๋ฆ„์€ ๋Œ€๋ฌธ์ž๋กœ ์‹œ์ž‘ํ•ฉ๋‹ˆ๋‹ค. ์ผ๋ถ€ ํด๋ž˜์Šค ์ด๋ฆ„์€ ์กฐ๊ธˆ ๋” ๊น๋‹ˆ๋‹ค: Integerinstead of intะธ Characterinstead of char.

๋ž˜ํผ ํด๋ž˜์Šค์˜ ๋ชจ๋“  ๊ฐœ์ฒด๋Š” ๋ณ€๊ฒฝํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค( immutable ).

ํด๋ž˜์Šค ์˜ ๋‹จ์ˆœํ™”๋œ ์ฝ”๋“œ๋Š” Integer๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

์•”ํ˜ธ ๋ฉ”๋ชจ
public class Integer
{
   private int value;

   Integer(int x)
   {
      this.value = x;
   }

   public int intValue()
   {
      return this.value;
   }

   public static Integer valueOf(int x)
   {
      return new Integer(x);
   }
}


๋ณ€์ˆ˜

์ƒ์„ฑ์ž ์ด




๋ฉ”์„œ๋“œ๋Š” ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์ •์  ๋ฉ”์„œ๋“œ๋Š” ๋ณ€์ˆ˜ ์— ๋Œ€ํ•œ




์ƒˆ ๊ฐœ์ฒด๋ฅผ ๋งŒ๋“ญ๋‹ˆ๋‹ค.Integerint

2. an์„ intan๋กœ ๋ณ€ํ™˜Integer

๋ž˜ํผ ์œ ํ˜•์€ ๊ธฐ๋ณธ ์œ ํ˜•์— ํ•ด๋‹นํ•˜๋Š” ๊ฒƒ์œผ๋กœ ๊ฐ„์ฃผ๋ฉ๋‹ˆ๋‹ค. ๊ธฐ๋ณธ ์œ ํ˜•์— ํ•ด๋‹นํ•˜๋Š” ๋ž˜ํผ ๊ฐœ์ฒด๋ฅผ ์‰ฝ๊ฒŒ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๊ธฐ๋ณธ ์œ ํ˜•์ด ํ•ด๋‹น ๋ž˜ํผ ์œ ํ˜•๊ณผ ์ƒํ˜ธ ์ž‘์šฉํ•˜๋Š” ๋ฐฉ์‹์„ ๋ถ„์„ํ•˜๊ธฐ ์œ„ํ•ด int ์œ ํ˜•์„ ์˜ˆ๋กœ ์‚ฌ์šฉํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค. intan์—์„œ an์œผ๋กœ ๋˜๋Š” ๊ทธ ๋ฐ˜๋Œ€๋กœ ๋ณ€ํ™˜ํ•˜๋Š” ์ฝ”๋“œ๋Š” Integer๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

intan์„ ๋กœ ๋ณ€ํ™˜ํ•˜๋ ค๋ฉด Integer๋‹ค์Œ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

Integer name = new Integer(value);

์—ฌ๊ธฐ์„œ name๋Š” ๋ณ€์ˆ˜์˜ ์ด๋ฆ„ Integer์ด๊ณ  ๋Š” value๋ž˜ํ•‘๋œ int๊ฐ’์ž…๋‹ˆ๋‹ค.

์˜ˆ:

์•”ํ˜ธ ๋ฉ”๋ชจ
Integer age = new Integer(18);
Integer hundred = new Integer(100);
Integer zero = new Integer(0);

๊ทธ๋ฆฌ๊ณ  an์„ Integeran๋กœ ๋ณ€ํ™˜ํ•˜๋ ค๋ฉด int๋‹ค์Œ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

int name = variable.intValue();

์—ฌ๊ธฐ์„œ name๋Š” ๋ณ€์ˆ˜์˜ ์ด๋ฆ„ int์ด๊ณ  ๋Š” ๊ฐœ์ฒด variable์— ๋Œ€ํ•œ ์ฐธ์กฐ์ž…๋‹ˆ๋‹ค Integer.

์˜ˆ:

์•”ํ˜ธ ๋ฉ”๋ชจ
Integer age = new Integer(18);
int x = age.intValue();

x == 18
Integer hundred = new Integer(100);
int y = hundred.intValue();

y == 100
Integer zero = new Integer(0);
int z = zero.intValue();


z == 0
int i = 110;
Integer zero = new Integer(i);
int z = zero.intValue();

z == 110

3. ์˜คํ† ๋ฐ•์‹ฑ ๋ฐ ์–ธ๋ฐ•์‹ฑ

ํ•˜์ง€๋งŒ Integerํƒ€์ž…์„ ์ด์šฉํ•œ ๊ฐ„๋‹จํ•œ ์—ฐ์‚ฐ์กฐ์ฐจ๋„ ์ž‘์„ฑํ•˜๊ธฐ ์‰ฝ์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

์ด์ „์— ๋งํ–ˆ๋“ฏ์ด Integer์œ ํ˜•์€ ๋ณ€๊ฒฝํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค( immutable ). Integer์ƒˆ ๊ฐ’์œผ๋กœ ๊ฐœ์ฒด๋ฅผ ๋งŒ๋“ค๋ ค๋ฉด int๋ช…์‹œ์ ์œผ๋กœ ์ƒˆ ๊ฐœ์ฒด๋ฅผ ๋งŒ๋“ค์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค Integer. int์ฆ‰, ๊ฐ์ฒด ๋‚ด๋ถ€์— ์ €์žฅ๋œ ๊ฐ’์„ ๊ฐ€์ ธ์˜ค๋Š” ๊ฒƒ์€ ์‰ฝ์Šต๋‹ˆ๋‹ค Integer. intValue()๋ฉ”์†Œ๋“œ๋ฅผ ํ˜ธ์ถœํ•˜๊ธฐ๋งŒ ํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค.

์˜ˆ:

์•”ํ˜ธ ์„ค๋ช…
Integer a = Integer.valueOf(5);
int b = a.intValue();
Integer c = new Integer(b + 5)
5๊ฐœ์ฒด ๊ฐ์‹ธ๊ธฐ Integer๊ฐœ์ฒด ์—์„œ
๊ฐ’ ๊ฐ€์ ธ์˜ค๊ธฐ ์ƒˆ ๊ฐœ์ฒด ๋งŒ๋“ค๊ธฐ(10๊ณผ ๊ฐ™์Œ)Integer
Integer

์ด๊ฒƒ์€ ๋‹ค์†Œ ์„ฑ๊ฐ€์‹  ์ฝ”๋“œ๋ผ๊ณ  ์ƒ๊ฐํ•˜์ง€ ์•Š์Šต๋‹ˆ๊นŒ?

Java ์ œ์ž‘์ž๋Š” ๊ทธ๋ ‡๊ฒŒ ์ƒ๊ฐํ–ˆ๊ธฐ ๋•Œ๋ฌธ์— ์ปดํŒŒ์ผ๋Ÿฌ์—๊ฒŒ ์ด๋Ÿฌํ•œ ์ž‘์—…์„ ์ž๋™์œผ๋กœ ์ˆ˜ํ–‰ํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ๊ฐ€๋ฅด์ณค์Šต๋‹ˆ๋‹ค. intan์„ an์œผ๋กœ ์ž๋™ ๋ณ€ํ™˜ํ•˜๋Š” ๊ฒƒ์„ autoboxing (๊ฐ’์„ ์ƒ์ž์— ์ž๋™์œผ๋กœ ๋„ฃ์Œ) Integer์ด๋ผ๊ณ  ํ•˜๊ณ , an์„ an์œผ๋กœ ๋ณ€ํ™˜ํ•˜๋Š” ์—ญ ์ž‘์—…์„ unboxing ์ด๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค .Integerint

๊ท€ํ•˜์˜ ์ฝ”๋“œ ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ๋ณด๋Š” ๊ฒƒ
Integer a = 10;
Integer a = Integer.valueOf(10);
int b = a;
int b = a.intValue();
Integer c = a + b;
Integer c = Integer.valueOf(a.intValue() + b);

์˜คํ† ๋ฐ•์‹ฑ ๋ฐ ์–ธ๋ฐ•์‹ฑ ๋•๋ถ„์— ๋ณ€์ˆ˜ int์— ์•ˆ์ „ํ•˜๊ฒŒ ํ• ๋‹นํ•  ์ˆ˜ Integer์žˆ์œผ๋ฉฐ ๊ทธ ๋ฐ˜๋Œ€๋„ ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค. int์™€ ์œ ํ˜• ์„ ๊ตฌ๋ถ„ํ•˜์ง€ ์•Š๊ณ  ๋ณต์žกํ•œ ํ‘œํ˜„์‹์„ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค Integer.

์˜ˆ:

์•”ํ˜ธ ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ์ƒ์„ฑํ•  ๋‚ด์šฉ
Integer a = 5;
int b = a;
Integer c = a + b;
int d = a + b + c;
Integer a = Integer.valueOf(5);
int b = a.intValue();
Integer c = Integer.valueOf(a.intValue() + b);
int d = a.intValue() + b + c.intValue();
Integer a = 5;
int b = 5;

if (a == b)
{
   ...
}
Integer a = Integer.valueOf (5);
int b = 5;

if (a.intValue() == b)
{
   ...
}


4. ๋ž˜ํผ ๋ณ€์ˆ˜ ๋น„๊ต

์˜คํ† ๋ฐ•์‹ฑ ๋ฐ ์–ธ๋ฐ•์‹ฑ์€ ๊ฐ„๋‹จํ•˜๊ณ  ํˆฌ๋ช…ํ•œ ํ”„๋กœ์„ธ์Šค์ž…๋‹ˆ๋‹ค. ํ•„์š”์— ๋”ฐ๋ผ ๋ช…๋ น๋ฌธ์„ ์‚ฌ์šฉ new Integer()ํ•˜๊ณ  ํ•„์š”์— ๋”ฐ๋ผ ๋ฉ”์„œ๋“œ๋ฅผ ํ˜ธ์ถœํ•ฉ๋‹ˆ๋‹ค intValue().

ํ”„๋กœ๊ทธ๋ž˜๋จธ์—๊ฒŒ๋Š” ๋ชจ๋“  ๊ฒƒ์ด ํ›Œ๋ฅญํ•˜๊ณ  ์‰ฝ๊ฒŒ ์ž‘๋™ํ•ฉ๋‹ˆ๋‹ค. an ๊ณผ an ์„ ๋น„๊ตํ•˜๋Š” ๊ฒฝ์šฐ ๋น„๊ต๋Š” ๊ฐ’์ด ์•„๋‹Œ ์ฐธ์กฐ๋ฅผ ๊ธฐ๋ฐ˜์œผ๋กœ ํ•ฉ๋‹ˆ๋‹ค .IntegerInteger

์•”ํ˜ธ ์ฝ˜์†” ์ถœ๋ ฅ
Integer a = 1000;
Integer b = 1000;

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



false
Integer a = 1000;
Integer b = 1000;

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



true

๋ฐ ๋ณ€์ˆ˜ a๋Š” ๊ฐ’์„ b์ €์žฅํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค int. ๊ฐœ์ฒด์— ๋Œ€ํ•œ ์ฐธ์กฐ๋ฅผ ์ €์žฅํ•ฉ๋‹ˆ๋‹ค. ์ฆ‰, ์˜ฌ๋ฐ”๋ฅด๊ฒŒ ๋น„๊ตํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ๊ธฐ์–ตํ•˜๋Š” ๊ฒƒ์ด ์ค‘์š”ํ•ฉ๋‹ˆ๋‹ค.

์ž˜๋ชป๋œ ์˜ค๋ฅธ์ชฝ
Integer a = 1000;
Integer b = 1000;
if (a == b)
{
   ...
}
Integer a = 1000;
Integer b = 1000;
if (a.equals(b))
{
   ...
}