Ik was deze code aan het schrijven:
public static void main(String[] args) {
double g = 1 / 3;
System.out.printf("%.2f", g);
}
Het resultaat is 0. Waarom is dit en hoe los ik dit probleem op?
Antwoord 1, autoriteit 100%
De twee operanden (1 en 3) zijn gehele getallen, daarom wordt rekenkunde met gehele getallen (hier deling) gebruikt. Het declareren van de resultaatvariabele als dubbel zorgt ervoor dat er na delingeen impliciete conversie plaatsvindt.
Gehele deling retourneert natuurlijk het werkelijke resultaat van deling afgerond naar nul. Het resultaat van 0.333...wordt hier dus naar beneden afgerond op 0. (Merk op dat de processor eigenlijk geen afrondingen doet, maar je kunt het nog steeds zo zien.)
Houd er ook rekening mee dat als beideoperanden (getallen) als floats worden gegeven; 3.0 en 1.0, of zelfs alleen de eerste, daarna wordt rekenkunde met drijvende komma gebruikt, waardoor je 0.333...krijgt.
Antwoord 2, autoriteit 16%
1/3gebruikt gehele getallen omdat beide zijden gehele getallen zijn.
Je hebt er minstens één nodig om floatof doublete zijn.
Als u de waarden in de broncode invoert zoals uw vraag, kunt u 1.0/3; de 1.0is een dubbele.
Als je de waarden ergens anders vandaan haalt, kun je (double)gebruiken om de intom te zetten in een double.
int x = ...;
int y = ...;
double value = ((double) x) / y;
Antwoord 3, autoriteit 6%
Expliciet casten als een double
double g = 1.0/3.0
Dit gebeurt omdat JAVA de werking van het gehele gedeelte van de integer gebruikt voor 1en 3sinds u deze als geheel getal constateert.
4
U moet
gebruiken
double g=1.0/3;
of
double g=1/3.0;
Integer-divisie retourneert geheel getal.
5
Omdat u integer divisie uitvoert.
Zoals @noldorin zegt, als beide operators gehele getallen zijn, wordt getal-divisie gebruikt.
Het resultaat 0.33333333 kan niet worden weergegeven als een geheel getal, daarom is alleen het geheel getal (0) toegewezen aan het resultaat.
Als een van de exploitanten een double/ float, zal drijvend punt rekenkundig plaatsvinden. Maar je hebt hetzelfde probleem als je dat doet:
int n = 1.0 / 3.0;
6
De eenvoudigste oplossing is om dit gewoon te doen
double g = (double) 1 / 3;
Wat dit doet, aangezien u 1,0 / 3.0 niet hebt ingevoerd, laat u het handmatig omzetten naar het Dubbele van het type, omdat Java aannam dat het integer-divisie was, en het zou het doen, zelfs als het de conversie bedoelde. Dit is wat een castoperator wordt genoemd.
Hier worden we slechts één operand, en dit is genoeg om integer-divisie (afronden naar nul) te vermijden
Antwoord 7
Maak van de 1 een float en een float-verdeling wordt gebruikt
public static void main(String d[]){
double g=1f/3;
System.out.printf("%.2f",g);
}
Antwoord 8
De conversie in JAVA is vrij eenvoudig, maar vereist enig begrip. Zoals uitgelegd in de JLS voor gehele operaties:
Als een geheeltallige operator anders dan een shift-operator ten minste één operand van het type long heeft, wordt de bewerking uitgevoerd met 64-bits precisie en is het resultaat van de numerieke operator van het type long. Als de andere operand niet lang is, wordt deze eerst verbreed (§5.1.5) om lang te typen door numerieke promotie (§5.6).
En een voorbeeld is altijd de beste manier om de JLS te vertalen 😉
int + long -> long
int(1) + long(2) + int(3) -> long(1+2) + long(3)
Anders wordt de bewerking uitgevoerd met 32-bits precisie en is het resultaat van de numerieke operator van het type int. Als een van de operanden geen int is, wordt deze eerst uitgebreid om int te typen door middel van numerieke promotie.
short + int -> int + int -> int
Een klein voorbeeld waarin Eclipse wordt gebruikt om te laten zien dat zelfs een toevoeging van twee shorts niet zo eenvoudig zal zijn:
short s = 1;
s = s + s; <- Compiling error
//possible loss of precision
// required: short
// found: int
Dit vereist een casting met mogelijk verlies aan precisie.
Hetzelfde geldt voor de drijvende puntoperators
Als ten minste één van de operanden tot een numerieke operator van het type verdubbelt, wordt de bewerking uitgevoerd met behulp van 64-bits drijvende rekenkundige, en het resultaat van de numerieke operator is een waarde van het type dubbele. Als de andere operand geen dubbel is, wordt het eerst verbreed (§5.1.5) om dubbel te typen door numerieke promotie (§5.6).
Dus wordt de promotie uitgevoerd op de drijver in het dubbele.
en de mix van zowel integer als zwevende waarde resulteren in drijvende waarden als gezegd
Als ten minste één van de operanden tot een binaire operator van het type drijvend punt is, is de bewerking een drijvende werking, zelfs als de andere integraal is.
Dit geldt voor binaire operators, maar niet voor “toewijzingsoperators” zoals +=
Een eenvoudig werkvoorbeeld is genoeg om dit te bewijzen
int i = 1;
i += 1.5f;
De reden is dat er hier een impliciete cast is, dit wordt uitgevoerd als
i = (int) i + 1.5f
i = (int) 2.5f
i = 2
9
1 en 3 zijn gehele getalcenten en dus doet Java een integer-divisie die het resultaat is 0. Als u dubbele constanten wilt schrijven die u moet schrijven 1.0en 3.0.
10
Ik deed dit.
double g = 1.0/3.0;
System.out.printf("%gf", g);
Gebruik .0 Tijdens het doen van dubbele berekeningen of anders gaat Java aan dat u integers gebruikt. Als een berekening elke hoeveelheid dubbele waarden gebruikt, is de uitvoer een dubbele waarde. Als het alle gehele getallen zijn, is de uitvoer een geheel getal.
Antwoord 11
(1/3) betekent gehele deling, daarom kun je geen decimale waarde uit deze deling halen. Gebruik om dit probleem op te lossen:
public static void main(String[] args) {
double g = 1.0 / 3;
System.out.printf("%.2f", g);
}
Antwoord 12
public static void main(String[] args) {
double g = 1 / 3;
System.out.printf("%.2f", g);
}
Omdat zowel 1 als 3 ints zijn, wordt het resultaat niet afgerond maar afgekapt. Dus je negeert breuken en neemt alleen helen.
Om dit te voorkomen, moet u ten minste één van uw cijfers 1 of 3 als decimale vorm 1.0 en/of 3.0 gebruiken.
Antwoord 13
Probeer dit eens:
public static void main(String[] args) {
double a = 1.0;
double b = 3.0;
double g = a / b;
System.out.printf(""+ g);
}
Antwoord 14
Doe “dubbel g=1,0/3.0;” in plaats daarvan.
Antwoord 15
Veel anderen hebben niet op het echte probleem gewezen:
Een bewerking op alleen gehele getallen werpt het resultaat van de bewerking naar een geheel getal.
Dit betekent noodzakelijkerwijs dat resultaten met drijvende komma, die kunnenworden weergegeven als een geheel getal, worden afgekapt (het decimale deel wegknippen).
Wat is casting(typecasting / typeconversie) vraag je?
Het hangt af van de implementatie van de taal, maar Wikipedia heeft een vrij uitgebreid beeld, en het heeft het ook over dwang, wat een cruciaal stuk informatie is bij het beantwoorden van je vraag.
p>