Performance em Java para Classes do Dia a Dia

Muitas classes que usamos diariamente, como String, Boolean e Integer possuem �macetes� que �s vezes passam despercebidos pelo desenvolvedor. Iremos abordar nesse artigo alguns desses aspectos, a fim de mostrar as alternativas mais perform�ticas no uso dessas classes.

Classe Boolean


public class CreateBoolean {
    
    public static final int COUNT = 1000;
    
    public static void main(String[] args) {
        
        Boolean b1 = null, b2 = null, b3 = null, b4 = null;
        
        final long startTime = System.nanoTime();
        
        for(int i = 0; i < COUNT; i++) {
            b1 = new Boolean("true");
            b2 = new Boolean("true");
            b3 = new Boolean("false");
            b4 = new Boolean("false");
        }
        
        final long estimatedTime = System.nanoTime() - startTime;
        
        System.out.println("Compare 1 = " + (b1 == b2));
        System.out.println("Compare 2 = " + (b3 == b4));
        
        System.out.println("Tempo decorrido = " + estimatedTime + " nanosegundos");
    }
}

Listagem 1. Criando Boolean via Construtor

Sa�da:

Compare 1 = false
Compare 2 = false
Tempo decorrido = 641950 nanosegundos

Cada chamada a new Boolean() cria um objeto novo na mem�ria. A quantidade de objetos Boolean criados na aplica��o ser� de 4*COUNT.

Analisando o c�digo fonte da classe Boolean:


public final class Boolean implements java.io.Serializable,
      Comparable<Boolean>
{
    /**
     * The {@code Boolean} object corresponding to the primitive
     * value {@code true}.
     */
    public static final Boolean TRUE = new Boolean(true);

    /**
     * The {@code Boolean} object corresponding to the primitive
     * value {@code false}.
     */
    public static final Boolean FALSE = new Boolean(false);

    /**
     * The Class object representing the primitive type boolean.
     *
     * @since   JDK1.1
     */
    public static final Class<Boolean> TYPE = Class.getPrimitiveClass("boolean");

    /**
     * Returns a {@code Boolean} with a value represented by the
     * specified string.  The {@code Boolean} returned represents a
     * true value if the string argument is not {@code null}
     * and is equal, ignoring case, to the string {@code "true"}.
     *
     * @param   s   a string.
     * @return  the {@code Boolean} value represented by the string.
     */
    public static Boolean valueOf(String s) {
        return toBoolean(s) ? TRUE : FALSE;
    }

    private static boolean toBoolean(String name) {
        return ((name != null) && name.equalsIgnoreCase("true"));
    }
    �

Listagem 2. Fragmento de c�digo fonte de Boolean

Vemos que existem duas constantes, TRUE e FALSE, declaradas na classe Boolean. Por ser uma classe imut�vel e thread-safe, podemos utilizar essas constantes para substituir a cria��o via new em qualquer lugar da aplica��o, economizando mem�ria e ganhando velocidade, pois menos objetos ser�o criados, diminuindo o trabalho do Garbage Collector (GC).


public class CreateBoolean {
    
    public static final int COUNT = 1000;
    
    public static void main(String[] args) {
        
        Boolean b1 = null, b2 = null, b3 = null, b4 = null;
        
        final long startTime = System.nanoTime();
        
        for(int i = 0; i < COUNT; i++) {
            b1 = Boolean.TRUE;
            b2 = Boolean.TRUE;
            b3 = Boolean.FALSE;
            b4 = Boolean.FALSE;
        }
        
        final long estimatedTime = System.nanoTime() - startTime;
        
        System.out.println("Compare 1 = " + (b1 == b2));
        System.out.println("Compare 2 = " + (b3 == b4));
        
        System.out.println("Tempo decorrido = " + estimatedTime + " nanosegundos");
    }
}

Listagem 3. Utilizando constantes

Sa�da:

Compare 1 = true
Compare 2 = true
Tempo decorrido = 49075 nanosegundos

Al�m do tempo decorrido ser bem menor ( 641.950 x 49.075 ), as compara��es usando o operador == retornam true, visto que temos refer�ncias somente a 2 objetos do tipo Boolean em mem�ria, ao inv�s dos 4*COUNT objetos do tipo Boolean da vers�o 1 do programa.

Podemos tamb�m usar o m�todo valueOf(), uma vez que ele n�o cria uma nova inst�ncia de Boolean, mas apenas devolve uma das constantes, dependendo do valor da String de entrada.

Recomenda��o: Utilizar Boolean.TRUE, Boolean.FALSE ou Boolean.valueOf() ao inv�s de new Boolean().

Classes Integer / Short / Long / Byte


private static class IntegerCache {
    private IntegerCache(){}

    static final Integer cache[] = new Integer[-(-128) + 127 + 1];

    static {
        for(int i = 0; i < cache.length; i++)
            cache[i] = new Integer(i - 128);
    }
}

/**
 * Returns an {@code Integer} instance representing the specified
 * {@code int} value.  If a new {@code Integer} instance is not
 * required, this method should generally be used in preference to
 * the constructor {@link #Integer(int)}, as this method is likely
 * to yield significantly better space and time performance by
 * caching frequently requested values.
 *
 * @param  i an {@code int} value.
 * @return an {@code Integer} instance representing {@code i}.
 * @since  1.5
 */
public static Integer valueOf(int i) {
    final int offset = 128;
    if (i >= -128 && i <= 127) { // must cache
        return IntegerCache.cache[i + offset];
    }
    return new Integer(i);
}

Listagem 4. Fragmento da classe Integer da API

Verificando o c�digo de valueOf(int), temos uma surpresa, pois existe um esquema de cache interno para vari�veis inteiras no intervalo de -128 a 127, j� que os mesmos s�o criados como objetos Integer no bloco est�tico da classe privada IntegerCache. Devido � classe Integer ser imut�vel, esses objetos pr�-definidos podem ser compartilhados sem nenhum problema com qualquer outra classe da aplica��o.

Exemplificando, se usarmos esse m�todo duas vezes com o mesmo valor, e este estiver no range, apenas um objeto ser� devolvido.


public class IntegerCacheTest {
    
    public static void main(String[] args) {
        
        Integer value1 = Integer.valueOf(1);
        Integer value2 = Integer.valueOf(1);
        Integer value3 = new Integer(1);

        System.out.println("Compare 1 = " + (value1 == value2));
        System.out.println("Compare 2 = " + (value1 == value3));
        
        Integer value4 = Integer.valueOf(159);
        Integer value5 = Integer.valueOf(159);
        Integer value6 = new Integer(159);
        
        System.out.println("Compare 3 = " + (value4 == value5));
        System.out.println("Compare 4 = " + (value4 == value6));
    }
}

Listagem 5. Verificando o esquema de cache

Sa�da:

Compare 1 = true
Compare 2 = false
Compare 3 = false
Compare 4 = false

As vari�veis value1 e value2 apontam para a mesma refer�ncia de mem�ria, devido ao cache interno da classe Integer, por isso o operador == retorna true. J� para value3, um novo objeto � criado, resultando em false a compara��o das refer�ncias.

J� as vari�veis value4 e value5 representam objetos distintos, pois como o valor 159 ultrapassa o range definido, n�o h� cache e um objeto sempre � criado.

Al�m de Integer, as classes Long, Short e Byte tamb�m possuem o mesmo mecanismo de cache para seus respectivos m�todos valueOf(), inclusive utilizando o mesmo range (-128 a 127).

Nota: Observe que esses objetos pr�-criados s�o armazenados num array est�tico final. Isso faz com que eles sejam referenciados praticamente durante toda a execu��o da JVM, ou seja, o GC n�o poder� colet�-los, evitando o overhead de desaloca��o de mem�ria.

Recomenda��o: Utilizar (Integer|Short|Long|Byte).valueOf(), ao inv�s de usar o operador new (note que a classe Byte, cujos valores v�o de -128 a 127, j� possui todo o seu range de valores criados).

Classe String

A classe String � uma das classes mais utilizadas em Java, por isso ela � tratada de forma especial pela JVM. Por ser imut�vel, foi poss�vel implementar o seu conhecido pool interno. Vejamos como ele funciona:


public class StringTest {
 
    public static void main(String[] args) {
        
        final String str1 = "Hello World";
        final String str2 = "Hello World";
        final String str3 = "Hello " + "World";
        final String str4 = "Hello " + new String("World");
        final String str5 = new String(str1);
        final String str6 = new String("Hello " + "World");
        final String str7 = str4.intern();
        
        System.out.println("Compare 1 = " + (str1 == str2));
        System.out.println("Compare 2 = " + (str1 == str3));
        System.out.println("Compare 3 = " + (str1 == str4));
        System.out.println("Compare 4 = " + (str1 == str5));
        System.out.println("Compare 5 = " + (str1 == str6));
        System.out.println("Compare 6 = " + (str1 == str7));
    }
}

Listagem 6. Criando objetos String

Sa�da:

Compare 1 = true
Compare 2 = true
Compare 3 = false
Compare 4 = false
Compare 5 = false
Compare 6 = true

Em Java, todas as Strings Literais s�o armazenadas num pool interno pela JVM, para economizar mem�ria. Por isso o operador == retorna true na compara��o entre a str1 e str2.

Perceba, na compara��o 2, que o Java consegue detectar que a concatena��o de duas literais, no caso �Hello � + �World� ir� resultar numa String que j� est� no pool, portanto apenas uma refer�ncia ser� mantida (�Hello World� literal), e a compara��o retorna true.

O mesmo truque n�o funciona quando se usa new String(str1) ou concatena��o de um literal com um objeto String ("Hello " + new String("World")). Nesse caso, novos objetos s�o criados e os mesmos n�o v�o para o pool.

Por fim, podemos aplicar o m�todo intern a um objeto String, fazendo com que o retorno do m�todo seja:

Se a String n�o existe no pool, a mesma ser� adicionada e a refer�ncia que est� no pool � devolvida
Caso j� haja uma representa��o de String similar no pool interno, uma refer�ncia a String desse pool ser� devolvida.

Ou seja, uma vez aplicado intern, � garantido que a String retornada estar� no pool interno.

Uma quest�o muito importante � que, quando aplicamos: String x = new String(�x�);

Estamos criando 2 objetos! Primeiro a String literal �x�, que ir� para o pool interno. Depois o pr�prio objeto criado por new. Por isso, se comparamos �x� == x, o retorno ser� false, pois s�o refer�ncias para objetos diferentes.

Recomenda��o: Utilize, quando poss�vel, String literais ao inv�s de new.

A classe String tamb�m nos d� alguns dicas de otimiza��o, por exemplo:


/** Cache the hash code for the string */
private int hash; // Default to 0

/**
 * Returns a hash code for this string. The hash code for a
 * <code>String</code> object is computed as
 * <blockquote><pre>
 * s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
 * </pre></blockquote>
 * using <code>int</code> arithmetic, 
 where <code>s[i]</code> is the
 * <i>i</i>th character of the string, 
 <code>n</code> is the length of
 * the string, and <code>^</code> 
 indicates exponentiation.
 * (The hash value of the empty string is zero.)
 *
 * @return  a hash code value for this object.
 */
public int hashCode() {
    int h = hash;
    if (h == 0) {
        int off = offset;
        char val[] = value;
        int len = count;

        for (int i = 0; i < len; i++) {
            h = 31*h + val[off++];
        }
        hash = h;
    }
    return h;
}

Listagem 7. String hashCode

Quando o m�todo � chamado pela primeira vez, o valor do hash code ser� calculado e armazenado no atributo de classe hash. As chamadas subsequentes n�o precisar�o recalcular hash novamente (se ele for diferente de 0), economizando processamento.

Assim, ao criar novas classes e implementar hashCode(), pode-se optar por essa estrat�gia, a fim de economizar processamento, se for necess�rio uma abordagem mais agressiva de desempenho.

Cuidado com Auto-Boxing


public class AutoBoxingTest {

    public static final int COUNT = 100000;    
    
    public static void main(String[] args) {
        
        long startTime = System.nanoTime();        
        Integer value1 = 10;        
        for (int i = 0; i < COUNT; i++) {
            value1 += i;
        }
        long estimatedTime = System.nanoTime() - startTime;
        System.out.println("Tempo decorrido = " + estimatedTime + " nanosegundos");
        
        startTime = System.nanoTime();        
        int value2 = 10;        
        for (int i = 0; i < COUNT; i++) {
            value2 += i;
        }        
        estimatedTime = System.nanoTime() - startTime;
        
        System.out.println("Tempo decorrido = " + estimatedTime + " nanosegundos");
    }
}

Listagem 8. Compara��o entre tipo primitivo e Objeto

Sa�da:

Tempo decorrido = 2649183 nanosegundos
Tempo decorrido = 75948 nanosegundos

Lidar com tipos primitivos � muito mais r�pido do que com suas respectivas classes Wrappers. Devido ao esquema de Auto-Boxing, cada chamada a �value1 += i� ir� resultar na cria��o de um novo objeto, aumentando consideravelmente o tempo de processamento.

Evitar testes com NULL quando n�o necess�rio

Dependendo das assertivas de sua rotina, o teste para comparar um valor NULL pode ser desnecess�rio:


public class NullTest {

    public static void main(String[] args) {
   
        String x = null;
        
        // x != null desnecess�rio, pois equals ao receber null retorna false
        if(x != null && "marcelo".equals(x)) {
            System.out.println("Hello Marcelo");
        }
        
        // x != null desnecess�rio, pois instanceof retorna false quando o objeto � null
        if(x != null && x instanceof String) {
            System.out.println("x is String");
        }
        
        // x != null desnecess�rio, pois valueOf retorna "null" quando objeto � null
        if(x != null && String.valueOf(x).equals("123")) {
            System.out.println("x is String");
        }        
        
        if(!"marcelo".equals(x)) {
            System.out.println("Hello Strange");
        }
        
        if(!(x instanceof String)) {
            System.out.println("x???");
        }        
        
        if(String.valueOf(x).equals("null")) {
            System.out.println("x is null");
        }        
    }    
}

Listagem 9. Testes condicionais desnecess�rios

Utilizando StringBuffer/StringBuilder ao inv�s de concatena��o de Strings em tempo de execu��o


public class StringConcatenationTest {

    public static final int COUNT = 10000;    
    
    public static void main(String[] args) {
        
        long startTime = System.nanoTime();
        String value = "INICIO";
        for (int i = 0; i < COUNT; i++) {
            value += "xy";
        }
        long estimatedTime = System.nanoTime() - startTime;
        System.out.println("Tempo decorrido [CONCATENACAO] = " + estimatedTime + " nanosegundos");
        
        startTime = System.nanoTime();        
        StringBuffer value2 = new StringBuffer("INICIO");
        for (int i = 0; i < COUNT; i++) {
            value2.append("xy");
        }
        estimatedTime = System.nanoTime() - startTime;
        
        System.out.println("Tempo decorrido [StringBuffer] = " + estimatedTime + " nanosegundos");
        
        startTime = System.nanoTime();        
        StringBuilder value3 = new StringBuilder("INICIO");
        for (int i = 0; i < COUNT; i++) {
            value3.append("xy");
        }
        estimatedTime = System.nanoTime() - startTime;
        
        System.out.println("Tempo decorrido [StringBuilder] = " + estimatedTime + " nanosegundos");        
    }
}

Listagem 10. Compara��o entre concatena��o de Strings

Sa�da:

Tempo decorrido [CONCATENACAO] = 475657601 nanosegundos
Tempo decorrido [StringBuffer] = 1081924 nanosegundos
Tempo decorrido [StringBuilder] = 657643 nanosegundos

Usar StringBuffer/StringBuilder � MUITO mais eficaz do que concatena��o de Strings usando vari�veis em tempo de execu��o.

O StringBuilder � tamb�m mais r�pido que o StringBuffer, pois n�o usa sincroniza��o. A quest�o a ser levantada � que, por ser thread-safe, o StringBuffer poderia ser usado ao inv�s do StringBuilder, mesmo ao custo de uma pequena perda de desempenho (que n�o � t�o grande assim), principalmente se voc� usar o StringBuffer como um atributo de classe.


public class UnsafeClass {
    
    private final StringBuilder error = new StringBuilder();
    
    public void addMsgError(final String msgError) {
        this.error.append(msgError);
    }
    
    public String getError() {
        return error.toString();
    }
}

Listagem 11. Classe thread-unsafe

Por exemplo, se uma inst�ncia da classe UnsafeClass for compartilhada por mais de uma thread, e ambas chamarem addMsgError, pode haver a gera��o de estado inconsistente. Para evitar isso, o StringBuffer deve ser usado.

Ambas as classes StringBuilder e StringBuffer herdam (no Java 6) a classe abstrata AbstractStringBuilder, que � thread-unsafe. A �nica diferen�a � que, no m�todo append da classe StringBuffer, a palavra synchronized � utilizada.


// StringBuilder
public StringBuilder append(String str) {
    super.append(str);
    return this;
}

// StringBuffer
public synchronized StringBuffer append(String str) {
    super.append(str);
    return this;
}

Listagem 12. StringBuilder e StringBuffer

Portanto, s� use StringBuilder quando voc� tiver certeza que o m�todo/classe for thread-safe, ou que a mesma n�o seja utilizada em ambientes de m�ltipla thread.

Agora, no caso de simples concatena��o de Strings literais em tempo de compila��o, n�o h� necessidade de se usar StringBuilder / StringBuffer, pois o pr�prio compilador ir� substituir a concatena��o por chamadas a StringBuilder.


public class StringConcatenationTest2 {

    public static final int COUNT = 10000;    
    
    public static void main(String[] args) {
        
        long startTime = System.nanoTime();        
        for (int i = 0; i < COUNT; i++) {
            String value = "INICIO";
            value = "xy" + "wz";
        }
        long estimatedTime = System.nanoTime() - startTime;
        System.out.println("Tempo decorrido [CONCATENACAO] = " 
        + estimatedTime + " nanosegundos");
        
        startTime = System.nanoTime();                
        for (int i = 0; i < COUNT; i++) {
            StringBuilder value2 = new StringBuilder("INICIO");
            value3.append("xy").append("wz");
        }
        estimatedTime = System.nanoTime() - startTime;
        
        System.out.println("Tempo decorrido [StringBuilder] = " 
        + estimatedTime + " nanosegundos");        
    }
}

Listagem 13. StringBuilder vs Concatena��o em tempo de Compila��o

Sa�da:

Tempo decorrido [CONCATENACAO] = 185739 nanosegundos
Tempo decorrido [StringBuilder] = 4276552 nanosegundos

A concatena��o de Strings em tempo de compila��o foi resolvida pelo compilador de uma forma muito mais perform�tica do que o uso direto de StringBuilder (lembrando que esses resultados foram obtidos no Java 6).

Conclus�o

Conhecer bem as classes que usamos diariamente pode render alguns n�veis de otimiza��o no c�digo, principalmente em aplica��es onde o desempenho e tempo de resposta s�o requisitos fundamentais.

Na grande maioria das aplica��es, otimiza��es desse n�vel podem ser desnecess�rias, mas, para n�s desenvolvedores, analisar o c�digo fonte da API do Java pode ser uma �tima fonte de conhecimento e aprendizado.

Os fontes analisados foram do openjdk-6-src-b27-26_oct_2012.tar.gz, cujo download pode ser obtido clicando aqui

Refer�ncias

Livro: Effective Java (Joshua Block)
Livro: Java Performance Tuning (Jack Shirazi)
Java Performance Tuning
String Literal Pool
Make Java fast: Optimize!
Revisitando a concatena��o de Strings: StringBuilder e StringBuffer
Performance em aplica��es Java
Urban performance legends
Anatomy of a flawed microbenchmark
Dynamic compilation and performance measurement

Leia/assista tamb�m

Tecnologias:

Confira outros conte�dos:

Introdu��o ao JDBC

Novidades do Java

Teste unit�rio com JUnit

Assista grátis a nossa aula inaugural

Perguntas frequentes

Quem somos?

Por que a programação se tornou a profissão mais promissora da atualidade?

Como faço para começar a estudar?

Em quanto tempo de estudo vou me tornar um programador?

Sim, você pode se tornar um programador e não precisa ter diploma de curso superior!

O que eu irei aprender estudando pela DevMedia?

Principais diferenciais da DevMedia

Qual o investimento financeiro que preciso fazer para me tornar um programador?

Como funciona a forma de pagamento da DevMedia?

Por Marcelo Em 2013

Nossos casos de sucesso

Leonardo Carlos

Eu sabia pouqu�ssimas coisas de programa��o antes de come�ar a estudar com voc�s, fui me especializando em v�rias �reas e ferramentas que tinham na plataforma, e com essa bagagem consegui um est�gio logo no in�cio do meu primeiro per�odo na faculdade.

Lucas Rodrigues

Estudo aqui na Dev desde o meio do ano passado! Nesse per�odo a Dev me ajudou a crescer muito aqui no trampo.
Fui o primeiro desenvolvedor contratado pela minha empresa. Hoje eu lidero um time de desenvolvimento!
Minha meta � continuar estudando e praticando para ser um Full-Stack Dev!

Her�clito J�nior

Economizei 3 meses para assinar a plataforma e sendo sincero valeu muito a pena, pois a plataforma � bem intuitiva e muuuuito did�tica a metodologia de ensino. Sinto que estou EVOLUINDO a cada dia. Muito obrigado!

Julio Cablen

Nossa! Plataforma maravilhosa. To amando o curso de desenvolvimento front-end, tinha coisas que eu ainda n�o tinha visto. A did�tica � do jeito que qualquer pessoa consegue aprender. S�rio, to apaixonado, adorando demais.

Joelberth Sena

Adquiri o curso de voc�s e logo percebi que s�o os melhores do Brasil. � um passo a passo incr�vel. S� n�o aprende quem n�o quer. Foi o melhor investimento da minha vida!

Felipe Nunes

Foi um dos melhores investimentos que j� fiz na vida e tenho aprendido bastante com a plataforma. Voc�s est�o fazendo parte da minha jornada nesse mundo da programa��o, irei assinar meu contrato como programador gra�as a plataforma.

Wanderson Oliveira

Comprei a assinatura tem uma semana, aprendi mais do que 4 meses estudando outros cursos. Exerc�cios pr�ticos que n�o tem como n�o aprender, est�o de parab�ns!

Jos� Lucas

Obrigado DevMedia, nunca presenciei uma plataforma de ensino t�o presente na vida acad�mica de seus alunos, parab�ns!

Eduardo Dorneles

Aprendi React na plataforma da DevMedia h� cerca de 1 ano e meio... Hoje estou h� 1 ano empregado trabalhando 100% com React!

Adauto Junior

J� fiz alguns cursos na �rea e nenhum � t�o bom quanto o de voc�s. Estou aprendendo muito, muito obrigado por existirem. Est�o de parab�ns... Espero um dia conseguir um emprego na �rea.

Ver todos os casos de sucesso

Performance em Java para Classes do Dia a Dia

Veja nesse artigo como otimizar a performance de aplica��es Java ao explorar os mecanismos por tr�s da API b�sica.

Classe Boolean

Classes Integer / Short / Long / Byte

Classe String

Cuidado com Auto-Boxing

Evitar testes com NULL quando n�o necess�rio

Utilizando StringBuffer/StringBuilder ao inv�s de concatena��o de Strings em tempo de execu��o

Conclus�o

Refer�ncias

Leia/assista tamb�m

Confira outros conte�dos:

Introdu��o ao JDBC

Novidades do Java

Teste unit�rio com JUnit

Perguntas frequentes

Nossos casos de sucesso