Como verificar se minha string é igual a null?

172

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.

romano
fonte
2
nullnão possui métodos, também não equals(). Se myStringfosse null, como você invocaria um método? :)
BalusC
1
Posso sugerir que você System.out.println(myString)imediatamente antes do if-block para que você possa ver o que há lá?
Michael Myers
1
Como você sabe que "é igual a null"?
Richard JP Le Guen
6
nullatribuído a essa variável foi transformado em "null"- esta é uma péssima idéia. Tente alterar esse design, se possível.
polygenelubricants
8
Eca - não acho que verificar se (! MyString.equals ("null")) é a melhor solução. Eu suspeito que a maioria consideraria o ponto no qual a string "null" foi atribuída ao myString como um bug.
Bert F

Respostas:

231
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.

poligenelubricants
fonte
2
Você deve verificar o comprimento em oposição a igual para fins de eficiência. Verifique este link hanuska.blogspot.com/2006/08/empty-string.html
CoolBeans
7
Eu diria que você deve fazer em s.isEmpty()vez de s.length() == 0legibilidade. Qualquer diferença no desempenho é insignificante. Eu concordo que isso s.equals("")é terrível.
polygenelubricants
6
Eu concordo com a legibilidade. Depende se estamos usando Java 5 vs Java 6 desde isEmpty () é apenas em Java 6.
coolbeans
@CoolBeans: Bom comentário! Eu não tinha percebido isso! Estou um pouco atrasado para a festa de Java =) #
11008
26

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.

Michael Myers
fonte
+1 para curto-circuito; é essencial para a expressão funcionar. No entanto, você realmente deve usar em .isEmpty()vez de .equals("").
polygenelubricants
1
Ok, eu pretendia deixar meu comentário neste post. ri muito. -> "Você deve verificar o comprimento em oposição a igual para fins de eficiência. Verifique este link hanuska.blogspot.com/2006/08/empty-string.html"
CoolBeans
@ CoolBeans: Claro, e com o Java 6 você pode fazer myString.isEmpty(). Mas, nesse nível, a legibilidade supera a otimização e as pessoas podem estar mais acostumadas à leitura myString.equals(""). (Ou possivelmente não).
Michael Myers
20

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

kedar
fonte
13

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();
}
corm
fonte
1
Bom argumento, mas os dois últimos ifs não são equivalentes. Com myString = "abc", o do meio não chama doSomething, mas o terceiro.
rimsky
@rimsky corrigido
pavi2410
7

TRABALHANDO !!!!

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

Você precisa verificar se o myStringobjeto é null:

if (myString != null) {
    doSomething
}
WhirlWind
fonte
5

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();
}
Andy White
fonte
5

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).

Matt
fonte
4

Experimentar,

myString!=null && myString.length()>0
bragboy
fonte
isso não é possível se myString for nulo
hsmit 06/01
4
isso é praticamente possível quando myString é nulo. Você deve saber que quando a parte esquerda do && falhar, a expressão direita não será avaliada em todos ..
bragboy
4

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.

ldsant
fonte
3

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.
James P.
fonte
3

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;
    } 
Máx.
fonte
2

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.

elduff
fonte
2

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

Moe
fonte
3
isEmpty é revertida .. se você chamar o método no objeto nulo, você recebe NPE
Brian
Se a sequência for nula, você receberá uma exceção de ponteiro nulo, mesmo antes de verificar se é nula. Este código nunca deve ser usado!
gil.fernandes
2

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

Luecx
fonte
2

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.

gil.fernandes
fonte
1

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);
}
AA
fonte
1

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.

NSK
fonte
1

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.

Web.11
fonte
0

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
}
imitar
fonte
Meu código é para processamento. O processamento é uma linguagem de programação baseada em java. Mais informações sobre join: processing.org/reference/join_.html .
imitar
0

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".

Harrouchi Taher
fonte
isso só cria uma string desnecessário
svarog
0

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

leeCoder
fonte
1
Não, essa é uma solução absolutamente terrível. As respostas acima funcionam.
Konrad Rudolph
@KonradRudolph Na verdade, tentei algumas dessas soluções acima antes de chegar à minha conclusão. Tentei usar essas soluções em um adaptador de reciclagem e ele não me deu o resultado correto até que eu tenha essa resposta.
precisa saber é o seguinte
Posso dizer com confiança que isso significa que há algo mais errado com o seu código, e você está apenas corrigindo os sintomas, não a fonte do erro. Não leve a mal, mas este é um caso típico de programação de cultos de carga .
Konrad Rudolph
0

A exceção também pode ajudar:

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

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ê.

Manmohan Soni
fonte
-5

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

rawa rawandze
fonte
5
Sua solução foi postada por outros usuários anos atrás ... Qual o sentido de repeti-la?
TDG 23/05
1
Eu vejo não das respostas confirmou que é por isso que eu respondo a ele
rawa rawandze
6
Certo, ele não confirmou as respostas desde 2010, assim você só vai repetir uma resposta anterior e ele vai confirmar a sua resposta ...
TDG