Jak sprawdzić, czy mój ciąg jest równy null?

Chcę wykonać jakąś akcję TYLKO JEŻELI mój ciąg ma znaczącą wartość. Więc spróbowałem tego.

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

i to

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

i to

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

i to

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

i to

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

I we wszystkich przypadkach mój program doSomethingpomimo faktu, że mój ciąg JEST PUSTY. To jest równe null. Więc co w tym złego?

DODANY:

Znalazłem przyczynę problemu. Zmienna została zadeklarowana jako łańcuch iw konsekwencji nullprzypisana do tej zmiennej została przekształcona w "null"! Więc if (!myString.equals("null"))działa.

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

Jako dalszy komentarz, powinieneś być świadomy tego terminu w equals umowie:

Od Object.equals(Object):

Dla każdej wartości referencyjnej niż null x, x.equals(null)należy return false.

Aby porównać z, nullużyj x == nullix != null .

Ponadto x.fieldi x.method()rzuca NullPointerExceptionjeśli x == null.

Jeśli myStringtak null, to wywołanie myString.equals(null)lub myString.equals("")zakończy się niepowodzeniem z NullPointerException. Nie można wywołać żadnych metod instancji dla zmiennej o wartości null.

Najpierw sprawdź, czy nie ma wartości null:

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

Wykorzystuje to ocenę zwarcia, aby nie próbować, .equalsjeśli myStringnie przejdzie kontroli zerowej.

Apache commons StringUtils.isNotEmptyto najlepsza droga.

Jeśli myString jest w rzeczywistości null, to każde wywołanie odwołania zakończy się niepowodzeniem z wyjątkiem Null Pointer Exception (NPE). Od wersji java 6 używaj #isEmpty zamiast sprawdzania długości (w żadnym wypadku NIGDY nie twórz nowego pustego ciągu z czekiem).

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

Nawiasem mówiąc, jeśli porównujesz z literałami String, tak jak robisz, odwrócisz instrukcję, aby nie musieć mieć sprawdzenia null, tj.

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

zamiast :

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

PRACA !!!!

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

Musisz sprawdzić, czy myStringobiekt jest null:

if (myString != null) {
    doSomething
}

Jeśli ciąg ma wartość null, wywołania takie jak to powinny zgłosić wyjątek NullReferenceException:

myString.equals (null)

W każdym razie myślę, że taka metoda jest tym, czego chcesz:

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

Następnie w swoim kodzie możesz wykonać następujące czynności:

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

Zachęcam do skorzystania z istniejącego narzędzia lub stworzenia własnej metody:

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

Następnie użyj go, gdy go potrzebujesz:

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

Jak wspomniano powyżej, || i && zwarcie operatorów. Oznacza to, że gdy tylko mogą określić swoją wartość, przestają. Więc jeśli (string == null) jest prawdziwe, część długości nie musi być oceniana, ponieważ wyrażenie zawsze byłoby prawdziwe. Podobnie z &&, gdzie jeśli lewa strona jest fałszywa, wyrażenie jest zawsze fałszywe i nie trzeba go dalej oceniać.

Jako dodatkowa uwaga, użycie length jest generalnie lepszym pomysłem niż użycie .equals. Wydajność jest nieco lepsza (niewiele) i nie wymaga tworzenia obiektów (chociaż większość kompilatorów może to zoptymalizować).

Próbować,

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

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

        // your magic here

 }

Nawiasem mówiąc, jeśli wykonujesz wiele operacji na ciągach, istnieje świetna klasa Spring z różnymi użytecznymi metodami:

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

Za każdym razem, gdy mam do czynienia ze stringami (prawie za każdym razem), zatrzymuję się i zastanawiam się, który sposób jest naprawdę najszybszym sposobem sprawdzenia pustego łańcucha. Oczywiście sprawdzenie string.Length == 0 powinno być najszybsze, ponieważ Length jest właściwością i nie powinno być innego przetwarzania niż pobranie wartości właściwości. Ale potem zadaję sobie pytanie, dlaczego istnieje String.Empty? Powinno być szybsze sprawdzenie, czy nie ma String. Puste niż długość, mówię sobie. Cóż, w końcu postanowiłem to przetestować. Zakodowałem małą aplikację Windows Console, która mówi mi, ile czasu zajmuje wykonanie określonego sprawdzenia dla 10 milionów powtórzeń. Sprawdziłem 3 różne ciągi: ciąg NULL, ciąg pusty i ciąg „”. Użyłem 5 różnych metod: 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

Zgodnie z tymi wynikami wyszukiwanie jest średnio str == nullnajszybsze, ale może nie zawsze przynosić to, czego szukamy. if str = String.Emptylub str = ""skutkuje fałszem. Następnie masz 2 remisujące na drugim miejscu: String.IsNullOrEmpty()i str == null || str.length == 0. Ponieważ String.IsNullOrEmpty()wygląda ładniej i jest łatwiejszy (i szybszy) do napisania, polecam użycie go zamiast innego rozwiązania.

Zrobiłbym coś takiego:

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

• Testowanie pod kątem wartości null sprawdza, czy myString zawiera wystąpienie String.
• length () zwraca długość i jest równoważne z równymi („”).
• Sprawdzenie, czy myString ma wartość null, pozwoli uniknąć wyjątku NullPointerException.

Używałem StringUtil.isBlank(string)

Sprawdza, czy łańcuch jest pusty: null, emtpy lub tylko białe znaki.

Więc ten jest jak dotąd najlepszy

Oto oryginalna metoda z dokumentacji

/**
    * 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;
    } 

To powinno działać:

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

Jeśli nie, to myString prawdopodobnie ma wartość, której się nie spodziewasz. Spróbuj wydrukować to w następujący sposób:

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

Użycie symboli „+” do otaczania ciągu pokaże ci, czy jest tam dodatkowa spacja, której nie bierzesz pod uwagę.

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

OK, tak działają typy danych w Javie. (Musisz wybaczyć mój angielski, prawdopodobnie nie używam właściwego słownictwa. Musisz rozróżnić dwa z nich. Podstawowe typy danych i normalne typy danych. Podstawowe typy danych w zasadzie składają się na wszystko, co istnieje. Na przykład to wszystkie liczby, znaki, wartości logiczne itp. Reszta to zwykłe lub złożone typy danych. Łańcuch to tablica znaków, a zatem złożony typ danych.

Każda utworzona zmienna jest w rzeczywistości wskaźnikiem wartości w Twojej pamięci. Na przykład:

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

zmienna „s” NIE zawiera łańcucha. To jest wskaźnik. Ten wskaźnik wskazuje na zmienną w twojej pamięci. Kiedy wywołujesz System.out.println(anyObject), wywoływana jest toString()metoda tego obiektu. Jeśli nie nadpisał toStringz Object, wydrukuje wskaźnik. Na przykład:

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

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

Wszystko za „@” to wskaźnik. Działa to tylko w przypadku złożonych typów danych. Prymitywne typy danych są BEZPOŚREDNIO zapisywane we wskaźnikach. W rzeczywistości nie ma wskaźnika, a wartości są przechowywane bezpośrednio.

Na przykład:

int i = 123;

W tym przypadku NIE przechowuję wskaźnika. będę przechowywać wartość całkowitą 123 (w bajtach ofc).

Ok, więc wróćmy do ==operatora. Zawsze porównuje wskaźnik, a nie zawartość zapisaną w miejscu wskaźnika w pamięci.

Przykład:

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

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

>>>>> false

To oba String mają inny wskaźnik. Jednak String.equals (String other) porównuje zawartość. Możesz porównać pierwotne typy danych za pomocą operatora „==”, ponieważ wskaźnik dwóch różnych obiektów o tej samej zawartości jest równy.

Null oznaczałoby, że wskaźnik jest pusty. Domyślnym pustym typem danych pierwotnych jest 0 (dla liczb). Jednak wartość Null dla dowolnego obiektu złożonego oznacza, że ​​obiekt ten nie istnieje.

Pozdrowienia

Dla mnie najlepszym sposobem sprawdzenia, czy łańcuch ma jakąkolwiek sensowną zawartość w Javie, jest to:

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

Najpierw sprawdzasz, czy łańcuch należy nullunikać, NullPointerExceptiona następnie przycinasz wszystkie znaki spacji, aby uniknąć sprawdzania łańcuchów, które mają tylko białe spacje, a na końcu sprawdzasz, czy przycięty ciąg nie jest pusty, tj. Ma długość 0.

Miałem ten problem w Androidzie i używam tego sposobu (Pracuj dla mnie):

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

Ale w kodzie java używam:

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

I :

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);
}

Wolę używać:

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

Przeczytaj StringUtils.isBlank () vs String.isEmpty () .

W Androidzie możesz to sprawdzić za pomocą metody narzędziowej isEmptyz TextUtils,

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

isEmpty(CharSequence str)Metoda sprawdza zarówno warunek, jak nulli długość.

Zawsze używam w ten sposób:

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

lub możesz skopiować to do swojego projektu:

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

i nazwij to tak:

boolean b = isEmptyOrNull(yourString);

zwróci wartość true, jeśli jest pusta lub null.
b=truejeśli jest pusty lub zerowy

lub możesz użyć try catch and catch, gdy jest zerowy.

Myślę, że myString nie jest ciągiem, ale tablicą ciągów. Oto, co musisz zrobić:

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

Możesz sprawdzić ciąg równy null za pomocą tego:

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

Jeśli wynikiem jest 0, to (Test + „”) = „null”.

Wypróbowałem większość przykładów podanych powyżej dla wartości null w aplikacji na Androida, którą budowałem i WSZYSTKO NIE POWIODŁO SIĘ. Więc wymyśliłem rozwiązanie, które zawsze działało dla mnie.

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

}

Więc po prostu połącz pusty ciąg, tak jak zrobiłem powyżej, i przetestuj pod kątem „null” i działa dobrze. W rzeczywistości nie jest zgłaszany żaden wyjątek

Wyjątek może również pomóc:

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

Jeśli pracujesz w systemie Android, możesz użyć prostej klasy TextUtils. Sprawdź poniższy kod:

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

To jest proste użycie kodu. Odpowiedź można powtórzyć. Ale łatwo jest mieć jedno i proste sprawdzenie dla Ciebie.

Musisz sprawdzić z null if(str != null).