Pour ce bloc de code:

int num = 5;
int denom = 7;
double d = num / denom;

la valeur de dest 0.0. Il peut être forcé de fonctionner en lançant:

double d = ((double) num) / denom;

Mais existe-t-il un autre moyen d'obtenir le doublerésultat correct ? Je n'aime pas lancer des primitives, qui sait ce qui peut arriver.

double num = 5;

Cela évite un casting. Mais vous constaterez que les conversions de cast sont bien définies. Vous n'avez pas à deviner, vérifiez simplement le JLS . int à double est une conversion élargie. Du §5.1.2 :

L'élargissement des conversions primitives ne perd pas d'informations sur l'ampleur globale d'une valeur numérique.

[...]

La conversion d'une valeur int ou longue en float, ou d'une valeur longue en double, peut entraîner une perte de précision, c'est-à-dire que le résultat peut perdre certains des bits les moins significatifs de la valeur. Dans ce cas, la valeur en virgule flottante résultante sera une version correctement arrondie de la valeur entière, en utilisant le mode arrondi au plus proche IEEE 754 (§4.2.4) .

5 peut être exprimé exactement comme un double.

Qu'y a-t-il de mal à lancer des primitives?

Si vous ne voulez pas lancer de casting pour une raison quelconque, vous pouvez le faire

double d = num * 1.0 / denom;

Je n'aime pas lancer des primitives, qui sait ce qui peut arriver.

Pourquoi avez-vous une peur irrationnelle de lancer des primitifs? Rien de mauvais ne se produira lorsque vous lancerez un intvers un double. Si vous n'êtes tout simplement pas sûr de son fonctionnement, recherchez-le dans la spécification du langage Java . La conversion d' un intvers doubleest une conversion primitive élargie .

Vous pouvez vous débarrasser de la paire de parenthèses supplémentaire en transtypant le dénominateur au lieu du numérateur:

double d = num / (double) denom;

Si vous changez le type de l'une des variables, vous devez vous rappeler d'introduire à nouveau un double si votre formule change, car si cette variable cesse de faire partie du calcul, le résultat est foiré. Je prends l'habitude de lancer le calcul et d'ajouter un commentaire à côté.

double d = 5 / (double) 20; //cast to double, to do floating point calculations

Notez que lancer le résultat ne le fera pas

double d = (double)(5 / 20); //produces 0.0

Cast un des entiers / les deux de l'entier à flotter pour forcer l'opération à effectuer avec Math à virgule flottante. Sinon, les mathématiques entières sont toujours préférées. Alors:

1. double d = (double)5 / 20;
2. double v = (double)5 / (double) 20;
3. double v = 5 / (double) 20;

Notez que la diffusion du résultat ne le fera pas. Parce que la première division se fait selon la règle de priorité.

double d = (double)(5 / 20); //produces 0.0

Je ne pense pas qu'il y ait de problème avec le casting en tant que tel auquel vous pensez.

Le casting de type est le seul moyen

Produire une doubledivision entière - il n'y a pas d'autre moyen sans lancer (peut-être que vous ne le ferez pas explicitement mais cela se produira).

Maintenant, il existe plusieurs façons d'essayer d'obtenir une doublevaleur précise (où numet denomsont le inttype, et bien sûr avec le casting ) -

1. avec un casting explicite:

   • double d = (double) num / denom;
   • double d = ((double) num) / denom;
   • double d = num / (double) denom;
   • double d = (double) num / (double) denom;

mais non double d = (double) (num / denom);

2. avec casting implicite:

   • double d = num * 1.0 / denom;
   • double d = num / 1d / denom;
   • double d = ( num + 0.0 ) / denom;
   • double d = num; d /= denom;

mais pas double d = num / denom * 1.0;
et pasdouble d = 0.0 + ( num / denom );

utilisez quelque chose comme:

double step = 1d / 5;

(1d est un casting à doubler)

Vous pourriez envisager de boucler les opérations. Par exemple:

class Utils
{
    public static double divide(int num, int denom) {
        return ((double) num) / denom;
    }
}

Cela vous permet de rechercher (une seule fois) si le casting fait exactement ce que vous voulez. Cette méthode pourrait également être soumise à des tests, afin de s'assurer qu'elle continue à faire ce que vous voulez. Peu importe la astuce que vous utilisez pour provoquer la division (vous pouvez utiliser n'importe laquelle des réponses ici), tant qu'elle aboutit au résultat correct. Partout où vous avez besoin de diviser deux entiers, vous pouvez maintenant simplement appeler Utils::divideet avoir confiance qu'il fait la bonne chose.

il suffit de l'utiliser.

int fxd=1;
double percent= (double)(fxd*40)/100;

La meilleure façon de le faire est

int i = 3;
Double d = i * 1.0;

d is 3.0 now.