Partagez 35 méthodes d'optimisation des performances du code Java

Avant-propos

L'optimisation du code est un sujet très important. Certaines personnes peuvent penser que cela ne sert à rien. Quelles sont les petites choses qui peuvent être modifiées ? Quel impact la modification aura-t-elle ou non sur l'efficacité du fonctionnement du code ? Je réfléchis à cette question comme celle-ci, tout comme une baleine dans la mer, est-ce utile qu'elle mange une petite crevette ? C'était inutile, mais après avoir mangé plus de crevettes, la baleine était rassasiée. Il en va de même pour l'optimisation du code. Si le projet se concentre sur un lancement sans bugs le plus tôt possible, vous pouvez alors vous concentrer sur le gros et abandonner le petit à ce moment-là, et les détails du code n'ont pas besoin d'être affinés. ; mais s'il y a suffisamment de temps pour développer et maintenir le code, vous devez considérer tous les aspects à ce moment-là. Certains détails peuvent être optimisés. L'accumulation de petits points d'optimisation un par un améliorera certainement l'efficacité de l'exécution du code.

Les objectifs de l'optimisation du code sont :

1. Réduire la taille du code

2 Améliorer l'efficacité de l'exécution du code

Détails de l'optimisation du code.

1. Essayez de spécifier le modificateur final des classes et des méthodes

Les classes avec le modificateur final ne peuvent pas être dérivées. Dans l'API principale Java, il existe de nombreux exemples d'applications finales, telles que java.lang.String, où la classe entière est finale. La spécification du modificateur final pour une classe empêche l'héritage de la classe, et la spécification du modificateur final pour une méthode empêche la substitution de la méthode. Si une classe est désignée comme finale, toutes les méthodes de la classe sont définitives. Le compilateur Java recherchera des opportunités pour intégrer toutes les méthodes finales. L'intégration joue un rôle important dans l'amélioration de l'efficacité de l'exécution de Java. Pour plus de détails, voir Optimisation de l'exécution Java. Cela peut améliorer les performances de 50 % en moyenne.

2. Essayez de réutiliser les objets

Surtout lorsque vous utilisez des objets String, StringBuilder/StringBuffer doit être utilisé à la place lorsque des connexions de chaîne se produisent. Étant donné que la machine virtuelle Java ne passe pas seulement du temps à générer des objets, elle devra peut-être également consacrer du temps à la collecte et au traitement de ces objets à l'avenir. Par conséquent, générer trop d'objets aura un impact important sur les performances du programme.

3. Utilisez autant que possible les variables locales.

Les paramètres passés lors de l'appel de la méthode et les variables temporaires créées lors de l'appel sont enregistrées plus rapidement dans la pile. Les autres variables, telles que les variables statiques. et les instances, les variables, etc., sont toutes créées dans le tas, ce qui est plus lent. De plus, le contenu des variables créées sur la pile disparaît à la fin de la méthode et aucun garbage collection supplémentaire n'est requis.

4. Fermez le flux en temps opportun

Pendant le processus de programmation Java, soyez prudent lorsque vous effectuez des connexions à la base de données et des opérations de flux d'E/S. Après utilisation, fermez le flux à temps pour le libérer. ressources. Étant donné que l’exploitation de ces gros objets entraînera une surcharge système importante, un peu de négligence entraînera de graves conséquences.

5. Minimisez les calculs répétés de variables

Clarifier un concept, même s'il n'y a qu'une seule instruction dans la méthode, est coûteux, y compris lors de la création d'un cadre de pile et de l'appel d'un. méthode. Protéger la scène, restaurer la scène lorsque la méthode est appelée, etc. Ainsi par exemple, il est recommandé de remplacer l'opération suivante :

for (int i = 0; i ad1989fd6120015193325f6a5e9e5a88重写了Object的toString()方法。<h3>31、不要对超出范围的基本数据类型做向下强制转型</h3><p>这绝不会得到想要的结果：</p><pre class="brush:java;toolbar:false;">public static void main(String[] args){ 
    long l = 12345678901234L;
    int i = (int)l;
    System.out.println(i);
}

我们可能期望得到其中的某几位，但是结果却是：

1942892530

解释一下。Java中long是8个字节64位的，所以12345678901234在计算机中的表示应该是：

0000 0000 0000 0000 0000 1011 0011 1010 0111 0011 1100 1110 0010 1111 1111 0010

一个int型数据是4个字节32位的，从低位取出上面这串二进制数据的前32位是：

0111 0011 1100 1110 0010 1111 1111 0010

这串二进制表示为十进制1942892530，所以就是我们上面的控制台上输出的内容。从这个例子上还能顺便得到两个结论：

1、整型默认的数据类型是int，long l = 12345678901234L，这个数字已经超出了int的范围了，所以最后有一个L，表示这是一个long型数。顺便，浮点型的默认类型是double，所以定义float的时候要写成”"float f = 3.5f”

2、接下来再写一句”int ii = l + i;”会报错，因为long + int是一个long，不能赋值给int

32、公用的集合类中不使用的数据一定要及时remove掉

如果一个集合类是公用的（也就是说不是方法里面的属性），那么这个集合里面的元素是不会自动释放的，因为始终有引用指向它们。所以，如果公用集合里面的某些数据不使用而不去remove掉它们，那么将会造成这个公用集合不断增大，使得系统有内存泄露的隐患。

33、把一个基本数据类型转为字符串，基本数据类型.toString()是最快的方式、String.valueOf(数据)次之、数据+”"最慢

把一个基本数据类型转为一般有三种方式，我有一个Integer型数据i，可以使用i.toString()、String.valueOf(i)、i+”"三种方式，三种方式的效率如何，看一个测试：

public static void main(String[] args){ 
    int loopTime = 50000;
    Integer i = 0; 
    long startTime = System.currentTimeMillis(); 
    for (int j = 0; j < loopTime; j++){
        String str = String.valueOf(i);
    }

    System.out.println("String.valueOf()：" +
     (System.currentTimeMillis() - startTime) + "ms");
    startTime = System.currentTimeMillis(); 
     for (int j = 0; j < loopTime; j++){
        String str = i.toString();
    }

    System.out.println("Integer.toString()：" +
      (System.currentTimeMillis() - startTime) + "ms");
    startTime = System.currentTimeMillis(); 
      for (int j = 0; j < loopTime; j++){
    
    String str = i + "";
    
    }

    System.out.println("i + \"\"：" + 
      (System.currentTimeMillis() - startTime) + "ms");

}

运行结果为：

String.valueOf()：11ms Integer.toString()：5ms i + ""：25ms

所以以后遇到把一个基本数据类型转为String的时候，优先考虑使用toString()方法。至于为什么，很简单：

1、String.valueOf()方法底层调用了Integer.toString()方法，但是会在调用前做空判断

2、Integer.toString()方法就不说了，直接调用了

3、i + “”底层使用了StringBuilder实现，先用append方法拼接，再用toString()方法获取字符串

三者对比下来，明显是2最快、1次之、3最慢

34、使用最有效率的方式去遍历Map

遍历Map的方式有很多，通常场景下我们需要的是遍历Map中的Key和Value，那么推荐使用的、效率最高的方式是：

public static void main(String[] args){
HashMap<String, String> hm = new HashMap<String, String>();
hm.put("111", "222");
Set<Map.Entry<String, String>> entrySet = hm.entrySet();
Iterator<Map.Entry<String, String>> iter = entrySet.iterator();
while (iter.hasNext()){
    Map.Entry<String, String> entry = iter.next();
    System.out.println(entry.getKey() 
    + "\t" + entry.getValue());
}
}

如果你只是想遍历一下这个Map的key值，那用”Setf7e83be87db5cd2d9a8a0b8117b38cd4 keySet = hm.keySet();”会比较合适一些

35、对资源的close()建议分开操作

意思是，比如我有这么一段代码：

try{
    XXX.close();
    YYY.close();
}catch (Exception e){
...
}

建议修改为：

try{
     XXX.close();
}catch (Exception e) {
     ... 
}
try{
  YYY.close();
}catch (Exception e) {
    ...
}

虽然有些麻烦，却能避免资源泄露。我们想，如果没有修改过的代码，万一XXX.close()抛异常了，那么就进入了cath块中了，YYY.close()不会执行，YYY这块资源就不会回收了，一直占用

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!