How to get biggest BigDecimal value

How can I get the largest possible value of a BigDecimal variable can hold? (Preferably programmatically, but hardcoding would be ok too)

EDIT

OK, just realized there is no suc开发者_StackOverflowh thing since BigDecimal is arbitrary precision. So I ended up with this, which is sufficiently big for my purpose:

BigDecimal my = BigDecimal.valueOf(Double.MAX_VALUE)

Its an arbitrary precision class, it will get as large as you'd like until your computer runs out of memory.

Looking at the source BigDecimal stores it as a BigInteger with a radix,

private BigInteger intVal;
private int scale;

and from BigInteger

/** All integers are stored in 2's-complement form.
63:    * If words == null, the ival is the value of this BigInteger.
64:    * Otherwise, the first ival elements of words make the value
65:    * of this BigInteger, stored in little-endian order, 2's-complement form. */
66:   private transient int ival;
67:   private transient int[] words;

So the Largest BigDecimal would be,

ival = Integer.MAX_VALUE;
words = new int[Integer.MAX_VALUE]; 
scale = 0;

You can figure out how to set that. :P

[Edit] So just to calculate that, In binary that's,

(2^35)-2 1's (I think?)

in 2's complement

01111111111111111...until your RAM fills up.

Given enough RAM, the value is approximately:

2²⁴⁰*10²³²

(It's definitely out by a few orders of magnitude but in relative terms it's a very precise estimate.)

You can represent 2^2147483647-1 however after this value some methods do not work as expected. It has 646456993 digits.

System.out.println(BigInteger.ONE.shiftLeft(Integer.MAX_VALUE)
                                 .subtract(BigInteger.ONE).bitLength());

prints

2147483647

however

System.out.println(BigInteger.ONE.shiftLeft(Integer.MAX_VALUE).bitLength());

prints

-2147483648

as there is an overflow in the number of bits.

BigDecimal.MAX_VALUE is large enough that you shouldn't need to check for it.

You can store Integer.MAX_VALUE + 1 integers in the magnitude, because arrays count from zero. All those integers got 32 bits, because they're all handled unsigned. So the precision in bits is 32*2147483648 = 68719476736 Bits (=8589934592Byte=8GiB=8,6GB). To get the precision in Decimals, you'll have to multiply the precision in Bits with log10(2) so you'll get 20686623783 full decimal digits, way over 4 times more, than a String can store. Now you can pow 10 with this amount of digits and subtract 1 to get the maximal BigDecimal value, but don't try to calculate it with BigDecimal itself. ;)

But now the question is... What comes first? The method .precision(), which is limited to Integer.MAX_VALUE or my calculated precision?