Soru Kaçınmak! = Null ifadeler


kullanırım object != null kaçınmak için çok NullPointerException.

Buna iyi bir alternatif var mı?

Örneğin:

if (someobject != null) {
    someobject.doCalc();
}

Bu bir önler NullPointerExceptionNesne olup olmadığı bilinmiyorsa null ya da değil.

Kabul edilen yanıtın güncel olmadığını unutmayın, bkz. https://stackoverflow.com/a/2386013/12943 Daha yeni bir yaklaşım için.


3553


Menşei


@Shervin Geçersiz kılar, kodu daha az anlaşılabilir ve daha az güvenilir kılar. - Tom Hawtin - tackline
Elvis operatörleri önerilen ama içinde olmayacak gibi görünüyor Java 7. Çok kötü, ?. ?: ve? [] inanılmaz zaman tasarrufu sağlar. - Scott
Null kullanmamak burada diğer birçok öneriden daha üstündür. İstisnalar at, geri dönme veya boş değerlere izin verme. BTW - 'assert' anahtar sözcüğü işe yaramaz, çünkü varsayılan olarak devre dışıdır. Her zaman etkin bir arıza mekanizması kullanın - ianpojman
Bu, Scala'yı kullanmamın tek sebebidir. Scala'da her şey nullable değildir. "Hiçbir şey" iletmesine izin vermek ya da dönmek istiyorsanız, sadece T als argümanı veya dönüş tipi yerine Option [T] seçeneğini kullanmanız gerekir. - Thekwasti
@thSoft Gerçekten, Scala'nın müthiş Option türü, dilin kontrol etme veya izin vermeme konusundaki isteksizliği tarafından gölgelenir null. Bunu hackernews'den bahsettim ve reddettim ve "hiç kimse zaten Scala'da null kullanmaz" demişti. Tahmin et, zaten iş arkadaşı tarafından yazılmış Scala'da boş buluyorum. Evet, "yanlış yapıyorlar" ve bu konuda eğitimli olmalılar, fakat gerçek şu ki, dilin türü sistem beni bundan korusun ve öyle değil :( - Andres F.


Cevaplar:


Bu benim için orta geliştiricilerin bir noktada yüzleşme eğiliminde oldukları oldukça yaygın bir soruna benziyor: ya katılmadıkları sözleşmelere güvenmiyorlar ya da güvenmiyorlar ve boş yere savunmaya devam ediyorlar. Buna ek olarak, kendi kodlarını yazarken, bir şey belirtmek için null'lara geri dönme eğilimindedirler;

Başka bir şekilde ifade etmek gerekirse, null kontrolün ortaya çıktığı iki durum vardır:

  1. Null, sözleşme açısından geçerli bir cevap olduğunda; ve

  2. Geçerli bir yanıt olmadığı yerde.

(2) kolay. Ya kullanım assert ifadeler (onaylamalar) veya hataya izin ver (örneğin, NullPointerException). İddialar, 1.4'te eklenen oldukça düşük bir Java özelliğidir. Sözdizimi şöyledir:

assert <condition>

veya

assert <condition> : <object>

nerede <condition> bir bool ifadesidir ve <object> bir nesnedir toString() Yöntemin çıktısı hataya dahil edilir.

bir assert deyim bir atar Error (AssertionError) koşul doğru değilse. Varsayılan olarak, Java, onaylamaları göz ardı eder. Seçeneği ileterek onaylamaları etkinleştirebilirsiniz -ea JVM'ye. Bireysel sınıflar ve paketler için onaylamaları etkinleştirebilir ve devre dışı bırakabilirsiniz. Bu, testler geliştirmeden ve test edilirken onaylamalarla onaylayabileceğiniz ve testlerimin performans etkilerinin yanında gösterilmemesine rağmen bir üretim ortamında bunları devre dışı bırakabileceğiniz anlamına gelir.

Bu durumda ifadeleri kullanmamanız iyidir çünkü kodlar başarısız olur, bu, onaylama yöntemlerini kullanırsanız ne olur. Tek fark, iddialarla daha önce, daha anlamlı bir şekilde ve muhtemelen fazladan bir bilgiyle olabileceğini, bu yüzden beklemiyor olsaydınız neden olduğunu anlamanıza yardımcı olabilir.

(1) biraz daha zor. Aradığınız kod üzerinde herhangi bir kontrole sahip değilseniz, o zaman sıkışmışsınız demektir. Eğer null geçerli bir cevap ise, bunu kontrol etmelisiniz.

Ancak, kontrol ettiğiniz kod ise (ve bu çoğu zaman böyle olur), o zaman farklı bir hikaye. Yanıt olarak boş değerleri kullanmaktan kaçının. Koleksiyonları geri döndüren yöntemlerle, kolay: boş koleksiyonları (veya dizileri) hemen hemen her zaman boş değerlere döndürür.

Koleksiyonsuz olarak, daha zor olabilir. Bunu bir örnek olarak kabul edin: Eğer bu arayüzlere sahipseniz:

public interface Action {
  void doSomething();
}

public interface Parser {
  Action findAction(String userInput);
}

Parser, ham kullanıcı girdisini alır ve bir şeyler için bir komut satırı arabirimi uyguluyorsanız, yapacak bir şeyler bulur. Artık, uygun bir eylem yoksa, sözleşmeyi null döndürdüğünü belirtebilirsiniz. Bu, bahsettiğin null kontrolüne neden oluyor.

Alternatif bir çözüm asla boşa dönmemektir ve bunun yerine Boş Nesne kalıbı:

public class MyParser implements Parser {
  private static Action DO_NOTHING = new Action() {
    public void doSomething() { /* do nothing */ }
  };

  public Action findAction(String userInput) {
    // ...
    if ( /* we can't find any actions */ ) {
      return DO_NOTHING;
    }
  }
}

Karşılaştırmak:

Parser parser = ParserFactory.getParser();
if (parser == null) {
  // now what?
  // this would be an example of where null isn't (or shouldn't be) a valid response
}
Action action = parser.findAction(someInput);
if (action == null) {
  // do nothing
} else {
  action.doSomething();
}

için

ParserFactory.getParser().findAction(someInput).doSomething();

Bu daha iyi bir tasarıma sahip çünkü daha özlü kodlara yol açıyor.

Bu, belki de özellikle bir kullanıcı girdisine güveniyorsanız bu durumda, bir istisnai bir hata mesajıyla atmak için findAction () yöntemine tamamen uygundur. FindAction metodunun, bir istisna atmadan basit bir NullPointerException ile havaya uçurma yönteminden çok bir istisna atması daha iyi olurdu.

try {
    ParserFactory.getParser().findAction(someInput).doSomething();
} catch(ActionNotFoundException anfe) {
    userConsole.err(anfe.getMessage());
}

Ya da try / catch mekanizmasının çok çirkin olduğunu düşünmüyorsanız, Hiçbir şey Yapmak yerine varsayılan eyleminiz kullanıcıya geri bildirim sağlamalıdır.

public Action findAction(final String userInput) {
    /* Code to return requested Action if found */
    return new Action() {
        public void doSomething() {
            userConsole.err("Action not found: " + userInput);
        }
    }
}

2392



DO_NOTHING eylemi için ifadelerinize katılmıyorum. Bul eylemi eylemi bir eylem bulamazsa, null döndürmek doğru olan şeydir. Kodunuzda gerçekten bulunmayan, yöntem ilkesini ihlal eden, kullanılabilir bir eylem bulmak için bir eylem buldunuz. - MetroidFan2002
Java'da, özellikle listelerde null'ın fazla kullanıldığına katılıyorum. Boş bir liste / dizi / koleksiyon null yerine döndürdüğünde pek çok apis daha iyi olurdu. Birçok kez, null yerine bir istisna atılmalıdır nerede kullanılır. Ayrıştırıcı ayrıştırılamıyorsa, bir istisna atılmalıdır. - Laplie Anderson
Buradaki son örnek, IIRC, Boş Nesne tasarım deseni. - Steven Evers
@ Cshah (ve MetroidFan2002). Basit, bunu sözleşmeye koyun ve sonra bulunmayan iade eyleminin hiçbir şey yapmayacağı açıktır. Eğer arayan kişi için bu önemli bir bilgi ise, bunun bir non-found eylemi olduğunu (yani, sonucun DO_NOTHING nesnesi olup olmadığını kontrol etmek için bir yöntem sağladığını) keşfetmenin bir yolunu sağlayın. Alternatif olarak, eylem normal olarak bulunursa, yine de null döndürmemelisiniz, bunun yerine bu koşulu özellikle belirten bir istisna atmanız gerekir - bu daha iyi bir kodla sonuçlanır. İstenirse, eylem olup olmadığını kontrol etmek için boole döndüren ayrı bir yöntem belirtin. - Kevin Brock
Özlü kalite koduna uymuyor. Üzgünüm, öyle düşünüyorsun. Kodunuz, bir hatanın avantajlı olduğu durumları gizler. - gshauger


Eğer bir Java IDE kullanırsanız (veya kullanmayı planlıyorsanız) JetBrains IntelliJ IDEA, Eclipse veya Netbeans veya findbugs gibi bir araç daha sonra bu sorunu çözmek için ek açıklamaları kullanabilirsiniz.

Temel olarak, @Nullable ve @NotNull.

Aşağıdaki gibi yöntem ve parametreler kullanabilirsiniz:

@NotNull public static String helloWorld() {
    return "Hello World";
}

veya

@Nullable public static String helloWorld() {
    return "Hello World";
}

İkinci örnek (IntelliJ IDEA'da) derlenmez.

İlk kullandığınızda helloWorld() Başka bir kod parçasında işlev:

public static void main(String[] args)
{
    String result = helloWorld();
    if(result != null) {
        System.out.println(result);
    }
}

Şimdi IntelliJ IDEA derleyicisi, kontrolün işe yaramaz olduğunu söyleyecektir, çünkü helloWorld() işlev geri dönmeyecek null, hiç.

Parametre kullanma

void someMethod(@NotNull someParameter) { }

eğer şöyle bir şey yazarsanız:

someMethod(null);

Bu derleme yapmaz.

Son örnek kullanarak @Nullable

@Nullable iWantToDestroyEverything() { return null; }

Bunu yapmak

iWantToDestroyEverything().something();

Ve bunun olmayacağından emin olabilirsiniz. :)

Derleyicinin genel olarak yaptığından daha fazlasını kontrol etmesini ve sözleşmelerinizi daha güçlü olmasını sağlamak için iyi bir yoldur. Ne yazık ki, tüm derleyiciler tarafından desteklenmiyor.

IntelliJ IDEA 10.5 ve üzerinde, başka herhangi bir destek eklediler @Nullable  @NotNull uygulamalar.

Blog gönderisini gör Daha esnek ve yapılandırılabilir @ Nullable / @ NotNull ek açıklamaları.


518



@NotNull, @Nullable ve diğer nullness ek açıklamaları JSR 305. Bunları, araçlarla ilgili olası sorunları tespit etmek için de kullanabilirsiniz. FindBugs. - Jacek S
Garip bir şekilde can sıkıcı buluyorum. @NotNull & @Nullable arayüzler paket içinde yaşıyor com.sun.istack.internal. (Sanırım com.sun'u özel bir API kullanma konusunda uyarıda bulundum.) - Jonik
kod taşınabilirlik jetbrains ile null gider. Ben ide seviyesine kadar bağlamadan önce iki kez (kare) düşünürdüm.Like Jacek S onlar JSR303 olduğunu düşündüm herhangi bir şekilde JSR parçası olduğunu söyledi. - Java Ka Baby
Özel bir derleyici kullanmanın bu sorun için uygun bir çözüm olduğunu düşünmüyorum. - Shivan Dragon
Ek açıklamalarla ilgili iyi bir şey, @NotNull ve @Nullable kaynak kodu, onları anlamayan bir sistem tarafından oluşturulduğunda güzel bir şekilde ayrışmalarıdır. Yani, aslında, kodun taşınabilir olmadığı argümanı geçersiz olabilir - bu ek açıklamaları destekleyen ve anlayan bir sistem kullanırsanız, daha sıkı hata kontrolünün ek avantajını elde edersiniz, aksi halde daha az alırsınız ancak kodunuz hala İyi çalışın ve çalışan programınızın kalitesi AYNI, çünkü bu ek açıklamaları zaten çalışma zamanında zorlanmadı. Ayrıca, tüm derleyiciler özel ;-) - amn


Boş değerlere izin verilmiyorsa

Yönteminiz harici olarak adlandırılıyorsa, şunun gibi bir şeyle başlayın:

public void method(Object object) {
  if (object == null) {
    throw new IllegalArgumentException("...");
  }

Sonra, bu yöntemin geri kalanında, bunu bileceksiniz object boş değil.

İçsel bir yöntemse (bir API'nın parçası değil), yalnızca boş olamaz, ve bu, bu belge.

Örnek:

public String getFirst3Chars(String text) {
  return text.subString(0, 3);
}

Bununla birlikte, yönteminiz sadece değeri aşarsa ve bir sonraki yöntem bunu iletirse, sorun yaşayabilir. Bu durumda argümanı yukarıdaki gibi kontrol etmek isteyebilirsiniz.

Boş izin verilirse

Bu gerçekten bağlı. Böyle bir şey yaptığımı görürseniz:

if (object == null) {
  // something
} else {
  // something else
}

Ben de dalıyorum ve iki tamamen farklı şeyler yapıyorum. Çirkin kod parçacığı yok, çünkü verilere bağlı olarak iki farklı şey yapmam gerekiyor. Örneğin, giriş üzerinde çalışmalı mıyım yoksa iyi bir varsayılan değer mi hesaplamalıyım?


Aslında deyim kullanmak benim için nadirdir "if (object != null && ...".

Genellikle deyimi kullandığınız yerlerin örneklerini gösterirseniz, size örnek vermek daha kolay olabilir.


282



IllegalArgumentException'ı atmanın amacı nedir? NullPointerException'ın daha net olacağını düşünüyorum ve eğer siz kendiniz kontrol etmiyorsanız bu da atılır. Ya savurganlık ya da hiçbir şey kullanmazdım. - Axel
Boş değerden başka her değerin kabul edilebilir olmaması olası değildir. IllegalArgumentException, OutOfRageException vb. Olabilir. Bazen bu mantıklı. Diğer zamanlarda herhangi bir değer eklemeyen bir çok istisna dersi yaratırsınız, o zaman sadece IllegalArgumentException kullanırsınız. Boş giriş için bir istisna, diğer her şey için bir tane daha olması mantıklı değildir. - myplacedk
Evet, başarısızlık ilkesine katılıyorum, ama yukarıda verilen örnekte, değer aktarılmaz, ancak bir yöntemin çağrılacağı nesne. Bu yüzden eşit derecede hızlı bir şekilde başarısız oluyor ve neyse aynı zamanda atılacak bir istisna atmak için bir null çekimi eklemek hata ayıklama işlemini daha kolay yapmıyor gibi görünüyor. - Axel
Güvenlik deliği mi? JDK böyle bir kodla dolu. Kullanıcının yığınları görmesini istemiyorsanız, bunları yalnızca devre dışı bırakın. Kimse davranışın belgelenmediğini ima etti. MySQL, dereferencing boş göstergelerin tanımlanmamış bir davranış olduğu, bir istisna atmak gibi bir şey yazılmadığı C dilinde yazılır. - fgb
throw new IllegalArgumentException("object==null") - Thorbjørn Ravn Andersen


Vay, neredeyse tavsiye etmek için 57 farklı yol var, başka bir cevap eklemek için nefret ediyorum NullObject patternama sanırım bu soruyla ilgilenen bazı kişiler, Java 7'nin eklenmesi için masa üzerinde bir teklif olduğunu bilmek isteyebilir. "boş güvenli kullanım"- Eşit olmayan-null mantığı için akıcı bir sözdizimi.

Alex Miller tarafından verilen örnek şöyle:

public String getPostcode(Person person) {  
  return person?.getAddress()?.getPostcode();  
}  

?. sol boş tanımlayıcıyı boş değilse, aksi halde ifadenin kalanını şu şekilde değerlendirmek anlamına gelir null. Java Posse üyesi Dick Wall ve Devoxx'da seçmen Bu öneriyi gerçekten çok seviyorum, ama aslında daha fazla kullanımı teşvik edeceği gerekçesiyle de muhalefet var. null bir sentinel değeri olarak.


Güncelleştirme: bir resmi teklif Java 7'de bir null-safe operatörü için gönderildi Proje madeni para. Sözdizimi, yukarıdaki örnekten biraz farklıdır, ancak aynı kavramdır.


Güncelleştirme: Null-safe operatör teklifi, Project Coin'e getirmedi. Yani, bu sözdizimini Java 7'de görmeyeceksiniz.


215



Bence bu yanlış. Belirli bir değişkenin ALWAYS boş olmayan olduğunu belirtmenin bir yolu olmalıdır. - Thorbjørn Ravn Andersen
Güncelleme: öneri Java7 yapmaz. Görmek blogs.sun.com/darcy/entry/project_coin_final_five . - Boris Terzic
İlginç bir fikir ama sözdizimi seçimi saçmadır; Ben her eklemin içine tutturulmuş bir soru işareti dolu bir kod tabanı istemiyorum. - Rob
Bu operatör var harikaBu yüzden onu kullanmak isteyenler bir seçenek olarak var. - Muhd
Bu gördüğüm en dahice fikir. C sözdiziminin her mantıklı diline eklenmelidir. Heryerde çizgisel çizgiler arasında gezinmek veya tüm günlerde "koruma maddeleri" ni atlatmak yerine "soru işaretlerini" iğnelemeyi tercih ederim. - Victor


Tanımlanmamış değerlere izin verilmiyorsa:

IDE'nizi, potansiyel boşaltma hakkında sizi uyaracak şekilde yapılandırabilirsiniz. Örneğin. Eclipse içinde bkz. Tercihler> Java> Derleyici> Hatalar / Uyarılar / Boşluk analizi.

Tanımlanmamış değerlere izin verilirse:

Tanımlanmamış değerlerin anlamlı olduğu yeni bir API tanımlamak istiyorsanız, kullan Seçenek Desen (işlevsel dillerden tanıdık olabilir). Aşağıdaki avantajlara sahiptir:

  • Bir girdi veya çıkışın var olup olmadığı API'da açıkça belirtilmiştir.
  • Derleyici, "tanımlanmamış" davayı ele almanız için sizi zorlar.
  • Seçenek bir monadBu nedenle, ayrıntılı bir null denetimine gerek yoktur, sadece değeri kullanmak için harita / foreach / getOrElse veya benzer bir birleştirici kullanın (örnek).

Java 8 yerleşik bir Optional sınıf (önerilir); önceki sürümler için, örneğin kütüphane alternatifleri vardır Guava'ler Optional veya FunctionalJava'ler Option. Ancak, birçok fonksiyonel stil kalıbı gibi, Java'daki Option'u (8 bile) kullanmak, daha az ayrıntılı bir JVM dili kullanarak azaltabileceğiniz oldukça fazla sayıda boilerplate ile sonuçlanır. Scala veya Xtend.

Boşuna dönebilecek bir API ile uğraşmak zorunda kalırsanızJava'da fazla bir şey yapamazsınız. Xtend ve Groovy Elvis operatörü  ?: ve null güvenli dereference operatörü  ?.ancak boş bir başvuru durumunda bu null döndürür, bu yüzden boş "null" sadece "çözer".


177



Gerçekten, Seçenek deseni harika. Bazı Java eşdeğerleri var. Guava, işlevsel olanların çoğunu dışarıda bırakan bu isteğe bağlı olarak adlandırılan sınırlı bir sürümü içerir. Haskell'de, bu örüntü Belki de denir. - Ben Hardy
Java 8'de isteğe bağlı bir sınıf mevcut olacak - Pierre Henry
... ve (henüz) haritaya da sahip değil. download.java.net/jdk8/docs/api/java/util/Optional.html - thSoft
İsteğe bağlı model hiçbir şeyi çözmez; potansiyel olarak boş bir nesne yerine, şimdi iki tane var. - Boann
@Boann, dikkatle kullanıldığında, tüm NPE sorununuzu çözersiniz. Değilse, o zaman bir "kullanım" problemi olduğunu tahmin ediyorum. - Louis F.


Sadece bu durum için -

Bir eşitleme yöntemini çağırmadan önce bir değişkenin boş olup olmadığını kontrol etme (bir dize aşağıdaki örneği karşılaştırın):

if ( foo.equals("bar") ) {
 // ...
}

sonuçlanacak NullPointerException Eğer foo mevcut değil.

Eğer karşılaştırırsan Stringböyle:

if ( "bar".equals(foo) ) {
 // ...
}

160



Katılıyorum - sadece bu durumda. Bunu bir sonraki gereksiz seviyeye götüren programcılara dayanamıyorum ve yazmam gerekirse (null! = MyVar) ... sadece bana çirkin gözüküyor ve hiçbir amaca hizmet etmiyor! - Alex Worden
Bu, genel olarak iyi bir uygulamanın muhtemelen en çok kullanılan özel bir örneğidir: eğer biliyorsanız, her zaman <object that you know that is not null>.equals(<object that might be null>);. Başka yöntemler dışında çalışır. equals sözleşmeyi biliyorsanız ve bu yöntemlerle başa çıkabilir null parametreleri. - Stef
Bu gördüğüm ilk örnek Yoda Koşulları Bu aslında mantıklı - Erin Drummond
NullPointerExceptions bir sebepten dolayı atılır. Atılırlar çünkü bir nesne olması gereken yerde boştur. Bu sorunu çözmek için programcıların işi FIX değil. - Oliver Watkins
Try-Catch-DoNothing problemi gizler; bu, eksik şeker çevresinde dilde çalışmak için geçerli bir uygulamadır. - echox


Java 8 ile yeni geliyor java.util.Optional Bazı problemi tartışan bir sınıf. En azından kodun okunabilirliğini geliştirdiğini söyleyebiliriz ve kamu API'ları durumunda API'nın sözleşmesini müşteri geliştiricisine daha açık hale getirin.

Onlar böyle çalışır:

Belirli bir tür için isteğe bağlı nesne (Fruit) bir yöntemin dönüş tipi olarak oluşturulur. Boş olabilir veya bir Fruit nesne:

public static Optional<Fruit> find(String name, List<Fruit> fruits) {
   for (Fruit fruit : fruits) {
      if (fruit.getName().equals(name)) {
         return Optional.of(fruit);
      }
   }
   return Optional.empty();
}

Şimdi bir listeyi aradığımız bu koda bakın. Fruit (fruitsBelirli bir Fruit örneği için:

Optional<Fruit> found = find("lemon", fruits);
if (found.isPresent()) {
   Fruit fruit = found.get();
   String name = fruit.getName();
}

Kullanabilirsiniz map() operatörün bir hesaplama yapması veya isteğe bağlı bir nesneyi bir değer elde etmesi. orElse() Eksik değerler için bir geri dönüş sağlar.

String nameOrNull = find("lemon", fruits)
    .map(f -> f.getName())
    .orElse("empty-name");

Elbette, boş / boş değerin kontrolü hala gereklidir, ancak en azından geliştirici, değerin boş olabileceğinin ve kontrol etmeyi unutmanın riskinin sınırlı olduğunun bilincindedir.

Sıfırdan oluşturulmuş bir API'da Optional ne zaman bir dönüş değeri boş olabilir ve düz bir nesneyi yalnızca null (kural), istemci kodu basit nesne döndürme değerlerinde boş çekleri iptal edebilir ...

Tabii ki Optional bir yöntem argümanı olarak da kullanılabilir, belki de bazı durumlarda 5 veya 10 aşırı yükleme yönteminden isteğe bağlı argümanları belirtmenin daha iyi bir yolu.

Optional gibi diğer uygun yöntemleri sunar orElse Bu, varsayılan bir değerin kullanılmasına izin verir ve ifPresent ile çalışır lambda ifadeleri.

Bu makaleyi okuman için sizi davet ediyorum (bu cevabı yazmak için ana kaynağım). NullPointerException (ve genel olarak boş gösterici) sorunlu yanı sıra (kısmi) çözüm getirdi Optional iyi açıklandı: Java İsteğe Bağlı Nesneler.


135



Google'ın guava'sı Java 6+ için isteğe bağlı bir ayırma özelliğine sahiptir. - Bradley Gottfried
Onun çok İsteğe bağlı yalnızca ifPresent () ile kullanıldığını vurgulamak önemlidir değil Normal boş değerlerin üstünde çok değer katın. Bu temel değer, başka bir yerde bahsedilen Groovy'deki Elvis operatörüne benzer sonuçları elde eden map / flapMap işlev zincirlerinde kullanılabilen bir monad olmasıdır. Bu kullanım olmasa bile, orElse / orElseThrow sözdizimini de çok yararlı buluyorum. - Cornel Masson
Bu blogun Optional'de iyi bir girişi var winterbe.com/posts/2015/03/15/avoid-null-checks-in-java - JohnC
İnsanların bu boilerplate koduyla neden bu kadar mutlu olduklarını hiç anlamadım dzone.com/articles/java-8-elvis-operator - Mykhaylo Adamovych
İnsanlar neden bunu yapma eğilimindeler? if(optional.isPresent()){ optional.get(); } yerine optional.ifPresent(o -> { ...}) - Satyendra Kumar


Hangi tür nesneleri kontrol ettiğinize bağlı olarak, apache commons'taki bazı sınıfları kullanabilirsiniz: apache ortakları lang ve apache commons koleksiyonları

Örnek:

String foo;
...
if( StringUtils.isBlank( foo ) ) {
   ///do something
}

veya (kontrol etmeniz gerekenlere bağlı olarak):

String foo;
...
if( StringUtils.isEmpty( foo ) ) {
   ///do something
}

StringUtils sınıfı, yalnızca bir tanesidir; Müşterilerde, güvenli ve güvenli bir manipülasyon yapan birkaç iyi sınıf var.

Apache kitaplığı (commons-lang-2.4.jar) eklediğinizde, JAVA'daki null vallidation'ı nasıl kullanabileceğinizi buradan görebilirsiniz

public DOCUMENT read(String xml, ValidationEventHandler validationEventHandler) {
    Validate.notNull(validationEventHandler,"ValidationHandler not Injected");
    return read(new StringReader(xml), true, validationEventHandler);
}

Ve Bahar kullanıyorsanız, Bahar aynı zamanda paketinde de aynı işlevselliğe sahiptir, bkz. Kitaplık (spring-2.4.6.jar)

Bu statik sınıfın yaydan nasıl kullanılacağı ile ilgili örnek (org.springframework.util.Assert)

Assert.notNull(validationEventHandler,"ValidationHandler not Injected");

113



Ayrıca, Apache Commons'ın daha genel bir sürümünü kullanabilir, bulduğum paramları kontrol etmek için yöntemlerin başlangıcında oldukça kullanışlıdır. Validate.notNull (object, "object null olmamalıdır"); commons.apache.org/lang/apidocs/org/apache/commons/lang/... - monojohnny
@monojohnny, Doğrulama ifadelerini ?. Bunu soruyorum çünkü Assert JVM üzerinde aktif / devre dışı bırakabilir ve üretimde kullanılmaması önerilmektedir. - Kurapika
Düşünme - Doğrulama başarısız olursa sadece bir RuntimeException atar inanıyorum - monojohnny