Comparar String com null e ""

Programação Java
#1

Colegas,

Existe outra forma mais ‘elegante’ de se comparar um String com null e vazio?

if (meuString != null && !meuString.isEmpty() ) {
	System.out.println("passei aki");
}

Sds,

Marques

#2

É interessante notar que, caso a comparação seja feita da seguinte forma:

if(b != null && !b.isEmpty()) {
    //write!
}

a máquina virtal verifica se a é string possui é nula e desta forma, se verdadeiro, não verifica a comparação seguinte (não gerando um nullPointerException).

Caso a comparação seja feita com os comparadores na ordem inversa:

if(!b.isEmpty() && b != null) {
    //write!
}

Ao acessar uma referência nula, sempre será lancada uma nullPointerException.

Logo, com o intuito de melhor a leitura do código eu escreveria:

if(b != null) {
    if(!b.isEmpty()) {
        //write!
    }
}
#3

Infelizmente é isso mesmo que você tem de fazer.

#4

[quote=Marques]Colegas,

Existe outra forma mais ‘elegante’ de se comparar um String com null e vazio?

if (meuString != null && !meuString.isEmpty() ) {
	System.out.println("passei aki");
}

[/quote]

em termos de instruções não muito, em termos de “elegancia” sim

if (Strings.isEmpty(meuString)) {
	System.out.println("passei aki");
}

public final class Strings {

     private Strings {} // utilitário

     public static boolean isEmpty(CharSequence sequence){
             return sequence != null && sequence.length() ==0;
    }

     public static boolean isTrimEmpty(CharSequence sequence){
             return sequence != null && sequence.toString().trim().isEmpty();
    }

}

Cuidado com as Strings apenas com espaços vazios.

#5

Eu costumo utilizar os métodos da classe StringUtils do Apache Commons Lang.

http://commons.apache.org/lang/apidocs/org/apache/commons/lang/StringUtils.html

Para validação de String utilizo muito o método a seguir da classe citada acima:

IsEmpty/IsBlank - checks if a String contains text

#6

Você pode fazer isso:

if ("".equals(meuString)) { // código }

Não irá gerar Null Pointer porque o objeto que será chamado o equals é um objeto que existe e acabou de ser criado (""), e como define o contrato do equals(), qualquer objeto comparado a null deve retornar false.

For any non-null reference value x, x.equals(null) should return false.

#7

[quote=andeb]Você pode fazer isso:

if ("".equals(meuString)) { // código }

Não irá gerar Null Pointer porque o objeto que será chamado o equals é um objeto que existe e acabou de ser criado (""), e como define o contrato do equals(), qualquer objeto comparado a null deve retornar false.

For any non-null reference value x, x.equals(null) should return false. [/quote]

Tudo certo, excepto que não é isso que ele quer… Ele não quer que seja nula nem vazia e aí, tem de fazer as duas comparações…

#8

Dependendo do contexto até chegar ao método que faz este if você pode considerar o uso da JSR 303 (Hibernate Validator).

Eu acredito realmente que este tipo de validação não deve estar na implementação da regra propriamente dita e sim em algum contexto que envolve este método. Por exemplo se a chegada até este método é via um web service vocẽ deve habilitar a validação pelo schema, se é feita também por uma tela você deve usar campo requerido.

E a NPE? Faz parte do fluxo. Se os parâmetros de entrada não são fornecidos corretamente uma NPE traduz perfeitamente o que aconteceu e o desenvolvedor deve corrigir o cliente para suportar mensagens amigaveis.

O if muda o fluxo do negócio? Talvez este seja o caso de implementar dois métodos diferentes ou realmente usar o if como apresentado.

#9

Tanto o Hibernate Validator quanto o StringUtils do Apache Commons Lang utiliza essa fórmula por baixo dos panos
Sendo assim continue utilizando essa forma, pois é a melhor forma e não retorna NullPointerException

#10

Eu costumo usar a mesma solução do sergiotaborda, mas utilizando um wrapper ao invés de uma classe com métodos estáticos:

[code]public final class StringWrapper {
private String s;

private StringWrapper(String s) {
    this.s = s;
}

public static StringWrapper wrappedString(String s) {
    return new StringWrapper(s);
}

public boolean isEmpty() {
    return (s == null || s.isEmpty());
}

// Outros métodos utilitários envolvendo strings

}[/code]
E pra usar:

[code]// import static
if (wrappedString(s).isEmpty()) {

}[/code]
Apenas uma forma diferente de fazer a mesma coisa.

#11