Beste manier om te controleren op null-waarden in Java?

Voordat ik een functie van een object aanroep, moet ik controleren of het object null is, om te voorkomen dat u een NullPointerException.

WORDT

Wat is de beste manier om dit te gaan? Ik heb deze methoden overwogen.
Welke is de beste programmeringspraktijk voor Java?

// Method 1
if (foo != null) {
    if (foo.bar()) {
        etc...
    }
}
// Method 2
if (foo != null ? foo.bar() : false) {
    etc...
}
// Method 3
try {
    if (foo.bar()) {
        etc...
    }
} catch (NullPointerException e) {
}
// Method 4 -- Would this work, or would it still call foo.bar()?
if (foo != null && foo.bar()) {
    etc...
}

Antwoord 1, Autoriteit 100%

Method 4 is het beste.

if(foo != null && foo.bar()) {
   someStuff();
}

Gebruik kortsluiting evaluatie , wat betekent dat het eindigt als het Eerste toestand van een logical ANDis onwaar.

Antwoord 2, Autoriteit 13%

de laatste en de beste. I.E logisch en

 if (foo != null && foo.bar()) {
    etc...
}

omdat in logisch &&

Het is niet nodig om te weten wat de rechterkant is, het resultaat moet vals zijn

Liever lezen: Java logische operator kortsluiting

Antwoord 3, Autoriteit 5%

• Vang NullPointerExceptionniet. Dat is een slechte gewoonte. Het is beter om ervoor te zorgen dat de waarde niet null is.
• Methode #4 zal voor jou werken. Het zal de tweede voorwaarde niet evalueren, omdat Java kortsluiting heeft (d.w.z. volgende voorwaarden zullen niet worden geëvalueerd als ze het eindresultaat van de booleaanse uitdrukking niet veranderen). Als in dit geval de eerste uitdrukking van een logische AND wordt geëvalueerd als onwaar, hoeven volgende uitdrukkingen niet te worden geëvalueerd.

Antwoord 4, autoriteit 5%

Methode 4 is verreweg de beste omdat deze duidelijk aangeeft wat er gaat gebeuren en het minimum aan code gebruikt.

Methode 3 is gewoon verkeerd op elk niveau. Je weet dat het item mogelijk nul is, dus het is geen uitzonderlijke situatie, het is iets waar je op moet letten.

Methode 2 maakt het alleen maar ingewikkelder dan het hoeft te zijn.

Methode 1 is gewoon methode 4 met een extra regel code.

Antwoord 5, autoriteit 3%

In Java 7kunt u Objects.requireNonNull()gebruiken.
Voeg een import toe van de klasse Objectsuit java.util.

public class FooClass {
    //...
    public void acceptFoo(Foo obj) {
        //If obj is null, NPE is thrown
        Objects.requireNonNull(obj).bar(); //or better requireNonNull(obj, "obj is null");
    }
    //...
}

Antwoord 6, autoriteit 2%

Ik zou zeggen dat methode 4 het meest algemene idioom is van de code die ik heb bekeken. Maar dit vind ik altijd een beetje stinken. Het gaat ervan uit dat foo == null hetzelfde is als foo.bar() == false.

Dat voelt niet altijd goed voor mij.

Antwoord 7, autoriteit 2%

Methode 4 is mijn voorkeursmethode. De kortsluiting van de && operator maakt de code het meest leesbaar. Methode 3, NullPointerException vangen, wordt meestal afgekeurd wanneer een eenvoudige nulcontrole zou volstaan.

Antwoord 8

Als u de API beheert die wordt aangeroepen, kunt u overwegen Guava’s optionele les

Meer informatie hier. Wijzig uw methode om een Optional<Boolean>te retourneren in plaats van een Boolean.

Dit informeert de aanroepende code dat deze rekening moet houden met de mogelijkheid van null, door een van de handige methoden in Optional

aan te roepen

Antwoord 9

Zoals anderen al hebben gezegd, is #4 de beste methode als je geen bibliotheekmethode gebruikt. U moet echter altijd null aan de linkerkant van de vergelijking plaatsen om ervoor te zorgen dat u niet per ongeluk null toewijst aan foo in het geval van een typfout. In dat geval zal de compiler de fout opvangen.

// You meant to do this
if(foo != null){
// But you made a typo like this which will always evaluate to true
if(foo = null)
// Do the comparison in this way
if(null != foo)
// So if you make the mistake in this way the compiler will catch it
if(null = foo){
// obviously the typo is less obvious when doing an equality comparison but it's a good habit either way
if(foo == null){
if(foo =  null){

Antwoord 10

U kunt ook StringUtils.isNoneEmpty("")gebruiken om te controleren of deze null of leeg is.

Antwoord 11

Als je überhaupt gaat controleren met dubbel gelijk “==”, vink dan null aan met objectref zoals

if(null == obj) 

in plaats van

if(obj == null)

Omdat als u mistige single gelijk is als (obj = null) het true retourneert (toewijzing van object retourneert succes (wat ‘true’ in waarde is).

Antwoord 12

Uw laatste voorstel is de beste.

 if (foo != null && foo.bar()) {
    etc...
}

omdat:

1. Het is gemakkelijker te lezen.
2. Het is veilig: foo.bar () wordt nooit uitgevoerd als foo == null.
3. Het voorkomt dat de slechte praktijk is, zoals het vangen van nullpointerexceptions (meestal vanwege een bug in uw code)
4. Het moet zo snel of zelfs sneller uitvoeren dan andere methoden (hoewel ik denk dat het bijna onmogelijk moet zijn om het op te merken).

Antwoord 13

Als u geen toegang hebt tot de Commons Apache-bibliotheek, werkt het volgende waarschijnlijk OK

if(null != foo && foo.bar()) {
//do something
}

Antwoord 14

We kunnen objecten gebruiken. REQUIRENINNULL STATISCHE METHODE VAN OBLEKKLASIC. Implementatie is lager dan

public void someMethod(SomeClass obj) {
    Objects.requireNonNull(obj, "Validation error, obj cannot be null");
}

Antwoord 15

Eenvoudige code voor één regel om te controleren op null:

namVar == null ? codTdoForNul() : codTdoForFul();

Antwoord 16

Voor Java 11+ kunt u Objects.nonNull(Object obj)

if(nonNull(foo)){ 
//
}

Antwoord 17

public <T, U> U defaultGet(T supplier, Function<T, U> mapper, U defaultValue) {
        return Optional.ofNullable(supplier).map(mapper).orElse(defaultValue);
    }

U kunt deze functie maken als u de voorkeur geeft aan de functieprogrammering