Devo usar string.isEmpty () ou “” .equals (string)?

O título basicamente diz tudo. Normalmente, estou testando isso ao lado de a string == null, então não estou realmente preocupado com um teste com segurança nula. Qual devo usar?

String s = /* whatever */;
...
if (s == null || "".equals(s))
{
    // handle some edge case here
}

ou

if (s == null || s.isEmpty())
{
    // handle some edge case here
}

Na mesma nota - faz isEmpty()mesmo outra coisa senão return this.equals("");ou return this.length() == 0;?

O principal benefício "".equals(s)é que você não precisa da verificação nula ( equalsirá verificar seu argumento e retornar falsese for nulo), com o qual você parece não se importar. Se você não está preocupado em sser nulo (ou está verificando isso), eu definitivamente usaria s.isEmpty(); mostra exatamente o que você está verificando, você se importa se sestá vazio ou não , se não é igual à string vazia

String.equals("")é realmente um pouco mais lento do que apenas uma isEmpty()chamada. Strings armazenam uma variável de contagem inicializada no construtor, pois Strings são imutáveis.

isEmpty() compara a variável count a 0, enquanto igual verifica o tipo, o comprimento da string e, em seguida, itera sobre a string para comparação, se os tamanhos corresponderem.

Então, para responder sua pergunta, isEmpty()realmente fará muito menos! e isso é uma coisa boa.

Uma coisa que você pode considerar além das outras questões mencionadas é a isEmpty()introduzida na 1.6, portanto, se você a usar, não poderá executar o código no Java 1.5 ou abaixo.

Você pode usar o apache commons StringUtils isEmpty () ou isNotEmpty ().

Realmente não importa. "".equals(str)é mais claro na minha opinião.

isEmpty()retornos count == 0;

Eu escrevi uma classe de testador que pode testar o desempenho:

public class Tester
{
    public static void main(String[] args)
    {
        String text = "";

        int loopCount = 10000000;
        long startTime, endTime, duration1, duration2;

        startTime = System.nanoTime();
        for (int i = 0; i < loopCount; i++) {
            text.equals("");
        }
        endTime = System.nanoTime();
        duration1 = endTime - startTime;
        System.out.println(".equals(\"\") duration " +": \t" + duration1);

        startTime = System.nanoTime();
        for (int i = 0; i < loopCount; i++) {
            text.isEmpty();
        }
        endTime = System.nanoTime();
        duration2 = endTime - startTime;
        System.out.println(".isEmpty() duration "+": \t\t" + duration2);

        System.out.println("isEmpty() to equals(\"\") ratio: " + ((float)duration2 / (float)duration1));
    }
}

Descobri que o uso de .isEmpty () levava cerca de metade do tempo de .equals ("").