How can I resolve mismatches brought about by rounding off?

I am working on a java API with two endpoints. One endpoint has a total amount to be paid, the other one has the breakdown or composition of the total amount in endpoint one. The logic behind is to fetch the values from the DB in currency A and show them to the user in currency B with the exchange rate at 1B = 18.03A. Ideally, the total converted total amount and the sum of the converted breakdown amounts must be the same. In most instances, the code is working fine. There are times though when I have mismatches. Here is an example,
The total amount is 19370.21B from endpoint one. The breakdown (from endpoint two): 124.5B,4245.71B,15000B. Here is what is happening when I do the conversion,

	BigDecimal rate = BigDecimal .valueOf(18.03);
	
	//Converting total amount to currency B
	
    BigDecimal bgtotal = BigDecimal .valueOf(19370.21);	  
    BigDecimal totalToCurB= bgtotal.divide(rate, 2, RoundingMode.HALF_UP);
    System.out.println(totalToCurB);//prints 1074.33
    
   //Converting individual item amounts to currency B and summing them
	BigDecimal itemA = BigDecimal .valueOf(124.5);
	BigDecimal itemB = BigDecimal .valueOf(4245.71);
	BigDecimal itemC = BigDecimal .valueOf(15000);
    BigDecimal itemAToCurB= itemA.divide(rate, 2, RoundingMode.HALF_UP);
	BigDecimal itemBToCurB= itemB.divide(rate, 2, RoundingMode.HALF_UP);
	BigDecimal itemCToCurB= itemC.divide(rate, 2, RoundingMode.HALF_UP);
	
	BigDecimal total = itemAToCurB.add(itemBToCurB).add(itemCToCurB);
    System.out.println(total);//prints 1074.34

How can I avoid such kind of mismatches?

Set bigger scale on the operations. If you are working only with two decimal places on the arithmetic operations it will have discrepancies.

itemAToCurB would be 6.91, itemBToCurB 235.48 and itemCToCurB 831.95, sum of these will be wrong. The itemAToCurB is the issue here as the division is more like 6.90515806988352745424. By rounding half up on second decimal place you just added discrepancy.

When you make these divides with more decimal spaces the rounding will be done on much less significant scale. You can always print just two places.

Something like

BigDecimal rate = BigDecimal .valueOf(18.03);

BigDecimal itemA = BigDecimal .valueOf(124.5);
BigDecimal itemB = BigDecimal .valueOf(4245.71);
BigDecimal itemC = BigDecimal .valueOf(15000);

BigDecimal itemAToCurB= itemA.divide(rate, 20, RoundingMode.HALF_UP);
BigDecimal itemBToCurB= itemB.divide(rate, 20, RoundingMode.HALF_UP);
BigDecimal itemCToCurB= itemC.divide(rate, 20, RoundingMode.HALF_UP);

BigDecimal total = itemAToCurB.add(itemBToCurB).add(itemCToCurB);
System.out.println(total.setScale(2, RoundingMode.HALF_UP));//prints 1074.33

As indicated by Pavel Polivka, the problem has been introduced by scale, increasing it to 3 or 4 decimal places will solve the problem.

Alternatively, you can maintain 2 decimal places but only use one endpoint for both the break downs and total amounts. I.e. instead of calling endpoint 1 to get the total amount, you can instead call endpoint 2 and sum the breakdown amounts.

// Option 1: Increase decimal scale to 3 or 4
BigDecimal rate = BigDecimal .valueOf(18.03);

BigDecimal total = BigDecimal.valueOf(19370.21);
BigDecimal itemA = BigDecimal.valueOf(124.5);
BigDecimal itemB = BigDecimal.valueOf(4245.71);
BigDecimal itemC = BigDecimal.valueOf(15000);

BigDecimal itemAToCurB= itemA.divide(rate, 3, RoundingMode.HALF_UP); //6.905
BigDecimal itemBToCurB= itemB.divide(rate, 3, RoundingMode.HALF_UP); //235.48
BigDecimal itemCToCurB= itemC.divide(rate, 3, RoundingMode.HALF_UP); //831.947

BigDecimal totalA = itemAToCurB.add(itemBToCurB).add(itemCToCurB);
BigDecimal totalB = total.divide(rate, 2, RoundingMode.HALF_UP); 

System.out.println(totalA.setScale(2, RoundingMode.HALF_UP)); //prints 1074.33
System.out.println(totalB.setScale(2, RoundingMode.HALF_UP)); //prints 1074.33

// Option 2: Use total from Endpoint 2, Carrying the rounding-off errors
BigDecimal rate = BigDecimal .valueOf(18.03);

// BigDecimal total = BigDecimal.valueOf(19370.21);
BigDecimal itemA = BigDecimal.valueOf(124.5);
BigDecimal itemB = BigDecimal.valueOf(4245.71);
BigDecimal itemC = BigDecimal.valueOf(15000);

BigDecimal itemAToCurB= itemA.divide(rate, 2, RoundingMode.HALF_UP); //6.91
BigDecimal itemBToCurB= itemB.divide(rate, 2, RoundingMode.HALF_UP); //235.48
BigDecimal itemCToCurB= itemC.divide(rate, 2, RoundingMode.HALF_UP); //831.95

BigDecimal totalA = itemAToCurB.add(itemBToCurB).add(itemCToCurB);
BigDecimal totalB = totalA; 

System.out.println(totalA.setScale(2, RoundingMode.HALF_UP)); //prints 1074.34
System.out.println(totalB.setScale(2, RoundingMode.HALF_UP)); //prints 1074.34