Como verificar se minha string é igual a null?

Eu quero executar alguma ação SOMENTE SE minha string tiver um valor significativo. Então, eu tentei isso.

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

e isto

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

e isto

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

e isto

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

e isto

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

E em todos os casos, meu programa doSomething, apesar do fato de que minha string É VAZIA. É igual a null. Então, o que há de errado com isso?

ADICIONADO:

Eu encontrei a razão do problema. A variável foi declarada como uma sequência e, como conseqüência, nullatribuída a essa variável foi transformada em "null"! Então, if (!myString.equals("null"))funciona.

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

Como comentário adicional, você deve estar ciente deste termo no equalscontrato:

De Object.equals(Object):

Para qualquer valor de referência não nulo x, x.equals(null)deveria return false.

A maneira de comparar com nullé usar x == nulle x != null.

Além disso, x.fielde x.method()joga NullPointerExceptionse x == null.

Se myStringestiver null, ligue myString.equals(null)ou myString.equals("")falhará com a NullPointerException. Você não pode chamar nenhum método de instância em uma variável nula.

Verifique se há nulo primeiro assim:

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

Este faz uso de avaliação de curto-circuito para não tentar a .equalsse myStringfalhar a verificação de nulo.

O Apache commons StringUtils.isNotEmptyé o melhor caminho a percorrer.

Se myString for de fato nulo, qualquer chamada à referência falhará com uma NPE (Null Pointer Exception). Desde o java 6, use #isEmpty em vez da verificação do comprimento (em qualquer caso, NUNCA crie uma nova String vazia com a verificação).

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

Aliás, se comparar com literais de String como você faz, reverteria a instrução para não precisar de uma verificação nula, ou seja,

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

ao invés de :

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

TRABALHANDO !!!!

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

Você precisa verificar se o myStringobjeto é null:

if (myString != null) {
    doSomething
}

Se sua string for nula, chamadas como essa devem gerar uma NullReferenceException:

myString.equals (null)

Mas enfim, acho que um método como esse é o que você deseja:

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

Então, no seu código, você pode fazer coisas assim:

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

Eu recomendaria o uso de um utilitário existente ou a criação de seu próprio método:

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

Em seguida, basta usá-lo quando precisar:

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

Como observado acima, o || e && operadores curto-circuito. Isso significa que assim que eles podem determinar seu valor, eles param. Portanto, se (string == null) for verdadeira, a parte do comprimento não precisará ser avaliada, pois a expressão sempre seria verdadeira. Da mesma forma com &&, onde se o lado esquerdo for falso, a expressão será sempre falsa e não precisará mais ser avaliada.

Como uma observação adicional, usar comprimento geralmente é uma ideia melhor do que usar .equals. O desempenho é um pouco melhor (não muito) e não requer criação de objeto (embora a maioria dos compiladores possa otimizar isso).

Experimentar,

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

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

        // your magic here

 }

Incidentalmente, se você estiver fazendo muita manipulação de cadeias, há uma ótima classe Spring com todos os tipos de métodos úteis:

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

Toda vez que tenho que lidar com strings (quase todas as vezes), paro e me pergunto qual é a maneira mais rápida de verificar se há uma string vazia. É claro que a verificação string.Length == 0 deve ser a mais rápida, pois Length é uma propriedade e não deve haver outro processamento além de recuperar o valor da propriedade. Mas então eu me pergunto: por que existe um String.Empty? Deveria ser mais rápido procurar por String.Empty do que por comprimento, digo a mim mesma. Bem, finalmente decidi testá-lo. Codifiquei um pequeno aplicativo do Windows Console que me diz quanto tempo leva para fazer uma determinada verificação de 10 milhões de repetições. Eu verifiquei três strings diferentes: uma string NULL, uma vazia e uma "". Eu usei 5 métodos diferentes: String.IsNullOrEmpty (), str == null, str == null || str == String.Empty, str == nulo || str == "", str == nulo || 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

De acordo com esses resultados, em média, a verificação str == nullé a mais rápida, mas nem sempre produz o que estamos procurando. if str = String.Emptyou str = "", isso resulta em falso. Então você tem 2 que estão empatados em segundo lugar: String.IsNullOrEmpty()e str == null || str.length == 0. Desde que String.IsNullOrEmpty()parece mais agradável e é mais fácil (e mais rápido) de escrever, eu recomendaria usá-lo sobre a outra solução.

Eu faria algo assim:

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

• O teste para nulo verifica se myString contém uma instância de String.
• length () retorna o comprimento e é equivalente a igual a ("").
• Verificar se myString é nulo primeiro evitará uma NullPointerException.

Eu tenho usado StringUtil.isBlank(string)

Ele testa se uma string está em branco: nulo, vazio ou apenas espaço em branco.

Então este é o melhor até agora

Aqui está o método original dos documentos

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

Isso deve funcionar:

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

Caso contrário, é provável que o myString tenha um valor que você não está esperando. Tente imprimi-lo assim:

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

O uso dos símbolos '+' para cercar a string mostrará se há espaço em branco extra no qual você não está respondendo.

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

Ok, é assim que os tipos de dados funcionam em Java. (Você precisa desculpar meu inglês, provavelmente não estou usando o vocabulário certo. Você precisa diferenciar entre dois. Os tipos de dados base e os tipos de dados normais. Os tipos de dados base compõem praticamente tudo o que existe. Por exemplo, são todos números, char, booleano, etc. Os tipos de dados normais ou complexos são tudo o mais.Um String é uma matriz de caracteres, portanto um tipo de dados complexo.

Toda variável que você cria é realmente um ponteiro sobre o valor em sua memória. Por exemplo:

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

a variável "s" NÃO contém uma String. É um ponteiro. Este ponteiro aponta para a variável em sua memória. Quando você chama System.out.println(anyObject), o toString()método desse objeto é chamado. Se não substituir o toStringobjeto, imprimirá o ponteiro. Por exemplo:

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

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

Tudo por trás do "@" é o ponteiro. Isso funciona apenas para tipos de dados complexos. Tipos de dados primitivos são salvas DIRETAMENTE em seus ponteiros. Portanto, na verdade, não há ponteiro e os valores são armazenados diretamente.

Por exemplo:

int i = 123;

Eu não armazeno um ponteiro nesse caso. armazenarei o valor inteiro 123 (em byte ofc).

Ok, então vamos voltar para o ==operador. Ele sempre compara o ponteiro e não o conteúdo salvo na posição do ponteiro na memória.

Exemplo:

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

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

>>>>> false

Essa String tem um ponteiro diferente. String.equals (String other), no entanto, compara o conteúdo. Você pode comparar tipos de dados primitivos com o operador '==' porque o ponteiro de dois objetos diferentes com o mesmo conteúdo é igual.

Nulo significaria que o ponteiro está vazio. Um tipo de dados primitivo vazio por padrão é 0 (para números). Nulo para qualquer objeto complexo, no entanto, significa que esse objeto não existe.

saudações

Para mim, a melhor verificação se uma string tem algum conteúdo significativo em Java é esta:

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

Primeiro, verifique se a string deve nullser evitada NullPointerExceptione, em seguida, apare todos os caracteres de espaço para evitar verificar as strings que possuem apenas espaços em branco e, finalmente, verifique se a string aparada não está vazia, ou seja, tem comprimento 0.

Eu tive esse problema no android e uso dessa maneira (trabalhe para mim):

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

Mas no código java eu ​​uso:

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

E:

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

Eu prefiro usar:

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

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

No Android, você pode verificar isso com o método utilitário isEmptyde TextUtils,

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

isEmpty(CharSequence str)O método verifica tanto a condição nullquanto o comprimento.

Eu sempre uso assim:

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

ou você pode copiar isso para o seu projeto:

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

e chame assim:

boolean b = isEmptyOrNull(yourString);

retornará true se estiver vazio ou nulo.
b=truese estiver vazio ou nulo

ou você pode usar try catch and catch quando for nulo.

Eu acho que myString não é uma string, mas uma matriz de strings. Aqui está o que você precisa fazer:

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

Você pode verificar uma sequência igual a nula usando este:

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

Se o resultado for 0, então (Teste + "") = "nulo".

Tentei a maioria dos exemplos dados acima para um valor nulo em um aplicativo Android que eu estava criando e tudo falhou. Então, eu vim com uma solução que funcionava a qualquer momento para mim.

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

}

Então, simplesmente concatene uma string vazia como fiz acima e teste contra "null" e ela funciona bem. De fato, nenhuma exceção é lançada

A exceção também pode ajudar:

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

Se você estiver trabalhando no Android, poderá usar a classe TextUtils simples. Verifique o seguinte código:

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

Este é um uso simples de código. A resposta pode ser repetida. Mas é simples ter uma verificação simples e simples para você.

Você tem que verificar com nulo if(str != null).