public class Test {
private static double round(double d) {
return ((long) (d < 0 ? d * 100 - 0.5 : d * 100 + 0.5)) / 100.0;
}
public static void main(String ... args){
double mwst = 0.19;
BigDecimal mwBig = BigDecimal.valueOf(0.19);
double lo = 0.0;
double hi = 100.0;
double[] values =
new Random(42)
.doubles(100)
.map(d -> d * ((hi - lo) + lo))
.map(Test::round)
.toArray();
System.out.println(
Arrays.stream(values)
.mapToObj(BigDecimal::valueOf)
.map(b -> b.multiply(mwBig))
.reduce(BigDecimal.ZERO, BigDecimal::add));
System.out.println(
Arrays.stream(values)
.mapToObj(BigDecimal::valueOf)
.reduce(BigDecimal.ZERO, BigDecimal::add)
.multiply(mwBig));
System.out.println(
Arrays.stream(values)
.map(d -> d * mwst).reduce(0.0, (a, b) -> a + b));
System.out.println(
Arrays.stream(values)
.reduce(0.0, (a, b) -> a + b) * mwst
);
}
}
codet @ThreadPool in http://forum.byte-welt.net/threads/13147-BigDecimal-equals?p=104307&viewfull=1#post104307
ist das die neue Java-Welt? wird sowas wirklich intensiv auch für Dummy-Kram wie double/ BigDecimal-Berechnungen verwendet?
ein bedenkenswerter Punkt, der mir gerade auffällt, ist unterschiedliche Behandlung von einzelnen Codezeilen zu Arrays:
bei einem double d schreibst man anscheinend immer noch
BigDecimal brutto = BigDecimal.valueOf(d).multiply(mwBig);
dazu hat eine klassische Schleife a la
BigDecimal sum = BigDecimal.ZERO;
for (int i=0;i<d.length; i++) {
BigDecimal brutto = BigDecimal.valueOf(d**).multiply(mwBig);
sum = sum.add(brutto );
}
viel drumherum Noise, bei welchem man auch Fehler machen kann, aber die wichtige Berechnung kann man zumindest angenehm ähnlich gecodet wiederfinden,
ist es nicht bedenklich, wenn daraus ziemlich verrückt anderes a la
.map(b -> b.multiply(mwBig))
```wird?
keine Gefahr von Übersehen von Rechenzeichen (im double-Fall), Variablen, Konstanten, richtigen Methoden, durch die andere Darstellung?
Gefahr von Nichtfinden bei Textsuche nach dieser Art Code, Aufwand für IDEs bei Refactorn usw?
etwas akzeptabler wäre es für mich ja noch, wenn man die Einzelvariante dann ebenso darstellt:
```double d = ..;
BigDecimal brutto = Pump.up(d).mapToObj(BigDecimal::valueOf).map(b -> b.multiply(mwBig));
nie mehr normale Java-Aufrufe, stattdessen eine Code-Welt von Doppel-Doppelpunkten 
, na soweit wird es wohl nicht kommen
ein gemäßigter Einsatz nur mit map auf Listen, Iteratoren in zentralen Programmklassen, in wenigen % des Code,
nur mit Aufruf von individuellen wichtigen Methoden, statt BigDecimal- oder double-Berechnungen, das ginge ja noch,
bessere Syntax für den im Moment kruden seltenen Einsatz von anonymen inneren Klassen usw.,
aber fast überall für Arrays wie man hier als ein Beispiel sehen kann?
die Aussage aus dem Alten Hasen-Thread
[QUOTE=Bleiglanz]So gesehen wird man als alter Hase ja gerade im Java Umfeld noch lange sein auskommen haben:
Java ohne Generics
mit rohen JDBC-Zugriffen
mit gewaltigen "Swing"er-Orgien
mit java.util.Date und anderen Verrückten
J2EE (vor EJB3) mit riesigen XML-Descriptoren
mit vielen, vielen überflüssigen Casts aus der Zeit vor dem Boxing
Wirrnis ohne das java.util.concurrent Paket
usw. usf.
[/QUOTE]
könnte bald eine weitaus dramatischere Bedeutung haben, wenn Java demnächst keine simplen Schleifen mehr kennt…, eine ganz neue Sprache
