streamalism.org

1. Oversikt

Å dele med null er en operasjon som ikke har noen betydning i vanlig regning og derfor er udefinert. I programmering, men mens det er ofte assosiert med en feil, er dette ikke alltid tilfelle.

I denne artikkelen vil vi gå gjennom hva skjer når en divisjon med null forekommer i et Java-program.

I henhold til Java-spesifikasjonen for delingsoperasjonen kan vi identifisere to forskjellige tilfeller av deling med null: heltall og flytende tall.

2. Heltall

For det første, for heltall, er ting ganske greie. Å dele et heltall med null vil resultere i et Aritmetisk unntak:

assertThrows (ArithmeticException.class, () -> {int result = 12/0;});

assertThrows (ArithmeticException.class, () -> {int result = 0/0;});

3. Flytpunkttyper

Imidlertid når du handler med flytende tall, et unntak vil ikke bli kastet:

assertDoesNotThrow (() -> {float result = 12f / 0;});

For å håndtere tilfeller som disse bruker Java noen spesielle numeriske verdier som kan representere resultatene av en slik operasjon: NaN, POSITIVE_INFINITY, og NEGATIVE_INFINITY.

3.1. NaN

La oss starte med dividere nullverdier med flytende punkt:

assertEquals (Float.NaN, 0f / 0); assertEquals (Double.NaN, 0d / 0);

Resultatet i disse tilfellene er NaN (ikke et tall).

3.2. evighet

Neste, la oss dele noen ikke-nullverdier med null:

assertEquals (Float.POSITIVE_INFINITY, 12f / 0); assertEquals (Double.POSITIVE_INFINITY, 12d / 0); assertEquals (Float.NEGATIVE_INFINITY, -12f / 0); assertEquals (Double.NEGATIVE_INFINITY, -12d / 0);

Som vi kan se er resultatet EVIGHET, avhengig av tegnet til operandene.

Videre kan vi også bruke begrepet negativ null for å komme til NEGATIVE_INFINITY:

assertEquals (Float.NEGATIVE_INFINITY, 12f / -0f); assertEquals (Double.NEGATIVE_INFINITY, 12f / -0f);

3.3. Minne representasjon

Så hvorfor kaster heltallsdeling med null et unntak, mens flytende punktdeling med null ikke gjør det?

La oss se på dette fra et minnepresentasjonsperspektiv. For heltall er det ingen bitmønster som kan brukes til å lagre resultatet av en slik operasjon, mens flytende tall har verdier som NaN eller EVIGHET skal brukes i tilfeller som disse.

La oss nå vurdere den binære representasjonen av en flottør som S EEEEEEE E FFFFFFF FFFFFFFF FFFFFFFF med en bit (S) for tegnet, 8 bits (E) for eksponenten, og resten (F) for mantissen.

I hver av de tre verdiene NaN, POSITIVE_INFINITY, og NEGATIVE_INFINITY, alle biter i eksponentdelen er satt til 1.

EVIGHET har mantissabitene satt til 0, mens NaN har en ikke-null mantissa:

assertEquals (Float.POSITIVE_INFINITY, Float.intBitsToFloat (0b0111111110000000000000000000000000)); assertEquals (Float.NEGATIVE_INFINITY, Float.intBitsToFloat (0b111111111000000000000000000000000000)); assertEquals (Float.NaN, Float.intBitsToFloat (0b1111111110000001000000000000000000)); assertEquals (Float.NaN, Float.intBitsToFloat (0b11111111100000011000000000100000));

4. Oppsummering

For å oppsummere ting, i denne artikkelen så vi hvordan divisjon med null fungerer i Java.

Verdier som EVIGHET og NaN er tilgjengelige for flytende tall, men ikke for heltall. Hvis du deler et heltall med null, vil det resultere i et unntak. Imidlertid for en flyte eller dobbelt, Java tillater operasjonen.

Den komplette koden er tilgjengelig på GitHub.