Idiomas da linguagem Java
1. ciclo
Em loops importantes, elimine chamadas de método ao determinar o encerramento do loop.
Por exemplo: vai
for(int i=0; i<collection.size();i++){ ... }
Substitua por…
for(int i=0; n=coleção.size();i<n;i++){...}
Normalmente, mova itens que não estão relacionados ao índice do loop para fora do loop.
for(int i=0; terminal=x.length;i<terminal;i++){x[i] = x[i]/escalaA *escalaB;}
Deveria ser:
Escala dupla = escalaB*escalaA;for(int i=0; terminal=x.length;i<terminal;i++){x[i] = x[i]/escala;}
2. corda
Elimine a concatenação de strings
Ao criar strings longas, sempre use StringBuffter em vez de String
Pré-alocar espaço StringBuffer StringBuffer sb = new StringBuffer(5000);
3. Tipos de dados básicos
Use tipos de dados básicos em loops importantes (dados int geralmente são mais rápidos que dados longos/duplos)
Classes de agrupamento de tipos de dados básicos (Booleano, Inteiro, etc.) são usadas principalmente quando o parâmetro do método passado deve ser uma referência a um objeto (em vez de um tipo de dados básico)
Use o modificador static final em todas as expressões algébricas constantes para facilitar a referência das constantes (o compilador pré-calcula as expressões constantes)
4. anormal
As exceções são usadas apenas para uma única condição de erro verdadeira, de modo que lançar uma exceção e executar um bloco catch seja caro (principalmente devido à obtenção de um instantâneo da pilha de threads ao criar uma exceção)
Uma exceção é lançada somente quando a condição é verdadeiramente excepcional. Para lançar uma exceção, primeiro você cria um novo objeto.
O construtor da interface Throwable chama o método nativo denominado fillInStackTrace(). O método fillInStackTrace() verifica a pilha e coleta informações de rastreamento de chamadas.
Sempre que uma exceção é lançada, a VM precisa ajustar a pilha de chamadas porque um novo objeto é criado durante o processamento.
As exceções devem ser usadas apenas para tratamento de erros e não devem ser usadas para controlar o fluxo do programa.
Faça otimizações do compilador e do tempo de execução colocando várias chamadas de método em um bloco try/catch em vez de implementar vários blocos try/catch para cada chamada de método
try{ Some.method1(); //Difícil para java1.4 }catch(method1Exception e){ manipular exceção
1 // para otimizar este código } try{ Some.method2(); //Difícil para java1.4 }catch(method2Exception e){ lidar com exceção
2 // para otimizar este código } try{ Some.method3(); //Difícil para java1.4 }catch(method3Exception e){ lidar com exceção
3 // para otimizar este código
}
deve ser escrito como:
try{ Some.method1(); Some.method2(); //Difícil para java1.4 }catch(method1Exception e){ lidar com a exceção 1 }catch(method2Exception e){ lidar com a exceção 2 }catch( method3Exception e){lidar com exceção 3}
5. referência
Observe que todas essas dicas variam entre plataformas e máquinas virtuais
Por exemplo: em alguns contêineres de servlet, é mais rápido gerar bytes por meio de um OutputStream
2. Em outros contêineres, será mais rápido gerar caracteres por meio de um PrintWriter
Estas dicas descrevem as recomendações mais portáteis
Pode ser necessário executar alguns benchmarks para determinar o que é mais rápido em sua plataforma
6. Crie uma instância de uma classe sem usar a palavra-chave new
Quando você cria uma instância de uma classe usando a palavra-chave new, todos os construtores na cadeia de construtores são chamados automaticamente.
Mas se um objeto implementa a interface Cloneable, podemos chamar seu método clone(). O método clone() não chama nenhum construtor de classe.
Ao usar o Design Pattern, se você usar o modo Factory para criar um objeto, é muito simples usar o método clone() para criar uma nova instância do objeto.
Por exemplo, o seguinte é uma implementação típica do padrão Factory:
public static Crédito getNewCredit() { return new Crédito() };
Após a otimização:
private static Crédito BaseCredit = new Credit(); public static Crédito getNewCredit() { return (Crédito) BaseCredit.clone();}
As ideias acima também são úteis para processamento de array.
7. Use E/S sem bloqueio
JDKs com versões Java inferiores não suportam APIs de E/S sem bloqueio. Para evitar o bloqueio de E/S, alguns aplicativos criam um grande número de threads (em melhores casos, um buffer pool é usado). Esta técnica pode ser vista em muitas aplicações que devem suportar fluxos de E/S simultâneos, como servidores Web, aplicações de cotação e leilão, etc. No entanto, a criação de threads Java requer uma sobrecarga considerável.
O JDK 1.4 introduziu uma biblioteca de E/S sem bloqueio (java.nio). Se o seu aplicativo exigir uma versão mais antiga do JDK, existe um pacote que oferece suporte a E/S sem bloqueio.
8. Não inicialize variáveis repetidamente
Por padrão, ao chamar o construtor de uma classe, Java inicializará variáveis com determinados valores: todos os objetos são definidos como nulos, variáveis inteiras (byte, short, int, long) são definidas como 0 e variáveis float e double são definidas como 0,0, o valor lógico é definido como falso.
Isso deve ser observado especialmente quando uma classe é derivada de outra classe, porque quando um objeto é criado usando a palavra-chave new, todos os construtores na cadeia de construtores serão chamados automaticamente.
9. Tente especificar o modificador final da classe
As classes com o modificador final não são derivadas. Na API principal do Java, há muitos exemplos de aplicação final, como java.lang.String. Especificar final para a classe String evita que as pessoas substituam o método length().
Além disso, se uma classe for designada como final, todos os métodos da classe serão finais. O compilador Java procurará oportunidades para incorporar todos os métodos finais (isso depende da implementação específica do compilador). Isso pode melhorar o desempenho em uma média de 50%.
10. Use variáveis locais sempre que possível
Os parâmetros passados na chamada do método e as variáveis temporárias criadas durante a chamada são salvas na pilha (Stack), que é mais rápida. Outras variáveis, como variáveis estáticas, variáveis de instância, etc., são criadas no Heap e são mais lentas. Além disso, dependendo do compilador/JVM específico, as variáveis locais podem ser otimizadas ainda mais. Consulte Usar variáveis de pilha sempre que possível.
11. Multiplicação e divisão
Considere o seguinte código:
for (val = 0; val < 100000; val +=5) { alterX = val * 8;
Após a otimização:
for (val = 0; val < 100000; val += 5) { alterX = val << 3;
O código modificado não executa mais a operação de multiplicação por 8, mas usa a operação equivalente de deslocamento de 3 bits para a esquerda. Cada deslocamento de 1 bit para a esquerda equivale a multiplicação por 2. Da mesma forma, uma operação de deslocamento para a direita de 1 bit é equivalente a dividir por 2. Vale ressaltar que embora a operação de shift seja rápida, ela pode dificultar a compreensão do código, por isso é melhor adicionar alguns comentários.
private static Crédito BaseCredit = new Credit(); public static Credit getNewCredit() {return (Crédito) BaseCredit.clone();}