Gibt es eine Java -Funktion oder eine Util -Klasse, die so rundet: Func (3/2) = 2?

StackOverflow https://stackoverflow.com/questions/1074228

  •  21-08-2019
  •  | 
  •  

Frage

Gibt es eine Java -Funktion oder eine Util class Was auf diese Weise rundet: func(3/2) = 2

Math.ceil() Hilft nicht, was mit Namen hätte tun sollen. Ich bin mir bewusst, dass BigDecimal, aber brauche es nicht.

War es hilfreich?

Lösung

Math.ceil() wird immer zusammenfassen, aber Sie machen eine ganzzahlige Abteilung mit 3/2. So seit in der Ganzzahl Division 3/2 = 1 (nicht 1.5) die Decke von 1 ist 1.

Was Sie tun müssen, um die gewünschten Ergebnisse zu erzielen, ist Math.ceil(3/2.0);

Durch die Abteilung um eine doppelte Menge (2.0), Sie führen am Ende eine schwimmende Punktdivision anstelle einer Ganzzahl -Division. Daher 3/2.0 = 1.5, und die ceil() von 1.5 ist immer 2.

Andere Tipps

Ein bisschen schwarze Magie, und Sie können alles mit Ganzzahlen machen:

// Divide x by n rounding up
int res = (x+n-1)/n

Sie können immer zuerst werfen:

Math.ceil((double)3/2)

Um die Bodenabteilung in die Decke umzuwandeln: Abteilung:

(numerator + denominator-1) / denominator

Um die Bodenabteilung in die Rundung der Division umzuwandeln:

(numerator + (denominator)/2) / denominator

In Java, 3/2 = 1, weil es eine Ganzzahl -Division verwendet. Es gibt keine Funktion, die dies danach "beheben" kann. Was Sie tun müssen, ist, eine Schwimmerteilung zu erzwingen und das Ergebnis zu runden:

int result = (int)Math.ceil( ((float)3) / ((float)2) );

Ist dies nicht der übliche Fall einer Ganzzahl -Division? Versuchen Sie es mit Math.CEIL, nachdem Sie eine der beiden Nummer zu einem schwimmenden Punkttyp geworfen haben.

Viele Sprachen "denken" so. Wenn Sie ein INT in ein INT aufteilen, sollten Sie ein INT bekommen (damit sie abschneiden und Sie 1 als Ergebnis erhalten).

Wir alle wissen, dass dies nicht wahr ist, aber so funktionieren sie. Sie können sie "betrügen" und so etwas wie ein Doppelgast machen oder eine doppelte Darstellung verwenden: Math.ceil (3.0 / 2) oder Math.ceil((double)3/2), wie erwähnt.

Math.ceil Wille Hilfe, vorausgesetzt, Sie verwenden schwimmende Punktzahlen. Das Problem ist, dass 3/2, in Ganzzahl -Division 1 ist. Wenn der Wert zu jeder Funktion kommt, sei es mathematisch.

if (a % b == 0)
{
  return (a / b);
}
else
{
  return (a / b) + 1;
}

Nutzt die Ganzzahl -Division, um das zu tun, was Sie wollen. Ich weiß keine Mathematikfunktion, die dies tut, aber warum nicht Ihre eigene rollen?

Unterhalb des Fragments funktioniert auch mit negativen Ganzzahlen:

public static int divRoundUp(int x, int n) {
    if (n<=0) throw new RuntimeException("conceived wt. pos. dividers (was:"+n+")");
    int ret = (x+(n-1)*(x>0?1:0))/n;
    return ret;
}

Ich mag Randy Proctors Antwort am besten. Hier detaillierter:

Wenn Sie echte Rundung (dh 3/2 -> 2, aber 17/7 -> 2) mit Ganzzahlen> 0: Verwenden möchten (dividend + (divisor / 2)) / divisor Anstatt von dividend / divisor.

Wenn eine Dividende eine ganze Zahl sein kann (dh negativ erlaubt):(dividend >= 0) ? ((dividend + divisor / 2) / divisor) : ((dividend - divisor / 2) / divisor).

Wenn eine Dividende eine Ganzzahl und Trenner ist eine Ganzzahl, aber 0:(dividend >= 0) ? ((dividend + Math.abs(divisor) / 2) / divisor) : ((dividend - Math.abs(divisor) / 2) / divisor).

(Beachten Sie, dass der Zugabe und die Substraktion zu einem Umlauf führen können, der sonst nicht auftreten würde, was das Ergebnis falsch macht.)

Hier ist eine Methode, die ich erstellt habe, um die INT -Division zu behandeln, ohne Mathematikrunde zu verwenden und zu kämpfen, um zu schweben. Dies funktioniert für positive und negative Zahlen. Es funktioniert, indem es die Hälfte des Nenner hinzufügt, um die Abundung auszugleichen

public static int div_Int(int num, int den){
    if(num > 0 && den > 0 || num < 0 && den < 0 ){
        return ((2*num)+ den)/(2*den);  
    }else{
        return ((2*num)- den)/(2*den);
    }

}

Wenn Sie sich nur um 2 teilen möchten, können Sie:

n - n / 2

Und allgemein:

(n - 1) / d + 1 == (n + d - 1) / d

Dies gilt für nicht negative ganze Zahlen. Wie man es auf negative Ganzzahlen ausdehnt, hängt davon ab, was Sie mit "Rundung auf diese Weise" meinen. Integer Division ist in Richtung Null abgerundet, während Math.ceil() Runden und Math.floor() Runden. Zum Beispiel n / 2 != (int) Math.floor(n / 2.0) zum n == -5.

Wenn Sie sich immer zusammenschließen möchten, können Sie verwenden Math.ceil() wie in Diese Antwort.

Wenn Sie wirklich vermeiden möchten, Ceil und Casting zu verwenden, finden Sie hier eine kleine Methode, die dasselbe erreicht.

public int findCeil(int X, int Y) {
        if (X % Y == 0){
            return X / Y;
        } else {
            return X / Y + 1;
        }
    }

Hast du es versucht Math.floor() ?

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top