java - una - resultado de 7/8(3/4+5/6)+6/5(3/4-1/2)
¿Por qué es el resultado de 1/3== 0? (13)
(1/3) significa división entera, es por eso que no puede obtener el valor decimal de esta división. Para resolver este problema, use:
public static void main(String[] args) {
double g = 1.0 / 3;
System.out.printf("%.2f", g);
}
Estaba escribiendo este código:
public static void main(String[] args) {
double g = 1 / 3;
System.out.printf("%.2f", g);
}
El resultado es 0. ¿Por qué es esto y cómo resuelvo este problema?
1 y 3 son contajes enteros, por lo que Java hace una división entera cuyo resultado es 0. Si desea escribir constantes dobles, debe escribir 1.0 y 3.0 .
Deberías usar
double g=1.0/3;
o
double g=1/3.0;
La división entera devuelve un entero.
Explícitamente echarlo como un double
double g = 1.0/3.0
Esto sucede porque Java usa la operación de división de enteros para 1 y 3 ya que los ingresó como constantes enteras.
Haga que el 1 sea una flotante y se usará la división flotante
public static void main(String d[]){
double g=1f/3;
System.out.printf("%.2f",g);
}
Haz "doble g = 1.0 / 3.0;" en lugar.
La conversión en JAVA es bastante simple, pero necesita cierta comprensión. Como se explica en el JLS para operaciones enteras :
Si un operador entero distinto de un operador de desplazamiento tiene al menos un operando de tipo largo, entonces la operación se lleva a cabo utilizando una precisión de 64 bits, y el resultado del operador numérico es de tipo largo. Si el otro operando no es largo, primero se amplía (§5.1.5) para escribir largo por promoción numérica (§5.6).
Y un ejemplo es siempre la mejor manera de traducir el JLS;)
int + long -> long
int(1) + long(2) + int(3) -> long(1+2) + long(3)
De lo contrario, la operación se lleva a cabo utilizando una precisión de 32 bits, y el resultado del operador numérico es de tipo int. Si ninguno de los operandos es un int, primero se amplía para escribir int por promoción numérica.
short + int -> int + int -> int
Un pequeño ejemplo usando Eclipse para mostrar que incluso una adición de dos short no será tan fácil:
short s = 1;
s = s + s; <- Compiling error
//possible loss of precision
// required: short
// found: int
Esto requerirá un casting con una posible pérdida de precisión.
Lo mismo es cierto para los operadores de punto flotante
Si al menos uno de los operandos de un operador numérico es de tipo doble, entonces la operación se lleva a cabo utilizando una aritmética de punto flotante de 64 bits, y el resultado del operador numérico es un valor de tipo doble. Si el otro operando no es un doble, primero se amplía (§5.1.5) para escribir double por promoción numérica (§5.6).
Entonces la promoción se realiza en el flotador en doble.
Y la combinación de valores tanto enteros como flotantes da como resultado valores flotantes como se dijo
Si al menos uno de los operandos de un operador binario es de tipo coma flotante, entonces la operación es una operación de punto flotante, incluso si la otra es integral.
Esto es cierto para los operadores binarios pero no para los "Operadores de Asignación" como +=
Un simple ejemplo de trabajo es suficiente para probar esto
int i = 1;
i += 1.5f;
La razón es que hay un elenco implícito hecho aquí, esto se ejecutará como
i = (int) i + 1.5f
i = (int) 2.5f
i = 2
Los dos operandos (1 y 3) son enteros, por lo tanto, se utiliza la aritmética de enteros (división aquí). Declarar la variable de resultado como doble solo provoca una conversión implícita después de la división .
La división entera del curso devuelve el resultado verdadero de la división redondeada hacia cero. El resultado de 0.333... se redondea así a 0 aquí. (Tenga en cuenta que el procesador no hace ningún redondeo, pero puede pensarlo de esa manera).
Además, tenga en cuenta que si ambos operandos (números) se dan como flotantes; 3.0 y 1.0, o incluso solo el primero , luego se usa la aritmética de coma flotante, que le da 0.333...
Muchos otros no han podido señalar el verdadero problema:
Una operación solo en enteros arroja el resultado de la operación a un número entero.
Esto necesariamente significa que los resultados de punto flotante, que podrían mostrarse como un entero, se truncarán (separe la parte decimal).
¿Qué es el casting (encasillado / conversión de tipo) que preguntas?
Varía según la implementación del idioma, pero Wikipedia tiene una visión bastante completa, y también habla de coacción , que es una pieza clave de información para responder a su pregunta.
Porque estás haciendo una división entera.
Como dice @Noldorin, si ambos operadores son enteros, entonces se usa la división entera.
El resultado 0.33333333 no se puede representar como un entero, por lo tanto, solo la parte entera (0) se asigna al resultado.
Si alguno de los operadores es un double / float , entonces se realizará la aritmética de coma flotante. Pero tendrás el mismo problema si haces eso:
int n = 1.0 / 3.0;
Porque trata a 1 y 3 como números enteros, por lo tanto, redondea el resultado a 0, de modo que es un número entero.
Para obtener el resultado que está buscando, explique explícitamente a java que los números se duplican así:
double g = 1.0/3.0;
1/3 usa división de enteros ya que ambos lados son enteros.
Necesita al menos uno de ellos para float o double .
Si está ingresando los valores en el código fuente como su pregunta, puede hacer 1.0/3 ; el 1.0 es un doble.
Si obtiene los valores de otra parte, puede usar (double) para convertir el int en un double .
int x = ...;
int y = ...;
double value = ((double) x) / y;
public static void main(String[] args) {
double g = 1 / 3;
System.out.printf("%.2f", g);
}
Dado que tanto 1 como 3 son enteros, el resultado no es redondeado, pero está truncado. Entonces ignoras fracciones y tomas solo totalidades.
Para evitar esto, tenga al menos uno de sus números 1 o 3 como una forma decimal 1.0 y / o 3.0.