2009-03-20 16 views
21

Quiero saber cómo obtener el resto y el cociente en un solo valor en Java.¿Cómo se dividen para obtener un valor decimal?

Ejemplo:

3/2 que debería obtener valor como 1,5.

Si utilizo el operador / obtengo solo el cociente. Si uso el operador % obtengo solo el resto. ¿Cómo puedo obtener ambos a la vez en la misma variable?

Respuesta

15

En su ejemplo, Java está realizando entero aritmética, redondeando el resultado de la división.

Según su pregunta, le gustaría realizar aritmética de coma flotante. Para ello, al menos uno de sus términos se debe especificar como (o convertidos a) de punto flotante:

Especificación de punto flotante:

3.0/2 
3.0/2.0 
3/2.0 

La conversión a punto flotante:

int a = 2; 
int b = 3; 
float q = ((float)a)/b; 

o

double q = ((double)a)/b; 

(Ver Java Traps: double y Java Floating-Point Number Intricacies para las discusiones sobre float y double)

55
quotient = 3/2; 
remainder = 3 % 2; 

// now you have them both 
+0

en Java no va a funcionar, si lo hace un 1,0% 0,1 – endless

+2

@endless: Es cierto, primero tendrías que convertir a un entero. Y también tendría que especificar lo que quiere decir con el resto de dos flotantes, ya que generalmente se define en términos de aritmética de enteros. – recursive

+0

Solo si alguien repasa esta pregunta y se pregunta cómo obtendría el cociente, pero el número natural más grande <= el cociente o el mod puede usar la función en el paquete matemático: 'Math.floorDiv (x, y)' y 'Math.floorMod (x, y)' –

7

No se preocupe por ella. En su código, simplemente haga las operaciones separadas/y% como usted menciona, aunque parezca ineficaz. Deje que el compilador JIT se preocupe sobre la combinación de estas operaciones para obtener tanto el cociente como el resto en una sola instrucción de máquina (por lo que recuerdo, generalmente lo hace).

8

mira esto: http://download.oracle.com/javase/1,5.0/docs/api/java/math/BigDecimal.html#divideAndRemainder%28java.math.BigDecimal%29

Sólo tiene que envolver su int o largo variable en un BigDecimal objeto y luego invoque la divideAndRemainder método en él. La matriz devuelta contendrá el cociente y el resto (en ese orden).

+0

sugerencia increíble. – Buffalo

+0

Esta es una gran respuesta ya que responde lo que el OP está buscando. Uno necesita preguntar, pero ¿renunciar a usar una primitiva de 32 bits para un BigDecimal contrarrestar cualquier ahorro que teóricamente obtendría (si el compilador no realizó las optimizaciones para usted)? – demongolem

1

Si inicializa los dos parámetros como float, obtendrá el valor real dividido. Por ejemplo:

float RoomWidth, TileWidth, NumTiles; 
RoomWidth = 142; 
TileWidth = 8; 
NumTiles = RoomWidth/TileWidth; 

Ans: 17,75.

1
int a = 3; 
int b = 2; 
float c = ((float)a)/b 
+0

Puede mejorar esta respuesta describiendo brevemente qué hace su código. Por ejemplo, ¿por qué es necesario convertir a a una carroza antes de la división? –

+0

Funcionó. Gracias – JITHIN

0

@ solusion de recursiva (La respuesta aceptada) es 100% correcto. Solo estoy agregando un código de muestra para su referencia.

Mi caso es para mostrar el precio con dos dígitos decimales.Esto es parte de la respuesta de back-end: "price": 2300, "currencySymbol": "CD", ....

Esta es mi clase de ayuda:

public class CurrencyUtils 
{ 
    private static final String[] suffix = { "", "K", "M" }; 

    public static String getCompactStringForDisplay(final int amount) 
    { 
     int suffixIndex; 
     if (amount >= 1_000_000) { 
      suffixIndex = 2; 
     } else if (amount >= 1_000) { 
      suffixIndex = 1; 
     } else { 
      suffixIndex = 0; 
     } 

     int quotient; 
     int remainder; 
     if (amount >= 1_000_000) { 
      quotient = amount/1_000_000; 
      remainder = amount % 1_000_000; 
     } else if (amount >= 1_000) { 
      quotient = amount/1_000; 
      remainder = amount % 1_000; 
     } else { 
      return String.valueOf(amount); 
     } 

     if (remainder == 0) { 
      return String.valueOf(quotient) + suffix[suffixIndex]; 
     } 

     // Keep two most significant digits 
     if (remainder >= 10_000) { 
      remainder /= 10_000; 
     } else if (remainder >= 1_000) { 
      remainder /= 1_000; 
     } else if (remainder >= 100) { 
      remainder /= 10; 
     } 

     return String.valueOf(quotient) + '.' + String.valueOf(remainder) + suffix[suffixIndex]; 
    } 
} 

Ésta es mi clase de prueba (basado en Junit 4):

public class CurrencyUtilsTest { 

    @Test 
    public void getCompactStringForDisplay() throws Exception { 
     int[] numbers = {0, 5, 999, 1_000, 5_821, 10_500, 101_800, 2_000_000, 7_800_000, 92_150_000, 123_200_000, 9_999_999}; 
     String[] expected = {"0", "5", "999", "1K", "5.82K", "10.50K", "101.80K", "2M", "7.80M", "92.15M", "123.20M", "9.99M"}; 

     for (int i = 0; i < numbers.length; i++) { 
      int n = numbers[i]; 
      String formatted = CurrencyUtils.getCompactStringForDisplay(n); 
      System.out.println(n + " => " + formatted); 

      assertEquals(expected[i], formatted); 
     } 
    } 

} 
Cuestiones relacionadas