Jeśli chcesz wydrukować double z dwoma cyframi po przecinku, użyj czegoś takiego:

double value = 200.3456;
System.out.printf("Value: %.2f", value);

Jeśli chcesz mieć wynik w String zamiast być drukowanym na konsoli, użyj String.format() z tymi samymi argumentami:

String result = String.format("%.2f", value);

Lub użyj klasy DecimalFormat:

DecimalFormat df = new DecimalFormat("####0.00");
System.out.println("Value: " + df.format(value));

Myślę, że tak jest łatwiej:

double time = 200.3456;
DecimalFormat df = new DecimalFormat("#.##");      
time = Double.valueOf(df.format(time));

System.out.println(time); // 200.35

Zauważ, że to rzeczywiście będzie zaokrąglanie za Ciebie, a nie tylko formatowanie.

Najłatwiej byłoby zrobić taki trik;

double val = ....;
val = val*100;
val = Math.round(val);
val = val /100;

Jeśli val zaczyna się od 200.3456, to idzie do 20034.56, a następnie zaokrągla się do 20035, a następnie dzielimy go na 200.34.

Jeśli chcesz zawsze zaokrąglać w dół, zawsze możemy obciąć, rzucając do int:

double val = ....;
val = val*100;
val = (double)((int) val);
val = val /100;

Ta technika będzie działać w większości przypadków, ponieważ dla bardzo dużych podwójnych (dodatnich lub ujemnych) może przepełnić. ale jeśli wiesz, że twoje wartości będą w odpowiednim zakresie, to powinno działać dla Ciebie.

Proszę użyć Apache commons math :

Precision.round(10.4567, 2)

function Double round2(Double val) {
    return new BigDecimal(val.toString()).setScale(2,RoundingMode.HALF_UP).doubleValue();
}

Zwróć uwagę na ToString ()!!!!

Są to różne sugerowane metody i ich przypadki niepowodzenia.

// Always Good!
new BigDecimal(val.toString()).setScale(2,RoundingMode.HALF_UP).doubleValue() 

Double val = 260.775d; //EXPECTED 260.78
260.77 - WRONG - new BigDecimal(val).setScale(2,RoundingMode.HALF_UP).doubleValue()

Double val = 260.775d; //EXPECTED 260.78
260.77 - TRY AGAIN - Math.round(val * 100.d) / 100.0d  

Double val = 256.025d; //EXPECTED 256.03d
256.02 - OOPS - new DecimalFormat("0.00").format(val) 
// By default use half even, works if you change mode to half_up 

Double val = 256.025d; //EXPECTED 256.03d
256.02 - FAIL - (int)(val * 100 + 0.5) / 100.0;

double value= 200.3456;
DecimalFormat df = new DecimalFormat("0.00");      
System.out.println(df.format(value));

Jeśli naprawdę chcesz to samo podwójne, ale zaokrąglone w sposób, w jaki chcesz, możesz użyć BigDecimal, na przykład

new BigDecimal(myValue).setScale(2, RoundingMode.HALF_UP).doubleValue();

double d = 28786.079999999998;
String str = String.format("%1.2f", d);
d = Double.valueOf(str);

Zaokrąglanie sobowtóra zazwyczaj nie jest tym, czego się chce. Zamiast tego użyj String.format() reprezentowanie go w pożądanym formacie.

Dla dwóch zaokrąglonych cyfr. Bardzo proste i w zasadzie aktualizujesz zmienną, a nie tylko wyświetlasz cele, które robi DecimalFormat.

x = Math.floor(x * 100) / 100;

value = (int)(value * 100 + 0.5) / 100.0;

W twoim pytaniu, wydaje się, że chcesz uniknąć zaokrąglania liczb, jak również? Tak myślę .format() będzie zaokrąglać liczby za pomocą half-up, afaik?
więc jeśli chcesz zaokrąglać, 200.3456 powinno być 200.35 dla dokładności 2. ale w Twoim przypadku, jeśli chcesz tylko pierwsze 2, a następnie odrzucić resztę?

Można go pomnożyć przez 100, a następnie rzucić do int (lub biorąc głos liczby), przed podzieleniem przez 100 ponownie.

200.3456 * 100 = 20034.56;  
(int) 20034.56 = 20034;  
20034/100.0 = 200.34;

Możesz mieć problemy z naprawdę naprawdę dużym liczby zbliżone do granicy. W takim przypadku konwersja na łańcuch i podłańcuch działa równie łatwo.