Os exemplos neste artigo resumem técnicas de otimização de desempenho Java. Compartilhe com todos para sua referência. A análise específica é a seguinte:
Aqui nos referimos a alguns livros e recursos de rede que são adequados para a maioria das aplicações Java.
Nos programas JAVA, a maioria das causas dos problemas de desempenho não está na linguagem JAVA, mas no próprio programa. Desenvolver bons hábitos de codificação é muito importante e pode melhorar significativamente o desempenho do programa.
1. Tente usar o modificador final.
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 os usuários substituam o método length(). Além disso, se uma classe for 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%.
2. Tente reutilizar objetos.
Especialmente ao usar objetos String, StringBuffer deve ser usado quando ocorre a concatenação de strings. Como o sistema não só precisa gastar tempo gerando objetos, ele também pode precisar gastar tempo coletando lixo e processando esses objetos no futuro. Portanto, gerar muitos objetos terá um grande impacto no desempenho do programa.
3. Tente usar variáveis locais.
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.
4. 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 serão definidos como nulos, variáveis inteiras serão definidas como 0, variáveis flutuantes e duplas serão definidas como 0,0 e valores lógicos serão definidos 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.
Há uma observação aqui: ao definir o valor inicial para uma variável de membro, mas precisar chamar outros métodos, é melhor colocá-lo em um método como initXXX(), porque chamar diretamente um método para atribuir um valor pode gerar um valor nulo. exceção de ponteiro porque a classe não foi inicializada public int state = this.getState();
5. No desenvolvimento de sistemas aplicativos Java + Oracle, a linguagem SQL incorporada em Java deve estar em letras maiúsculas tanto quanto possível para reduzir a carga de análise do analisador Oracle.
6. Durante o processo de programação Java, execute conexões de banco de dados e operações de fluxo de E/S. Após o uso, feche-os a tempo de liberar recursos. Porque as operações nesses objetos grandes causarão muita sobrecarga no sistema.
7. A criação excessiva de objetos consumirá uma grande quantidade de memória do sistema e, em casos graves, poderá causar vazamentos de memória. Portanto, é de grande importância garantir a reciclagem oportuna de objetos expirados.
O GC da JVM não é muito inteligente, por isso é recomendado defini-lo manualmente como nulo após o uso do objeto.
8. Ao usar o mecanismo de sincronização, tente usar a sincronização de métodos em vez da sincronização de blocos de código.
9. Minimize a contagem dupla de variáveis.
por exemplo
for(int i=0;i<lista.tamanho();i++)
deverá ser modificado para
for(int i=0,len=list.size();i<len;i++)
10. Adote uma estratégia de criar apenas quando precisar.
Por exemplo:
String str="abc";if(i==1){ list.add(str);} Deve ser modificado para:
if(i==1){Stringstr="abc";11. Use exceções com cautela, pois as exceções são prejudiciais ao desempenho.
Lançar uma exceção primeiro cria um novo objeto. O construtor da interface Throwable chama um método local chamado 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 deve 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.
12. Não use instruções Try/Catch em loops. Try/Catch deve ser colocado no nível mais externo do loop.
Error é uma classe para obter erros de sistema ou erros de máquina virtual. Nem todas as exceções de erro podem ser obtidas. Se a máquina virtual relatar uma exceção de erro, ela não poderá ser obtida.
13. Definir a capacidade inicial do StringBuffer por meio de seu construtor pode melhorar significativamente o desempenho.
A capacidade padrão do StringBuffer é 16. Quando a capacidade do StringBuffer atingir a capacidade máxima, ele aumentará sua capacidade para 2 vezes + 2 da capacidade atual, que é 2*n+2. Sempre que StringBuffer atinge sua capacidade máxima, ela precisa criar um novo array de objetos e depois copiar o array antigo de objetos, o que desperdiça muito tempo. Portanto, é necessário definir um valor de capacidade inicial razoável para StringBuffer!
14. Use java.util.Vector razoavelmente.
Vector é semelhante a StringBuffer Cada vez que a capacidade é expandida, todos os elementos existentes devem ser atribuídos ao novo espaço de armazenamento. A capacidade de armazenamento padrão do Vector é de 10 elementos e a capacidade é duplicada.
vector.add(index,obj) Este método pode inserir o elemento obj na posição do índice, mas o índice e os elementos subsequentes devem ser movidos para baixo em uma posição (aumentar seu índice em 1). Ruim para o desempenho, a menos que seja necessário.
As mesmas regras se aplicam ao método remove(int index), que remove o elemento na posição especificada neste vetor. Desloque todos os elementos subsequentes para a esquerda (diminua seu índice em 1). Retorna os elementos removidos deste vetor. Portanto, excluir o último elemento do vetor é muito mais barato do que excluir o primeiro elemento. É melhor usar o método removeAllElements() para remover todos os elementos.
Se você deseja excluir um elemento do vetor, você pode usar vector.remove(obj); você não precisa recuperar a posição do elemento e excluí-lo, como int index = indexOf(obj); índice);
15. Ao copiar grandes quantidades de dados, use System.arraycopy();
16. Refatoração de código para aumentar a legibilidade do código.
17. Crie uma instância de um objeto 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.
A seguir está uma implementação típica do padrão Factory.
public static Credit getNewCredit(){ return new Credit();} O código aprimorado usa o método clone(), private static Credit BaseCredit = new public static Credit getNewCredit(){ return (Credit)BaseCredit.clone(); ;}18. Se o deslocamento puder ser usado para multiplicação e divisão, o deslocamento deve ser usado tanto quanto possível, mas é melhor adicionar comentários, porque a operação de deslocamento não é intuitiva e difícil de entender.
19. Não declare o array como: public static final.
20.Travessia do HaspMap.
Map<String, String[]> paraMap = new HashMap<String, String[]>();for( Entry<String, String[]> entrada: paraMap.entrySet() ){ String appFieldDefId = entry.getKey(); String[] valores=entrada.getValue();}Use o valor hash para recuperar a entrada correspondente para comparação e obter o resultado. Após obter o valor da entrada, obtenha diretamente a chave e o valor.
21. O uso de array (array) e ArrayList.
Array array é o mais eficiente, mas sua capacidade é fixa e não pode ser alterada dinamicamente. A capacidade de ArrayList pode ser aumentada dinamicamente, mas a eficiência é sacrificada.
22. Threads únicos devem tentar usar HashMap e ArrayList A menos que seja necessário, não é recomendado usar HashTable e Vector. Eles usam um mecanismo de sincronização e reduzem o desempenho.
23. A diferença entre StringBuffer e StringBuilder é: java.lang.StringBuffer é uma sequência de caracteres variável segura para thread. Um buffer de string semelhante a String, mas não pode ser modificado. StringBuilder A classe StringBuilder geralmente deve ser usada em preferência a esta classe porque suporta todas as mesmas operações, mas é mais rápida porque não executa sincronização. Para obter melhor desempenho, você deve tentar especificar a capacidade dela ao construir StringBuffer ou StringBuilder. Claro, não é necessário se não exceder 16 caracteres.
Nas mesmas circunstâncias, o uso do StringBuilder só pode alcançar uma melhoria de desempenho de 10% a 15% em relação ao uso do StringBuffer, mas correrá o risco de insegurança multi-threading. Após consideração abrangente, é recomendado usar StringBuffer.
24. Tente usar tipos de dados básicos em vez de objetos.
25. Use cálculos numéricos simples em vez de cálculos de funções complexas , como consultar tabelas para resolver problemas de funções trigonométricas.
26. Usar analogias concretas é mais eficiente do que usar interfaces, mas a flexibilidade estrutural é reduzida, mas IDEs modernos podem resolver esse problema.
27. Considere o uso de métodos estáticos
Se você não precisa acessar a parte externa do objeto, torne seu método estático. Ele será chamado mais rápido porque não requer uma tabela de guia de função virtual. Essa colega também é uma boa prática, pois ela ensina como distinguir a natureza do método, chamar esse método não alterará o estado do objeto.
28. A utilização de métodos GET e SET intrínsecos deve ser evitada tanto quanto possível.
Na programação Android, chamar métodos virtuais incorrerá em muitos custos, que são mais caros do que a consulta de atributos de instância. Devemos usar os métodos get e set apenas ao terceirizar chamadas, mas ao chamar internamente, devemos chamá-los diretamente.
29. Evite o uso de enumerações e números de ponto flutuante.
30. Uma matriz bidimensional ocupa mais espaço de memória do que uma matriz unidimensional, cerca de 10 vezes o cálculo.
31. O banco de dados SQLite lê todos os dados da tabela inteira muito rapidamente, mas as consultas condicionais levam de 30 a 50 MS. Ao fazer isso, todos devem prestar atenção para usá-lo o mínimo possível, especialmente pesquisas aninhadas!
Espero que este artigo seja útil para a programação Java de todos.