Dizimin null değerine eşit olup olmadığını nasıl kontrol edebilirim?

SADECE benim dize anlamlı bir değere sahipse bazı eylem gerçekleştirmek istiyorum. Bunu denedim.

if (!myString.equals("")) {
doSomething
}

ve bu

if (!myString.equals(null)) {
doSomething
}

ve bu

if ( (!myString.equals("")) && (!myString.equals(null))) {
doSomething
}

ve bu

if ( (!myString.equals("")) && (myString!=null)) {
doSomething
}

ve bu

if ( myString.length()>0) {
doSomething
}

Ve her durumda benim program doSomethingboş olmasına rağmen benim program BOŞ OLMAKTADIR. Eşittir null. Peki, bunun nesi yanlış?

KATMA:

Sorunun nedenini buldum. Değişken bir dize olarak bildirildi ve sonuç nullolarak bu değişkene atanan "null"! Yani, if (!myString.equals("null"))çalışır.

if (myString != null && !myString.isEmpty()) {
  // doSomething
}

Daha fazla yorum olarak, equalssözleşmede bu terimin farkında olmalısınız :

Gönderen Object.equals(Object):

Bir boş olmayan referans değeri için x, x.equals(null)olmalıdır return false.

İle karşılaştırmak için bir yol nullkullanmaktır x == nullve x != null.

Üstelik x.fieldve eğer x.method()atar .NullPointerExceptionx == null

Eğer myStringbir null, daha sonra arayarak myString.equals(null)ya myString.equals("")bir başarısız olur NullPointerException. Boş bir değişken üzerinde hiçbir örnek yöntemini çağıramazsınız.

İlk önce null olup olmadığını kontrol edin:

if (myString != null && !myString.equals("")) {
    //do something
}

Bu , eğer null kontrolünü geçemezse kısa devre değerlendirmesini kullanır ..equalsmyString

Apache müşterekleri StringUtils.isNotEmptygitmek için en iyi yoldur.

MyString aslında null olursa, referansa yapılan herhangi bir çağrı bir Null Pointer Exception (NPE) ile başarısız olur. Java 6'dan beri , uzunluk kontrolü yerine #isEmpty kullanın (her durumda ASLA çek ile yeni bir boş Dize oluşturmayın).

if (myString != null &&  !myString.isEmpty()){
    doSomething();
}

Bu arada, String değişmezleriyle yaptığınız gibi karşılaştırma yapıldığında, ifadeyi bir boş kontrol yapmak zorunda kalmayacak şekilde tersine çevirir, yani,

if ("some string to check".equals(myString)){
  doSomething();
} 

onun yerine :

if (myString != null &&  myString.equals("some string to check")){
    doSomething();
}

ÇALIŞMA !!!!

if (myString != null && !myString.isEmpty()) {
    return true;
}
else {
    return false;
}

Bunu kontrol etmeniz gerekir myStringnesnedir null:

if (myString != null) {
    doSomething
}

Dizeniz null olursa, bunun gibi çağrılar bir NullReferenceException özel durumu oluşturur:

myString.equals (boş)

Ama neyse, bence böyle bir yöntem istediğin şey:

public static class StringUtils
{
    public static bool isNullOrEmpty(String myString)
    {
         return myString == null || "".equals(myString);
    }
}

Daha sonra kodunuzda, böyle şeyler yapabilirsiniz:

if (!StringUtils.isNullOrEmpty(myString))
{
    doSomething();
}

Mevcut bir yardımcı programı kullanmayı veya kendi yönteminizi oluşturmayı teşvik ederim:

public static boolean isEmpty(String string) {
    return string == null || string.length() == 0;
}

O zaman sadece ihtiyacınız olduğunda kullanın:

if (! StringUtils.isEmpty(string)) {
  // do something
}

Yukarıda belirtildiği gibi || ve && operatörleri kısa devre. Bu, değerlerini belirledikleri anda durdukları anlamına gelir. Bu nedenle (string == null) true olursa, ifade bölümünün her zaman doğru olacağı için uzunluk bölümünün değerlendirilmesi gerekmez. && ile benzer şekilde, sol taraf yanlışsa, ifade her zaman yanlıştır ve daha fazla değerlendirilmesine gerek yoktur.

Ek bir not olarak, uzunluk kullanmak genellikle .equals kullanmaktan daha iyi bir fikirdir. Performans biraz daha iyidir (fazla değil) ve nesne oluşturma gerektirmez (çoğu derleyici bunu optimize edebilir).

Deneyin,

myString!=null && myString.length()>0

 if (myString != null && myString.length() > 0) {

        // your magic here

 }

Bu arada, çok fazla dize manipülasyonu yapıyorsanız, her türlü yararlı yöntemle harika bir Spring sınıfı vardır:

http://static.springsource.org/spring/docs/2.5.x/api/org/springframework/util/StringUtils.html

Her seferinde (neredeyse her seferinde) dizelerle uğraşmak zorunda kalıyorum ve hangi yolun gerçekten boş bir dize kontrol etmek için en hızlı yol olduğunu merak ediyorum. Elbette string.Length == 0 denetimi en hızlı olmalıdır, çünkü Length bir özelliktir ve özelliğin değerini almak dışında herhangi bir işlem yapılmamalıdır. Ama sonra kendime soruyorum, neden bir String.Empty var? String.Empty'yi kontrol etmek daha uzun olmalı, uzunluk için kendime söylüyorum. Peki ben finnaly test etmeye karar verdi. Bana 10 milyon tekrar için belirli bir kontrol yapmanın ne kadar sürdüğünü söyleyen küçük bir Windows Konsolu uygulaması kodladım. 3 farklı dizeyi kontrol ettim: NULL string, Empty string ve "" string. 5 farklı yöntem kullandım: String.IsNullOrEmpty (), str == null, str == null || str == String.Empty, str == null || str == "", str == null || str.

String.IsNullOrEmpty()
NULL = 62 milliseconds
Empty = 46 milliseconds
"" = 46 milliseconds

str == null
NULL = 31 milliseconds
Empty = 46 milliseconds
"" = 31 milliseconds

str == null || str == String.Empty
NULL = 46 milliseconds
Empty = 62 milliseconds
"" = 359 milliseconds

str == null || str == ""
NULL = 46 milliseconds
Empty = 343 milliseconds
"" = 78 milliseconds

str == null || str.length == 0
NULL = 31 milliseconds
Empty = 63 milliseconds
"" = 62 milliseconds

Bu sonuçlara göre, ortalama kontrol str == nullen hızlıdır, ancak aradığımızı her zaman vermeyebilir. if str = String.Emptyveya str = ""yanlış sonuçlanır. Sonra ikinci sırada bağlı 2 var: String.IsNullOrEmpty()ve str == null || str.length == 0. Güzel String.IsNullOrEmpty()görünüyor ve yazmak daha kolay (ve daha hızlı) olduğundan diğer çözüm üzerinde kullanmanızı tavsiye ederim.

Böyle bir şey yapardım:

( myString != null && myString.length() > 0 )
    ? doSomething() : System.out.println("Non valid String");

• Null olup olmadığını sınama, myString öğesinin bir String örneği içerip içermediğini denetler.
• length (), uzunluğu döndürür ve eşittir ("").
• MyString öğesinin null olup olmadığını kontrol etmek, bir NullPointerException özelliğinden kaçınacaktır.

Kullanıyordum StringUtil.isBlank(string)

Bir dizenin boş olup olmadığını test eder: null, emtpy veya yalnızca boşluk.

Bu şimdiye kadarki en iyisi

İşte dokümanlardan orignal yöntem

/**
    * Tests if a string is blank: null, emtpy, or only whitespace (" ", \r\n, \t, etc)
    * @param string string to test
    * @return if string is blank
    */
    public static boolean isBlank(String string) {
        if (string == null || string.length() == 0)
            return true;

        int l = string.length();
        for (int i = 0; i < l; i++) {
            if (!StringUtil.isWhitespace(string.codePointAt(i)))
                return false;
        }
        return true;
    } 

Bu çalışmalı:

if (myString != null && !myString.equals(""))
    doSomething
}

Değilse, myString muhtemelen beklemediğiniz bir değere sahiptir. Aşağıdaki gibi yazdırmayı deneyin:

System.out.println("+" + myString + "+");

Dizeyi çevrelemek için '+' sembollerini kullanmak, içinde hesap yapmadığınız fazladan boşluk olup olmadığını gösterir.

if(str.isEmpty() || str==null){ do whatever you want }

Tamam, veri türleri Java'da böyle çalışır. (İngilizcemi mazeret göstermeliyim, doğru kelimeleri kullanmıyorum. İkisini birbirinden ayırmanız gerekiyor. Temel veri türleri ve normal veri türleri. Temel veri türleri var olan her şeyi oluşturuyor. Örneğin, orada Tüm sayılar, karakter, boole vb. Normal veri türleri veya karmaşık veri türleri diğer her şeydir Dize karakter dizisidir, dolayısıyla karmaşık veri tipidir.

Oluşturduğunuz her değişken aslında hafızanızdaki değerin bir göstergesidir. Örneğin:

String s = new String("This is just a test");

"s" değişkeni bir String içermez. Bu bir işaretçi. Bu işaretçi, belleğinizdeki değişkeni gösterir. Aradığınızda System.out.println(anyObject), toString()o nesnenin yöntemi çağrılır. Nesne'den geçersiz toStringkılmadıysa, işaretçiyi yazdırır. Örneğin:

public class Foo{
    public static void main(String[] args) {
        Foo f = new Foo();
        System.out.println(f);
    }
}

>>>>
>>>>
>>>>Foo@330bedb4

"@" In arkasındaki her şey işaretçi. Bu yalnızca karmaşık veri türleri için geçerlidir. İlkel veri türleri doğrudan kendi işaretçilerine kaydedilir. Yani aslında bir işaretçi yoktur ve değerler doğrudan saklanır.

Örneğin:

int i = 123;

i bu durumda bir işaretçi saklamıyor. i tam sayı değerini (123 bayt cinsinden) saklayacağım.

Tamam, ==operatöre geri dönelim . İşaretçinin bellekteki konumuna kaydedilen içeriği değil, her zaman işaretçiyi karşılaştırır.

Misal:

String s1 = new String("Hallo");
String s2 = new String("Hallo");

System.out.println(s1 == s2);

>>>>> false

Bu her iki Dize farklı bir işaretçiye sahiptir. Ancak String.equals (Diğer String) içeriği karşılaştırır. Aynı içeriğe sahip iki farklı nesnenin işaretçisi eşit olduğundan, ilkel veri türlerini '==' işleci ile karşılaştırabilirsiniz.

Null, işaretçinin boş olduğu anlamına gelir. Boş bir ilkel veri türü varsayılan olarak 0'dır (sayılar için). Ancak herhangi bir karmaşık nesne için null değeri, o nesnenin mevcut olmadığı anlamına gelir.

Selamlar

Benim için bir dizenin Java'da anlamlı bir içeriğe sahip olup olmadığını kontrol etmek en iyisidir:

string != null && !string.trim().isEmpty()

Dize ise Önce kontrol nullkaçınmak NullPointerExceptionve daha sonra sadece boşlukları var dizeleri kontrol önlemek için tüm uzay karakterleri Döşeme ve kesilmiş dize boş değilse, nihayet kontrol yani uzunluğu 0 sahiptir.

Ben android bu sorunu vardı ve ben bu şekilde kullanın (benim için çalışmak):

String test = null;
if(test == "null"){
// Do work
}

Ama java kodunda kullanıyorum:

String test = null;
if(test == null){
// Do work
}

Ve :

private Integer compareDateStrings(BeanToDoTask arg0, BeanToDoTask arg1, String strProperty) {
    String strDate0 = BeanUtils.getProperty(arg0, strProperty);_logger.debug("strDate0 = " + strDate0);
    String strDate1 = BeanUtils.getProperty(arg1, strProperty);_logger.debug("strDate1 = " + strDate1);
    return compareDateStrings(strDate0, strDate1);
}

private Integer compareDateStrings(String strDate0, String strDate1) {
    int cmp = 0;
    if (isEmpty(strDate0)) {
        if (isNotEmpty(strDate1)) {
            cmp = -1;
        } else {
            cmp = 0;
        }
    } else if (isEmpty(strDate1)) {
        cmp = 1;
    } else {
        cmp = strDate0.compareTo(strDate1);
    }
    return cmp;
}

private boolean isEmpty(String str) {
    return str == null || str.isEmpty();
}
private boolean isNotEmpty(String str) {
    return !isEmpty(str);
}

Kullanmayı tercih ederim:

if(!StringUtils.isBlank(myString)) { // checks if myString is whitespace, empty, or null
    // do something
}

StringUtils.isBlank () ve String.isEmpty () değerlerini okuyun .

Android'de size yarar yöntemi ile kontrol edebilirsiniz isEmptygelen TextUtils,

public static boolean isEmpty(CharSequence str) {
    return str == null || str.length() == 0;
}

isEmpty(CharSequence str)yöntem nulluzunluğunu ve durumunu kontrol eder .

Her zaman böyle kullanırım:

if (mystr != null && !mystr.isEmpty()){
  //DO WHATEVER YOU WANT OR LEAVE IT EMPTY
}else {
  //DO WHATEVER YOU WANT OR LEAVE IT EMPTY
}

veya bunu projenize kopyalayabilirsiniz:

private boolean isEmptyOrNull(String mystr){
    if (mystr != null && !mystr.isEmpty()){ return true; }
    else { return false; }
}

ve sadece şöyle deyin:

boolean b = isEmptyOrNull(yourString);

boş veya null olursa true değerini döndürür.
b=trueboş veya boşsa

ya da boşken try catch ve catch'i kullanabilirsiniz.

MyString bir dize değil, bir dizi dizisi olduğunu düşünüyorum. Yapman gerekenler işte burada:

String myNewString = join(myString, "")
if (!myNewString.equals(""))
{
    //Do something
}

Bunu kullanarak null değerine eşit olan dizeyi kontrol edebilirsiniz:

String Test = null;
(Test+"").compareTo("null")

Sonuç 0 ise (Test + "") = "null".

Ben inşa edildi ve TÜM BAŞARISIZ bir android app null için yukarıda verilen örneklerin çoğunu denedim. Bu yüzden benim için her zaman işe yarayan bir çözüm buldum.

String test = null+"";
If(!test.equals("null"){
       //go ahead string is not null

}

Boş bir dizeyi yukarıda yaptığım gibi birleştirin ve "null" a karşı test edin ve iyi çalışır. Aslında hiçbir istisna atılmaz

İstisna ayrıca yardımcı olabilir:

try {
   //define your myString
}
catch (Exception e) {
   //in that case, you may affect "" to myString
   myString="";
}

Android'de çalışıyorsanız, basit TextUtils sınıfını kullanabilirsiniz. Aşağıdaki kodu kontrol edin:

if(!TextUtils.isEmpty(myString)){
 //do something
}

Bu kodun basit kullanımıdır. Cevap tekrarlanabilir. Ancak sizin için tek ve basit bir kontrol yapmak basittir.

Null ile kontrol etmelisiniz if(str != null).