That is achievable using the .compareTo() method. For instance:

if ( price.compareTo( BigDecimal.valueOf( 500 ) > 0 
     && price.compareTo( BigDecimal.valueOf( 1000 ) < 0 ) {
    // price is larger than 500 and less than 1000
    ...
}

Quoting (and paraphrasing) from the JavaDoc:

The suggested idiom for performing these comparisons is: (x.compareTo(y) op 0), where op is one of the six comparison operators [(<, ==, >, >=, !=, <=)]

Cheers,

class BigDecRand {
    public static void main(String[] args) {
        String range = args[0];
        BigDecimal max = new BigDecimal(range + ".0");
        BigDecimal randFromDouble = new BigDecimal(Math.random());
        BigDecimal actualRandomDec = randFromDouble.divide(max,BigDecimal.ROUND_DOWN);

        BigInteger actualRandom = actualRandomDec.toBigInteger();
    }
}

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

Double.MIN_VALUE represents the minimum positive value. (That is, a positive value close to zero.)

From the documentation:

A constant holding the smallest positive nonzero value of type double, 2^-1074.

This is the reason why

System.out.println(inRange(new BigDecimal("0.0")));
System.out.println(inRange(new BigDecimal("-987.0")));

outputs false. None of the provided values are (strictly) greater than 0.

The solution

Since the range of doubles are symmetrical around origo (as opposed to integers, which stretches one step further on the negative side) you can get the minimum (negative) value by writing -Double.MAX_VALUE. That is

BigDecimal DOUBLE_MIN = BigDecimal.valueOf(-Double.MAX_VALUE);

BigDecimal#toPlainString() will give the decimal part . Note it doesnt exactly satisfy your requirements

If you the op formatted , use DecimalFormat

A BigDecimal is defined by two values: an arbitrary precision integer and a 32-bit integer scale. The value of the BigDecimal is defined to be unscaledValue * 10 ^ (-scale).

Precision:

The precision is the number of digits in the unscaled value. For instance, for the number 123.45, the precision returned is 5.

So, precision indicates the length of the arbitrary precision integer. Here are a few examples of numbers with the same scale, but different precision:

• 12345 / 100000 = 0.12345 // scale = 5, precision = 5
• 12340 / 100000 = 0.1234 // scale = 4, precision = 4
• 1 / 100000 = 0.00001 // scale = 5, precision = 1

In the special case that the number is equal to zero (i.e. 0.000), the precision is always 1.

Scale:

If zero or positive, the scale is the number of digits to the right of the decimal point. If negative, the unscaled value of the number is multiplied by ten to the power of the negation of the scale. For example, a scale of -3 means the unscaled value is multiplied by 1000.

This means that the integer value of the ‘BigDecimal’ is multiplied by 10 ^ (-scale).

Here are a few examples of the same precision, with different scales:

• 12345 with scale 5 = 0.12345
• 12345 with scale 4 = 1.2345
• …
• 12345 with scale 0 = 12345
• 12345 with scale -1 = 123450 †

BigDecimal.toString:

The toString method for a BigDecimal behaves differently based on the scale and precision. (Thanks to @RudyVelthuis for pointing this out.)

• If scale == 0, the integer is just printed out, as-is.
• If scale < 0, E-Notation is always used (e.g. 5 scale -1 produces "5E+1")
• If scale >= 0 and precision - scale -1 >= -6 a plain decimal number is produced (e.g. 10000000 scale 1 produces "1000000.0")
• Otherwise, E-notation is used, e.g. 10 scale 8 produces "1.0E-7" since precision - scale -1 equals unscaledValue * 10 ^ (-scale) is less than -6.

More examples:

• 19/100 = 0.19 // integer=19, scale=2, precision=2
• 1/1000 = 0.0001 // integer=1, scale = 4, precision = 1