If you want 2 / 3 to result in 66.67, you need to multiply first, then divide and round to 2 decimal places:

BigDecimal totalPrep = BigDecimal.valueOf(2);
BigDecimal totalCase = BigDecimal.valueOf(3);

BigDecimal result = totalPrep.multiply(BigDecimal.valueOf(100))
                             .divide(totalCase, 2, RoundingMode.HALF_UP);

System.out.println(result); // prints: 66.67

That will calculate 2 * 100 = 200, then 200 / 3 = 66.67 (rounded)

When you divide first, you calculate 2 / 3 = 0.67 (rounded), then 0.67 * 100 = 67.00, which is obviously not what you want.

I think that the RoundingMode you are looking for is HALF_EVEN. From the javadoc:

Rounding mode to round towards the "nearest neighbor" unless both neighbors are equidistant, in which case, round towards the even neighbor. Behaves as for ROUND_HALF_UP if the digit to the left of the discarded fraction is odd; behaves as for ROUND_HALF_DOWN if it's even. Note that this is the rounding mode that minimizes cumulative error when applied repeatedly over a sequence of calculations.

Here is a quick test case:

Use with AIBigDecimal a = new BigDecimal("10.12345");
BigDecimal b = new BigDecimal("10.12556");

a = a.setScale(2, RoundingMode.HALF_EVEN);
b = b.setScale(2, RoundingMode.HALF_EVEN);

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

Correctly prints:

Use with AI10.12
10.13

UPDATE:

setScale(int, int) has not been recommended since Java 1.5, when enums were first introduced, and was finally deprecated in Java 9. You should now use setScale(int, RoundingMode) e.g:

setScale(2, RoundingMode.HALF_EVEN)

All BigDecimal operations allow to set precision (number of digits after decimal point) and rounding mode.

System.out.println(
    new BigDecimal(1).divide(new BigDecimal(3), 10, RoundingMode.HALF_UP));

will output 0.3333333333. You can create a MathContext object to encapsulate this information. This is helpful since you typically need to do several operations with the same precision and rounding settings.

MathContext mc = new MathContext(10, RoundingMode.HALF_UP);
System.out.println(new BigDecimal(1).divide(new BigDecimal(3), mc));
System.out.println(new BigDecimal(1).divide(new BigDecimal(9), mc));

value = value.setScale(2, RoundingMode.CEILING)

Well this one works...

double roundOff = Math.round(a * 100.0) / 100.0;

Output is

123.14

Or as @Rufein said

 double roundOff = (double) Math.round(a * 100) / 100;

this will do it for you as well.

As specified in javadoc, a BigDecimal is defined by an integer value and a scale.

The value of the number represented by the BigDecimal is therefore (unscaledValue × 10^(-scale)).

So BigDecimal("1761e+5") has scale -5 and BigDecimal(176100000) has scale 0.

The division of the two BigDecimal is done using the -5 and 0 scales respectively because the scales are not specified when dividing. The divide documentation explains why the results are different.

divide

public BigDecimal divide(BigDecimal divisor)

Returns a BigDecimal whose value is (this / divisor), and whose preferred scale is (this.scale() - divisor.scale()); if the exact quotient cannot be represented (because it has a non-terminating decimal expansion) an ArithmeticException is thrown.

Parameters:

divisor - value by which this BigDecimal is to be divided.

Returns:

this / divisor

Throws:

ArithmeticException — if the exact quotient does not have a terminating decimal expansion

Since:

1.5

If you specify a scale when dividing, e.g. dividendo.divide(BigDecimal.valueOf(1000), 0, RoundingMode.HALF_UP) you will get the same result.