Como verificar uma string em relação a null em java?

Como posso verificar uma string em relação a null em java? estou usando

stringname.equalsignorecase(null)

mas não está funcionando.

string == nullcompara se o objeto é nulo. string.equals("foo")compara o valor dentro desse objeto. string == "foo"nem sempre funciona, porque você está tentando ver se os objetos são os mesmos, não os valores que eles representam.

Resposta mais longa:

Se você tentar fazer isso, não funcionará, pois você descobriu:

String foo = null;
if (foo.equals(null)) {
    // That fails every time. 
}

A razão é que foo é nulo, então ele não sabe o que é .equals; não há nenhum objeto a partir do qual .equals possa ser chamado.

O que você provavelmente queria era:

String foo = null;
if (foo == null) {
    // That will work.
}

A maneira típica de se proteger contra um null ao lidar com Strings é:

String foo = null;
String bar = "Some string";
...
if (foo != null && foo.equals(bar)) {
    // Do something here.
}

Dessa forma, se foo for nulo, ele não avalia a segunda metade da condicional e está tudo bem.

A maneira mais fácil, se você estiver usando um literal String (em vez de uma variável), é:

String foo = null;
...
if ("some String".equals(foo)) {
    // Do something here.
}

Se você quiser contornar isso, o Apache Commons tem uma classe - StringUtils - que fornece operações String seguras para nulos.

if (StringUtils.equals(foo, bar)) {
    // Do something here.
}

Outra resposta estava brincando e disse que você deveria fazer o seguinte:

boolean isNull = false;
try {
    stringname.equalsIgnoreCase(null);
} catch (NullPointerException npe) {
    isNull = true;
}

Por favor, não faça isso. Você só deve lançar exceções para erros excepcionais; se você está esperando um valor nulo, deve verificar com antecedência e não deixá-lo lançar a exceção.

Na minha cabeça, existem duas razões para isso. Primeiro, as exceções são lentas; a verificação em relação a nulo é rápida, mas quando a JVM lança uma exceção, leva muito tempo. Em segundo lugar, o código é muito mais fácil de ler e manter se você apenas verificar o ponteiro nulo com antecedência.

s == null

não vai funcionar?

Claro que funciona. Você está perdendo uma parte vital do código. Você só precisa fazer assim:

boolean isNull = false;
try {
    stringname.equalsIgnoreCase(null);
} catch (NullPointerException npe) {
    isNull = true;
}

;)

Use o método TextUtils se você estiver trabalhando no Android.

TextUtils.isEmpty (str) : Retorna verdadeiro se a string for nula ou de comprimento 0. Parâmetros: str a string a ser examinada Retorna: verdadeiro se str for nulo ou comprimento zero

  if(TextUtils.isEmpty(str)) {
        // str is null or lenght is 0
    }

Abaixo está o código-fonte deste método. Você pode usar direclty.

 /**
     * Returns true if the string is null or 0-length.
     * @param str the string to be examined
     * @return true if str is null or zero length
     */
    public static boolean isEmpty(CharSequence str) {
        if (str == null || str.length() == 0)
            return true;
        else
            return false;
    }

Se olharmos para a implementação do método equalsIgnoreCase, encontramos esta parte:

if (string == null || count != string.count) {
    return false;
}

Portanto, ele sempre retornará falsese o argumento for null. E isso está obviamente certo, porque o único caso em que ele deve retornar trueé quando equalsIgnoreCase foi invocado em um null String, mas

String nullString = null;
nullString.equalsIgnoreCase(null);

definitivamente resultará em um NullPointerException.

Portanto, os métodos equals não são projetados para testar se um objeto é nulo, apenas porque você não pode invocá-los null.

Isso parece um pouco estranho, mas ...

stringName == null || "".equals(stringName)

Nunca tive problemas ao fazer isso, além de ser uma maneira mais segura de verificar, evitando exceções de pontos nulos em potencial.

Não tenho certeza do que havia de errado com a resposta do MYYN.

if (yourString != null) {
  //do fun stuff with yourString here
}

A verificação nula acima é muito boa.

Se você está tentando verificar se uma referência de String é igual (ignorando maiúsculas e minúsculas) a outra string que você sabe que não é uma referência nula, faça algo assim:

String x = "this is not a null reference"
if (x.equalsIgnoreCase(yourStringReferenceThatMightBeNull) ) {
  //do fun stuff
}

Se houver qualquer dúvida se você tem ou não referências nulas para ambas as Strings que está comparando, você precisará verificar se há uma referência nula em pelo menos uma delas para evitar a possibilidade de um NullPointerException.

Se sua string tiver valor "nulo", você pode usar

if(null == stringName){

  [code]

}

else

[Error Msg]

importe na sua aula

import org.apache.commons.lang.StringUtils;

então use-o, os dois retornarão verdadeiro

System.out.println(StringUtils.isEmpty(""));
System.out.println(StringUtils.isEmpty(null)); 

Você pode verificar com String == null

Isso funciona para mim

    String foo = null;
    if(foo == null){
        System.out.println("String is null");
    }

Claro, user351809 stringname.equalsignorecase(null)lançará NullPointerException.
Veja, você tem um objeto string stringname, que segue 2 condições possíveis: -

1. stringnametem um valor de string não nulo (digamos "computador"):
   Seu código funcionará bem, pois assume a forma
   "computer".equalsignorecase(null)
   e você obtém a resposta esperada como false.
2. stringnametem um nullvalor:
   aqui seu código ficará travado, pois
   null.equalsignorecase(null)
   No entanto, parece bom à primeira vista e você pode esperar uma resposta true, pois ,
   mas, nullnão é um objeto que pode executar o equalsignorecase()método.

Portanto, você obtém a exceção devido ao caso 2.
O que eu sugiro que você simplesmente usestringname == null

Método simples:

public static boolean isBlank(String value) {
    return (value == null || value.equals("") || value.equals("null") || value.trim().equals(""));
}

Se o valueretornado for nulo, use:

if(value.isEmpty());

Às vezes, para verificar o valor nulo, if(value == null)em java, pode não ser verdadeiro mesmo que a string seja nula.

Com Java 7 você pode usar

if (Objects.equals(foo, null)) {
    ...
}

que retornará truese ambos os parâmetros forem null.

Sei que isso foi respondido há muito tempo, mas não vi isso postado, então pensei em compartilhar o que faço. Isso não é particularmente bom para a legibilidade do código, mas se você tiver que fazer uma série de verificações de nulos, gosto de usar:

String someString = someObject.getProperty() == null ? "" : someObject.getProperty().trim();

Neste exemplo, trim é chamado na string, o que lançaria um NPE se a string fosse nula ou espaços, mas na mesma linha, você pode verificar se há nulo ou em branco para não acabar com uma tonelada de (mais ) difícil de formatar se blocos.

Se bem entendi, isso deve bastar:

if(!stringname.isEmpty())
// an if to check if stringname is not null
if(stringname.isEmpy())
// an if to check if stringname is null

Bem, a última vez que alguém fez essa pergunta boba, a resposta foi:

someString.equals("null")

Essa "correção" apenas esconde o problema maior de como nullse torna, "null"em primeiro lugar.

Existem duas maneiras de fazer isso .. Diga String == null ou string.equals () ..

public class IfElse {

    public int ifElseTesting(String a){
        //return null;
        return (a== null)? 0: a.length();
    }

}

public class ShortCutifElseTesting {

    public static void main(String[] args) {

        Scanner scanner=new Scanner(System.in);
        System.out.println("enter the string please:");
        String a=scanner.nextLine();
        /*
        if (a.equals(null)){
            System.out.println("you are not correct");
        }
        else if(a.equals("bangladesh")){
            System.out.println("you are right");
        }
        else
            System.out.println("succesful tested");

        */
        IfElse ie=new IfElse();
        int result=ie.ifElseTesting(a);
        System.out.println(result);

    }

}

Verifique este exemplo ... Aqui está outro exemplo de versão de atalho de If Else ..