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
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
É 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!
}
}
Infelizmente é isso mesmo que você tem de fazer.
[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.
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
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=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…
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.
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
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.