import java.math.BigDecimal;
์ด๋ ๊ฒ ์ ์ธํ๊ณ ์์ํ๋ฉฐ double, float๋ณด๋ค ํฐ์, ์์์๋ฅผ ๊ณ์ฐํ๋ ์ฉ๋
double, float๋ณด๋ค ์ค์ฐจ๋ ์ ์ง๋ง, ํ๋ก๊ทธ๋จ์ ๋ฌด๊ฑฐ์ ์ง๋๊ฒ ๋จ์ ...
BigDecimal BigA = new BigDecimal("3");
BigDecimal BigB = BigDecimal.valueOf(100);
๊ธฐ๋ณธ์ ์ธ ์ ์ธ์ ์ด๋ ๊ฒ new๋ฅผ ์ฌ์ฉํ ๋์๋ ๋ฌด์กฐ๊ฑด string์ผ๋ก ๋ฃ์ด์ฃผ๊ณ , double๋ก ๋ฃ๊ณ ์ถ์ ๊ฒฝ์ฐ์๋ valueOf๋ฅผ ์ฌ์ฉํ๋ค.
์ฌ๊ธฐ์ ๋ฌธ์ ๋ ๋ณ์ ์ ์ธ!
string์ผ๋ก๋ double๋ก๋ ๋ค์ด๊ฐ์ง ์๊ธฐ ๋๋ฌธ์ stringํ์ผ๋ก ๋ณํํด ์ฃผ์ด์ผ ํ๋ค.
BigDecimal BigC = new BigDecimal(String.valueOf(c));
์ด ์ ์ธ์ด ๋๋ฌด ๊ธธ์ด ๊ฐ์ฅ ์์ฃผ ์ฌ์ฉํ๋ 0, 1, 10์ ์์๋ก ์ ์๋์ด ์๋ค.
๊ทธ๋ฅ ์ ์๋ ๋๋ก ์ ์ธํ๋ฉด ๋๋ค.
BigDecimal.ZERO
BigDecimal.ONE
BigDecimal.TEN
์ฌ๊ธฐ์์ ์ฌ์น์ฐ์ฐ์ ํ๊ณ ์ถ๋ค๋ฉด?
BigDecimal์ ์๋ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค!
BigA.add(BigB);
BigA.subtract(BigB);
BigA.multiply(BigB);
BigA.divide(BigB);
BigA.remainder(BigB);
์ฌ์น์ฐ์ฐ +, -, *, /์ ๋์ ๋๊ณ remainer๋ %๊ธฐํธ, ๋๋จธ์ง๋ฅผ ๊ตฌํ๋ ๋ฉ์๋์ด๋ค.
์ฌ๊ธฐ์ ์ฃผ์ํ ์ ์ divide() ๋ฉ์๋์ด๋ค!
๊ทธ๋ฅ ๋๋๊ฐ์ ์ถ๋ ฅํ๋ ค๊ณ ํ๋ฉด ๋ฐํ์ ์๋ฌ ๋ฐ์๐ข
divide() ๋ฉ์๋์ ์ธ์๋ก ํผ์ฐ์ฐ์, ์ถ๋ ฅํ ์๋ฆฌ์, ์ฌ๋ฆผ๋ด๋ฆผ ์ค์ ๊ฐ ์ ์ง์ ํด ์ฃผ์ด์ผ ํ๋ค.
System.out.println(BigA.divide(BigB, 9, ROUND_CEILING));
๋น๊ต์ฐ์ฐ๋ ๋น์ทํ๊ฒ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
BigA.equal(BigB);
BigA.compareTo(BigB);
๋ฉ์๋๊ฐ ๋ค์ํ ๋ฏํ๋ค. ์ต์๊ฐ, ์ต๋๊ฐ์ ๊ตฌํ ๋์๋
BigA.min(BigB);
BigA.max(Big.B);
๊ณ์ฐ์ ๊ผญ ์์ ๋ฉ์๋๋ค๋ก ํด์ผํ๋ค.
ํ์ ์ฌ์ฉํ๋ ์ฐ์ฐ์๋ค์ ์ฌ์ฉํ๋ฉด ์ ๋ถ ์๋ฌ..๐ญ
String์ด๋ valueOf๋ ๋์ค์...
ํ ์ ์์์ง๋ ๋ชจ๋ฅด๊ฒ ์ง๋ง??
'PROGRAMING > JAVA' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๊ฐ์ฒด์งํฅํ๋ก๊ทธ๋๋ฐ ํท๊ฐ๋ฆฌ๋ ์ฉ์ด (0) | 2019.11.13 |
---|---|
๋ฐฑ์ค java ์ปดํ์ผ ์๋ฌํด๊ฒฐ - ํด๋์ค๋ช (0) | 2019.11.11 |