์์ ์ ํ | ๋ฉ๋ชจ๋ฆฌ ํฌ๊ธฐ | ๊ฐ ๋ฒ์ |
---|---|---|
๋ฐ์ดํธ | 8๋นํธ | -128 ~ 127 |
์งง์ | 16๋นํธ | -32768 ~ 32767 |
์ฏ | 16๋นํธ | 0 ~ 65536 |
์ ์ | 32๋นํธ | -2147483648 ~ 2147483647 |
๊ธด | 64๋นํธ | -9223372036854775808 ~ 9223372036854775807 |
๋จ๋ค | 32๋นํธ | (2์ -149์น) ~ ((2์ -23์น) * 2์ 127์น) |
๋๋ธ | 64๋นํธ | (-2์ 63์น) ~ ((2์ 63์น) - 1) |
๋ถ์ธ | 8(๋ฐฐ์ด๋ก ์ฌ์ฉํ๋ ๊ฒฝ์ฐ), 32(๋ฐฐ์ด๋ก ์ฌ์ฉํ์ง ์๋ ๊ฒฝ์ฐ) | ์ฐธ ๋๋ ๊ฑฐ์ง |
public class Main {
public static void main(String[] args) {
BigInteger integer = new BigInteger("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
System.out.println(integer);
BigDecimal decimal = new BigDecimal("123.444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444");
System.out.println(decimal);
}
}
๋ฌธ์์ด์ ์์ฑ์์ ์ ๋ฌํ๋ ๊ฒ์ ๊ฐ๋ฅํ ์ต์
์ค ํ๋์ผ ๋ฟ์
๋๋ค. ์ฌ๊ธฐ์ ์ฐ๋ฆฌ๋ ์ซ์๊ฐ long ๋ฐ double ์ ์ต๋๊ฐ์ ์ด๊ณผํ๊ธฐ ๋๋ฌธ์ ๋ฌธ์์ด์ ์ฌ์ฉํฉ๋๋ค. ์ปดํ์ผ๋ฌ์๊ฒ ์ด๋ค ์ซ์๋ฅผ ๋ง๋ค๊ณ ์ถ์์ง ์ค๋ช
ํ ๋ฐฉ๋ฒ์ด ํ์ํฉ๋๋ค. 111111111111111111111111111111111111111111111111111111111111111111111 ์์ฑ์์ ๋ํ ์์
์ ์๋ํ์ง ์์ต๋๋ค. Java๋ ์ ๋ฌ๋ ์ซ์๋ฅผ ๊ธฐ๋ณธ ๋ฐ์ดํฐ ์ ํ ์ค ํ๋๋ก ๋ฐ์ด ๋ฃ์ผ๋ ค๊ณ ์๋ํ์ง๋ง ๊ทธ ์ค ์ด๋ ๊ฒ์๋ ๋ง์ง ์์ต๋๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ๋ฌธ์์ด์ ์ฌ์ฉํ์ฌ ์ํ๋ ์ซ์๋ฅผ ์ ๋ฌํ๋ ๊ฒ์ด ์ข์ ์ ํ์
๋๋ค. ๋ ํด๋์ค ๋ชจ๋ ์ ๋ฌ๋ ๋ฌธ์์ด์์ ์ซ์ ๊ฐ์ ์๋์ผ๋ก ์ถ์ถํ ์ ์์ต๋๋ค. ํฐ ์ซ์์ ํด๋์ค๋ก ์์
ํ ๋ ๊ธฐ์ตํด์ผ ํ ๋ ๋ค๋ฅธ ์ค์ํ ์ ์ ๊ฐ์ฒด๊ฐ ๋ถ๋ณ( Immutable )์ด๋ผ๋ ๊ฒ์
๋๋ค. ๊ธฐ๋ณธ ์ ํ(Integer, Long ๋ฑ)์ ๋ํ ๋ํผ ํด๋์ค ๋ฐ String ํด๋์ค ์ ๋ํ ๊ฒฝํ ๋๋ถ์ ์ด๋ฏธ ๋ถ๋ณ์ฑ์ ๋ํด ์ ์๊ณ ์์ต๋๋ค .
import java.math.BigInteger;
public class Main {
public static void main(String[] args) {
BigInteger integer = new BigInteger("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
System.out.println(integer);
integer.add(BigInteger.valueOf(33333333));
System.out.println(integer);
}
}
์ฝ์ ์ถ๋ ฅ:
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
์์ํ์
จ๊ฒ ์ง๋ง ์ ํฌ ๋ฒํธ๋ ๋ณ๊ฒฝ๋์ง ์์์ต๋๋ค. ๋ํ๊ธฐ ์ฐ์ฐ์ ์ํํ๋ ค๋ฉด ์ฐ์ฐ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ์ ์ ๊ฐ์ฒด๋ฅผ ์์ฑํด์ผ ํฉ๋๋ค.
import java.math.BigInteger;
public class Main {
public static void main(String[] args) {
BigInteger integer = new BigInteger("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
System.out.println(integer);
BigInteger result = integer.add(BigInteger.valueOf(33333333));
System.out.println(result);
}
}
์ฝ์ ์ถ๋ ฅ:
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111144444444
๋ณด์ธ์, ์ด์ ๋ชจ๋ ๊ฒ์ด ์ ์์ ์ผ๋ก ์๋ํฉ๋๋ค :) ๊ทธ๋ฐ๋ฐ, ๋ง์
์ฐ์ฐ์ด ์ผ๋ง๋ ํน์ดํ์ง ๋์น์ฑ์
จ๋์?
BigInteger result = integer.add(BigInteger.valueOf(33333333));
์ด๊ฒ์ ๋ ๋ค๋ฅธ ์ค์ํ ํฌ์ธํธ์
๋๋ค. ํฐ ์ซ์ ํด๋์ค๋ + - * / ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ง ์์ต๋๋ค. ๋์ ์ผ๋ จ์ ๋ฉ์๋๋ฅผ ์ ๊ณตํฉ๋๋ค. ์ฃผ์ ๋ฐฉ๋ฒ์ ๋ํด ์์๋ณด๊ฒ ์ต๋๋ค(ํญ์ ๊ทธ๋ ๋ฏ์ด Oracle ์ค๋ช
์( ์ฌ๊ธฐ ๋ฐ ์ฌ๊ธฐ )์์ ์ ์ฒด ๋ฐฉ๋ฒ ๋ชฉ๋ก์ ์ฐพ์ ์ ์์ต๋๋ค ).
-
์ฐ์ ์ฐ์ฐ์ ์ํ ๋ฉ์๋: add() , ๋บ์ () , multiply() , divide() . ์ด๋ฌํ ๋ฐฉ๋ฒ์ ๊ฐ๊ฐ ๋ง์ , ๋บ์ , ๊ณฑ์ ๋ฐ ๋๋์ ์ ์ํํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
-
doubleValue() , intValue() , floatValue() , longValue() ๋ฑ์ ํฐ ์ซ์๋ฅผ Java์ ๊ธฐ๋ณธ ์ ํ ์ค ํ๋๋ก ๋ณํํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ์ด๋ฌํ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ ๋๋ ์ฃผ์ํ์ญ์์ค. ๋นํธ ํฌ๊ธฐ์ ์ฐจ์ด๋ฅผ ์์ง ๋ง์ธ์!
import java.math.BigInteger; public class Main { public static void main(String[] args) { BigInteger integer = new BigInteger("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"); long result = integer.longValue(); System.out.println(result); } }
์ฝ์ ์ถ๋ ฅ:
8198552921648689607
-
min() ๋ฐ max()๋ฅผ ์ฌ์ฉ ํ๋ฉด ๋ ๊ฐ์ ํฐ ์ซ์์ ์ต์๊ฐ๊ณผ ์ต๋๊ฐ์ ์ฐพ์ ์ ์์ต๋๋ค.
์ด๋ฌํ ๋ฉ์๋๋ ์ ์ ์ด ์๋๋๋ค!import java.math.BigInteger; public class Main { public static void main(String[] args) { BigInteger integer = new BigInteger("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"); BigInteger integer2 = new BigInteger("222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"); System.out.println(integer.max(integer2)); } }
์ฝ์ ์ถ๋ ฅ:
222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
BigDecimal ๋ฐ์ฌ๋ฆผ ๋์
ํฐ ์ซ์๋ฅผ ๋ฐ์ฌ๋ฆผํ๊ณ ๋ฐ์ฌ๋ฆผ ๋์์ ๊ตฌ์ฑํ๋ ๊ฒ์ด ๊ทธ๋ ๊ฒ ๊ฐ๋จํ์ง ์๊ธฐ ๋๋ฌธ์ ์ด ํญ๋ชฉ์๋ ๋ณ๋์ ์น์ ์ด ์์ต๋๋ค. setScale() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ BigDecimal ์ ์์ ์๋ฆฟ์๋ฅผ ์ค์ ํ ์ ์์ต๋๋ค . ์๋ฅผ ๋ค์ด ์ซ์ 111.5555555555์ ์์์ ์ดํ ์ธ ์๋ฆฌ๋ฅผ ์ํ๋ค๊ณ ๊ฐ์ ํฉ๋๋ค. ๊ทธ๋ฌ๋ ์ซ์ 3์ setScale() ๋ฉ์๋ ์ ์ธ์๋ก ์ ๋ฌํ์ฌ ์ํ๋ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์์ต๋๋ค . ์์์ ์ธ๊ธํ๋ฏ์ด BigDecimal๊ณ์ฐ ์ ๋ฐ๋์ ๋ํ ์๊ฒฉํ ์๊ตฌ ์ฌํญ์ด ์๋ ์ซ์๋ฅผ ํํํ๊ธฐ ์ํ ๊ฒ์ ๋๋ค. ํ์ฌ ํ์์์ ์ซ์๋ ์์์ ์ดํ 10์๋ฆฌ์ ๋๋ค. 7๊ฐ๋ฅผ ๋ฒ๋ฆฌ๊ณ 3๊ฐ๋ง ๋จ๊ธฐ๊ณ ์ ํฉ๋๋ค. ๋ฐ๋ผ์ ์ซ์ 3 ์ธ์ ๋ฐ์ฌ๋ฆผ ๋ชจ๋๋ฅผ ํต๊ณผํด์ผ ํฉ๋๋ค. BigDecimal์๋ ์ด 8๊ฐ์ ๋ฐ์ฌ๋ฆผ ๋ชจ๋๊ฐ ์์ต๋๋ค. ๋ง์ด! ๊ทธ๋ฌ๋ ๊ณ์ฐ์ ์ ๋ฐ๋๋ฅผ ๋ฏธ์ธํ๊ฒ ์กฐ์ ํด์ผ ํ๋ค๋ฉด ํ์ํ ๋ชจ๋ ๊ฒ์ ๊ฐ์ถ๊ฒ ๋ ๊ฒ์ ๋๋ค. BigDecimal ์์ ์ ๊ณตํ๋ 8๊ฐ์ง ๋ฐ์ฌ๋ฆผ ๋ชจ๋๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค .-
ROUND_CEILING โ ๋ฐ์ฌ๋ฆผ
111.5555555555 -> setScale(3, ROUND_CEILING) -> 111.556
-
ROUND_DOWN โ 0์ผ๋ก ๋ฐ์ฌ๋ฆผ
111.5555555555 -> setScale(3, ROUND_DOWN) -> 111.555
-
ROUND_FLOOR โ ๋ด๋ฆผ
111.5555555555 -> setScale(3, ROUND_FLOOR) -> 111.555
-
ROUND_HALF_UP โ ์์์ ์ดํ ์ซ์ >= 0.5์ธ ๊ฒฝ์ฐ ๋ฐ์ฌ๋ฆผ
0.55 -> setScale(1, ROUND_HALF_UP) -> 0.6 0.54 -> setScale(1, ROUND_HALF_UP) -> 0.5
-
ROUND_HALF_DOWN โ ์์์ ์ดํ ์ซ์ > 0.5์ธ ๊ฒฝ์ฐ ๋ฐ์ฌ๋ฆผ
0.55 -> setScale(1, ROUND_HALF_DOWN) -> 0.5 0.56 -> setScale(1, ROUND_HALF_DOWN) -> 0.6
-
ROUND_HALF_EVEN โ ๋ฐ์ฌ๋ฆผ์ ์์์ ์ผ์ชฝ์ ์๋ ์ซ์์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋๋ค. ์ผ์ชฝ์ ์ซ์๊ฐ ์ง์์ด๋ฉด ๋ฐ์ฌ๋ฆผ๋ฉ๋๋ค. ์์์ ์ผ์ชฝ์ ์ซ์๊ฐ ํ์์ด๋ฉด ๋ฐ์ฌ๋ฆผ๋ฉ๋๋ค.
2.5 -> setScale(0, ROUND_HALF_EVEN) -> 2
์์์ ์ผ์ชฝ์ ์ซ์๋ 2(์ง์)์ ๋๋ค. ์ซ์๋ ๋ด๋ฆผํฉ๋๋ค. ์์์ ์ดํ ์๋ฆฟ์ 0์ ์ํ๋ฏ๋ก ๊ฒฐ๊ณผ๋ 2์ ๋๋ค.
3.5 -> setScale(0, ROUND_HALF_EVEN) -> 4
์์์ ์ผ์ชฝ์ ์ซ์๋ 3(ํ์)์ ๋๋ค. ์ซ์๋ ๋ฐ์ฌ๋ฆผ๋ฉ๋๋ค. ์ฐ๋ฆฌ๋ ์์ ์๋ฆฟ์๊ฐ 0์ด๊ธฐ๋ฅผ ์ํ๋ฏ๋ก ๊ฒฐ๊ณผ๋ 4์ ๋๋ค.
-
ROUND_UNNECCESSARY โ ์ด ๋ชจ๋๋ ๋ฐ์ฌ๋ฆผ ๋ชจ๋๋ฅผ ๋ฉ์๋์ ์ ๋ฌํด์ผ ํ์ง๋ง ์ซ์๋ฅผ ๋ฐ์ฌ๋ฆผํ ํ์๊ฐ ์๋ ๊ฒฝ์ฐ์ ์ฌ์ฉ๋ฉ๋๋ค. ROUND_UNNECCESSARY ๋ชจ๋๊ฐ ์ค์ ๋ ์ํ์์ ์ซ์๋ฅผ ๋ฐ์ฌ๋ฆผํ๋ ค๊ณ ํ๋ฉด ArithmeticException์ด ๋ฐ์ํฉ๋๋ค.
3.51 -> setScale(1, ROUND_UNNECCESSARY) -> ArithmeticException
-
ROUND_UP โ 0์์ ๋ฉ์ด์ง๋ ๋ฐฉํฅ์ผ๋ก ๋ฐ์ฌ๋ฆผํฉ๋๋ค.
111.5551 -> setScale(3, ROUND_UP) -> 111.556
ํฐ ์ซ์ ๋น๊ต
์ด๊ฒ์ ๋ํ ์ค์ํฉ๋๋ค. equals() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ Java์์ ๊ฐ์ฒด๋ฅผ ๋น๊ตํ๋ค๋ ๊ฒ์ ๊ธฐ์ตํ ๊ฒ์ ๋๋ค . ๊ตฌํ์ ์ธ์ด ์์ฒด(ํ์ค Java ํด๋์ค์ ๊ฒฝ์ฐ)์์ ์ ๊ณตํ๊ฑฐ๋ ํ๋ก๊ทธ๋๋จธ๊ฐ ์ฌ์ ์ํฉ๋๋ค. ๊ทธ๋ฌ๋ BigDecimal ๊ฐ์ฒด ์ ๊ฒฝ์ฐ ๋น๊ต๋ฅผ ์ํด equals() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ๊ถ์ฅ๋์ง ์์ต๋๋ค. BigDecimal.equals() ๋ฉ์๋๋ 2๊ฐ์ ์ซ์๊ฐ ๋์ผํ ๊ฐ๊ณผ ๋ฐฐ์จ์ ๊ฐ๋ ๊ฒฝ์ฐ์๋ง true๋ฅผ ๋ฐํํ๊ธฐ ๋๋ฌธ์ ๋๋ค . Double ๋ฐ BigDecimal ํด๋์ค ์ ๋ํ equals() ๋ฉ์๋ ์ ๋์์ ๋น๊ตํด ๋ณด๊ฒ ์ต๋๋ค .import java.math.BigDecimal;
public class Main {
public static void main(String[] args) {
Double a = 1.5;
Double b = 1.50;
System.out.println(a.equals(b));
BigDecimal x = new BigDecimal("1.5");
BigDecimal y = new BigDecimal("1.50");
System.out.println(x.equals(y));
}
}
์ฝ์ ์ถ๋ ฅ:
true
false
๋ณด์ ๋ค์ํผ BigDecimal ์ ๊ฒฝ์ฐ ์ซ์ 1.5์ 1.50์ด ๊ฐ์ง ์์ ๊ฒ์ผ๋ก ๋ํ๋ฌ์ต๋๋ค! ์ด๊ฒ์ ์ ํํ BigDecimal ํด๋์ค ์ equals() ๋ฉ์๋ ๊ตฌํ์ ํน์ฑ ๋๋ฌธ์ด์์ต๋๋ค . ๋ ๊ฐ์ BigDecimal ๊ฐ์ฒด๋ฅผ ๋ณด๋ค ์ ํํ๊ฒ ๋น๊ตํ๋ ค๋ฉด compareTo() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์ต๋๋ค .
import java.math.BigDecimal;
public class Main {
public static void main(String[] args) {
BigDecimal x = new BigDecimal("1.5");
BigDecimal y = new BigDecimal("1.50");
System.out.println(x.compareTo(y));
}
}
์ฝ์ ์ถ๋ ฅ:
0
compareTo () ๋ฉ์๋๋ 0์ ๋ฐํํ์ผ๋ฉฐ ์ด๋ 1.5์ 1.50์ด ๊ฐ๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ด๊ฒ์ ์ฐ๋ฆฌ๊ฐ ์์ํ ๊ฒฐ๊ณผ์
๋๋ค! :) ์ด๊ฒ์ผ๋ก ์ค๋ ์์
์ ๋ง์นฉ๋๋ค. ์ด์ ์์
์ผ๋ก ๋์๊ฐ ์๊ฐ์
๋๋ค! :)