Controleer op null voordat u Parse in Double.parseDouble aanroept

1. Overzicht

Bij het converteren van een Java Draad naar een dubbele, we gebruiken meestal de Double.parseDouble (String-waarde) methode. Met deze methode kunnen we een Draad vertegenwoordiging van een gegeven dubbele - bijvoorbeeld "2.0" - naar een primitief dubbele waarde.

Zoals bij de meeste methodeaanroepen, is het een goede gewoonte om te voorkomen dat een nul referentie, wat waarschijnlijk zal resulteren in een NullPointerException tijdens runtime.

In deze zelfstudie onderzoeken we verschillende manieren waarop we kunnen controleren nul voordat u een beroep doet Double.parseDouble. We beginnen met het overwegen van oplossingen met behulp van core Java voordat we naar enkele externe bibliotheken kijken.

2. Waarom controleren

Laten we eerst eens begrijpen wat gebeurt er als we niet controleren op nul waarden bij het ontleden van een String. Laten we beginnen met het passeren van een lege Draad:

double emptyString = Double.parseDouble ("");

Wanneer we deze code uitvoeren, wordt een java.lang.NumberFormatException:

Uitzondering in thread "main" java.lang.NumberFormatException: lege String op sun.misc.FloatingDecimal.readJavaFormatString (FloatingDecimal.java:1842) op sun.misc.FloatingDecimal.parseDouble (FloatingDecimal.java:110) op java.lang.Double .parseDouble (Double.java:538) ...

Laten we nu eens overwegen om een nul referentie:

double nullString = Double.parseDouble (null);

Het is niet verwonderlijk dat een java.lang.NullPointerException zal deze keer worden gegooid:

Uitzondering in thread "main" java.lang.NullPointerException op sun.misc.FloatingDecimal.readJavaFormatString (FloatingDecimal.java:1838) op sun.misc.FloatingDecimal.parseDouble (FloatingDecimal.java:110) op java.lang.Double.parseDouble ( Dubbel.java:538) ...

Zoals we weten, kan het een goede gewoonte zijn om uitzonderingen te gebruiken in onze applicatiecode. Maar in het algemeen, we moeten dit soort ongecontroleerde uitzonderingen vermijden, die waarschijnlijk het gevolg zijn van een programmeerfout.

3. Hoe u kunt controleren met Core Java

In dit gedeelte zullen we verschillende opties bekijken om op te controleren nul of lege waarden met behulp van core Java.

3.1. Met behulp van Vanilla Java

Laten we beginnen met het definiëren van een eenvoudige methode die controleert of de waarde die we doorgeven is nul of een leeg Draad:

private static double parseStringToDouble (String-waarde) 

Zoals we kunnen zien, is of de waarde die we proberen te ontleden, is nul of leeg deze methode retourneert geen getal. Anders roepen we de Double.parseDouble methode.

We kunnen dit voorbeeld nog een stap verder gaan en de mogelijkheid bieden om een ​​voorgedefinieerde default op te geven:

private static double parseStringToDouble (String value, double defaultValue) retourwaarde == null 

Wanneer we deze methode aanroepen, leveren we een geschikte standaardwaarde om te retourneren als de opgegeven waarde dat is nul of leeg:

assertThat (parseStringToDouble ("1", 2.0d)). isEqualTo (1.0d); assertThat (parseStringToDouble (null, 1.0d)). isEqualTo (1.0d); assertThat (parseStringToDouble ("", 1.0d)). isEqualTo (1.0d);

3.2. Gebruik makend van Optioneel

Laten we nu eens kijken naar een andere oplossing met de gebruik van Optioneel:

private static Optioneel parseStringToOptionalDouble (String-waarde) waarde.isEmpty ()? Optioneel.empty (): Optioneel.of (Double.valueOf (waarde)); 

Deze keer gebruiken we Optioneel als een retourtype. Daarom hebben we, wanneer we deze methode aanroepen, de mogelijkheid om standaardmethoden aan te roepen, zoals is aanwezig() en is leeg() om te bepalen of een waarde aanwezig is:

parseStringToOptionalDouble ("2"). isPresent ()

We kunnen ook een standaardwaarde retourneren met de of anders methode van Optioneel:

parseStringToOptionalDouble ("1.0"). orElse (2.0d) parseStringToOptionalDouble (null) .orElse (2.0d) parseStringToOptionalDouble (""). orElse (2.0d)

4. Externe bibliotheken

Nu we goed begrijpen hoe we moeten controleren op nul en lege waarden met behulp van core Java, laten we eens kijken naar enkele externe bibliotheken.

4.1. Google Guava

De eerste externe oplossing die we zullen bekijken, is Google Guava, die beschikbaar is op Maven Central:

 com.google.guava guave 28.2-jre 

We kunnen gewoon de Doubles.tryParse methode:

Doubles.tryParse (MoreObjects.firstNonNull ("1.0", "2.0")) Doubles.tryParse (MoreObjects.firstNonNull (null, "2.0"))

In dit voorbeeld gebruiken we ook de MoreObjects.firstNonNull methode, die de eerste van twee gegeven parameters zal retourneren die dat niet is nul.

Deze code werkt in de meeste gevallen prima, maar laten we ons een ander voorbeeld voorstellen:

Doubles.tryParse (MoreObjects.firstNonNull ("", "2.0"))

In dit geval, aangezien de lege Draad niet nul, zal de methode terugkeren nul in plaats van een NumberFormatException. We vermijden de uitzondering, maar we zullen nog steeds een nul waarde op een bepaald punt in onze applicatiecode.

4.2. Apache Commons Lang NumberUtils

De NumberUtils class biedt veel handige hulpprogramma's die het gemakkelijker maken om met getallen te werken.

Het Apache Commons Lang-artefact is verkrijgbaar bij Maven Central:

 org.apache.commons commons-lang3 3.9 

Dan kunnen we gewoon de methode gebruiken dubbelen van NumberUtils:

NumberUtils.toDouble ("1.0") NumberUtils.toDouble ("1.0", 1.0d) 

Hier hebben we twee opties:

  • Converteer een Draad naar een dubbele, terugkerend 0.0d als de conversie mislukt
  • Converteer een Draad naar een dubbele, met een gedefinieerde standaardwaarde als de conversie mislukt

Als we een lege of passeren nul waarde, 0.0d wordt standaard geretourneerd:

assertThat (NumberUtils.toDouble ("")). isEqualTo (0.0d); assertThat (NumberUtils.toDouble (null)). isEqualTo (0.0d);

Dit is beter dan het vorige voorbeeld, omdat we altijd een dubbele retourwaarde, wat er ook gebeurt tijdens de conversie.

4.3. Vavr

Laten we tot slot eens kijken vavr.io, die een functionele benadering biedt.

Zoals altijd is het artefact te vinden op Maven Central:

 io.vavr vavr 0.10.2 

Nogmaals, we zullen een eenvoudige methode definiëren die gebruik maakt van de vavr Proberen klasse:

openbare statische dubbele tryStringToDouble (String-waarde, dubbele defaultValue) {return Try.of (() -> Double.parseDouble (waarde)). getOrElse (defaultValue); } 

We zullen deze methode op precies dezelfde manier aanroepen als in onze andere voorbeelden:

assertThat (tryStringToDouble ("1", 2.0d)). isEqualTo (1.0d); assertThat (tryStringToDouble (null, 2.0d)). isEqualTo (2.0d); assertThat (tryStringToDouble ("", 2.0d)). isEqualTo (2.0d);

5. Conclusie

In deze korte tutorial hebben we verschillende manieren onderzocht om te controleren op nul en lege strings voordat u de Double.parseDouble methode.

Zoals altijd is de volledige broncode van het artikel beschikbaar op GitHub.