Vocês também são loucos por validação de NULL?

Há validações e validações. Se houver hipóteses de o objecto vir null, é claro que tem de se validar para não dar NPE.
Agora validar depois de trim é absurdo, pois nunca virá null nesse caso.

Em casos em que o dado pode ser nulo ou não costumo verificar sim, mas olhando o seu código de exemplo eu não usaria por exemplo verificar se uma lista é igual a null e e verificar se ela é vazia e logo abaixo caso não for você percorre todas as posições dela, ou seja você ao percorrer se não tiver nada ele pula o for nem precisava colocar isso no if por exemplo, e nesse caso que você usa o metodo trim() da String e depois que verifica que ela é nula, seu código já pararia no trim() se a String verificada for nula.

Flw

hypper:

Como podem ver, tem operações, tipo trim(), que não precisaria verificar se o retorno foi NULL, mas eu tenho mania de validar tudo.
Será que estou gerando esforço desnecessário na JVM?

retornaDadosLista() poderia retornar uma lista vazia ao invés de null. Também não tem sentido (ao menos aparentemente) a lista ter elementos null.

Veja a diferença:

List<String> lista = retornaDadosLista(); for (String s : lista) { s = s.trim(); ... }

Está dando para ver no seu código que algumas validações que você faz são desnecessárias.

Verifique todas as ações executadas em cada linha de código e só faça validações se necessário.
Por exemplo:

if (s != null && s.length() !=0))  
      {  
        // remove os espaços  
        s = s.trim();  
...

Pra que você está dando trim na string e comparando se é igual a 0?
Eu faria assim:

if (s != null)  
      {  
        
        // remove os espaços  
        s = s.trim();  

        if (!s.equals("")) {
...

Porquê você teria certeza que o if não entra em string vazia - o usuário poderia digitar " " e o seu código não detectaria isso.

Essa parte é totalmente desnecessária:

// remove os espaços  
        s = s.trim();  
        if (s != null)  
          {  
             ...  
          }

Se você está verificando no if superior que “s” não é nulo, para quê verificar se “s” é nulo (de novo)? Não têm nenhuma possilidade do “s” virar nulo dentro desse if.
Se não há essa possibilidade (o trim() não vai retornar null), então evite esse if.

Analise as ações que seu código está tomando e a possibilidade de suas varíaveis ficarem com valores inválidos. Se a possibilidade existir, só daí você faz a validação. Blz?

Eu costumo usar sempre lista vazia e nunca null, então quando a variavel é do tipo de Collection nunca verifico null pois construo o sistema para retorna sempre vazio.
Agora com outros tipos principalmente String sempre verifico antes de fazer algo para evitar NullPointer, nunca tenho medo de mudar algo do banco pois sei que o sistema estara preparado para aquele valor pois sempre estou tratando.
Eu utilizo bastante lib pra mexer com String p/ facilitar as comparações, eu tenho uma lib só pra isso, OpenSutilshttp://code.google.com/p/opensutils-br4j/w/list, e existem varias outras como da Apache commons-lang e ao inves de fazer isso:

String valor ="";
if( valor != null && !valor.isEmpty()){
}

faço isso:

String valor ="";
if( !StringUtils.isNullOrEmpty(valor)){
}

• Simples

hypper:

E ai pessoal.

List<String> lista = retornaDadosLista();

if (lista != null && !lista.isEmpty())
{
for (String s: lista)
  {
if (s != null && s.length() !=0))
     {
       // remove os espaços
       s = s.trim();
       if (s != null) // ????????
         {
            ...
         }
     }
  }
}

Desde quando o método String#trim() retorna null ??? Pra que vc fez esse IF ???

Respondendo ao seu quiestionamento. Talvez separando um pouco em conceitos do tipo “validação” e “verificação”.

Validação: O valor é diferente de nulo.
Verificação: O valor esta de acordo com o que estou buscando.

if (s != null) {  //Validação
   if (s.contains("Casa")){} //Verificação
}

Valeu as dicas pessoal. Lembrando que esse código foi só uma demonstração dos tipos de validação desnecessárias que eu costumo fazer. Eu fiz ele na mão rapidinho.

Acho que eu tenho algum trauma de que por algum motivo X a variável receba null, mesmo que qualquer método que sete valores nela não possa fazer isso.

Vou começar a analisar melhor antes de ficar validando sem necessidade