Expressions idiomatiques du langage Java
1. faire du vélo
Dans les boucles importantes, éliminez les appels de méthode lors de la détermination de la fin de la boucle.
Par exemple : sera-t-il
pour(int i=0; i<collection.size();i++){ ... }
Remplacer par…
for(int i=0; n=collection.size();i<n;i++){...}
Habituellement, déplacez les éléments qui ne sont pas liés à l'index de la boucle en dehors de la boucle.
pour(int i=0; terminal=x.length;i<terminal;i++){x[i] = x[i]/scaleA *scaleB;}
Il devrait s'agir de :
Double échelle = scaleB*scaleA;for(int i=0; terminal=x.length;i<terminal;i++){x[i] = x[i]/scale;}
2. chaîne
Éliminer la concaténation de chaînes
Lors de la création de longues chaînes, utilisez toujours StringBuffter au lieu de String
Pré-allouer l'espace StringBuffer StringBuffer sb = new StringBuffer(5000);
3. Types de données de base
Utilisez des types de données de base dans les boucles importantes (les données int sont généralement plus rapides que les données longues/doubles)
Les classes d'emballage de types de données de base (Booléen, Integer, etc.) sont principalement utilisées lorsque le paramètre de méthode passé doit être une référence à un objet (plutôt qu'un type de données de base)
Utilisez le modificateur final statique sur toutes les expressions algébriques constantes pour rendre les constantes plus faciles à référencer (le compilateur précalcule les expressions constantes)
4. anormal
Les exceptions ne sont utilisées que pour une seule vraie condition d'erreur, de sorte que lancer une exception et exécuter un bloc catch coûte cher (principalement en raison de l'obtention d'un instantané de la pile de threads lors de la création d'une exception)
Une exception est levée uniquement lorsque la condition est vraiment exceptionnelle. Pour lever une exception, vous créez d'abord un nouvel objet.
Le constructeur de l'interface Throwable appelle la méthode native nommée fillInStackTrace(). La méthode fillInStackTrace() vérifie la pile et collecte les informations de suivi des appels.
Chaque fois qu'une exception est levée, la VM doit ajuster la pile d'appels car un nouvel objet est créé pendant le traitement.
Les exceptions ne doivent être utilisées que pour la gestion des erreurs et ne doivent pas être utilisées pour contrôler le déroulement du programme.
Effectuez des optimisations du compilateur et de l'exécution en plaçant plusieurs appels de méthode dans un bloc try/catch au lieu d'implémenter plusieurs blocs try/catch pour chaque appel de méthode.
try{ Some.method1(); //Difficut pour java1.4 }catch(method1Exception e){ gérer l'exception
1 // pour optimiser ce code } try{ Some.method2(); //Difficut pour java1.4 }catch(method2Exception e){ gérer l'exception
2 // pour optimiser ce code } try{ Some.method3(); //Difficut pour java1.4 }catch(method3Exception e){ gérer l'exception
3 // pour optimiser ce code
}
doit être écrit comme suit :
try{ Some.method1(); Some.method2(); Some.method3(); //Difficut pour java1.4 }catch(method1Exception e){ gérer l'exception 1 }catch(method2Exception e){ gérer l'exception 2 }catch( method3Exception e){ gérer l'exception 3 }
5. référence
Notez que tous ces conseils varient selon les plates-formes et les machines virtuelles
Par exemple : dans certains conteneurs de servlets, il est plus rapide de générer des octets via un OutputStream.
2. Dans d'autres conteneurs, il sera plus rapide de sortir les caractères via un PrintWriter
Ces conseils décrivent les recommandations les plus portables
Vous devrez peut-être effectuer des tests de performance pour déterminer ce qui est le plus rapide sur votre plate-forme.
6. Créer une instance d'une classe sans utiliser le nouveau mot-clé
Lorsque vous créez une instance d'une classe à l'aide du mot-clé new, tous les constructeurs de la chaîne de constructeurs sont automatiquement appelés.
Mais si un objet implémente l’interface Cloneable, nous pouvons appeler sa méthode clone(). La méthode clone() n’appelle aucun constructeur de classe.
Lorsque vous utilisez Design Pattern, si vous utilisez le mode Factory pour créer un objet, il est très simple d'utiliser la méthode clone() pour créer une nouvelle instance d'objet.
Par exemple, ce qui suit est une implémentation typique du modèle Factory :
crédit statique public getNewCredit() { return new Credit( });
Après optimisation :
crédit statique privé BaseCredit = new Credit(); crédit statique public getNewCredit() { return (Credit) BaseCredit.clone();}
Les idées ci-dessus sont également utiles pour le traitement des tableaux.
7. Utiliser des E/S non bloquantes
Les JDK dotés de versions Java inférieures ne prennent pas en charge les API d'E/S non bloquantes. Pour éviter le blocage des E/S, certaines applications créent un grand nombre de threads (dans le meilleur des cas, un pool de mémoire tampon est utilisé). Cette technique est visible dans de nombreuses applications qui doivent prendre en charge des flux d'E/S simultanés, telles que les serveurs Web, les applications de cotation et d'enchères, etc. Cependant, la création de threads Java nécessite une surcharge considérable.
JDK 1.4 a introduit une bibliothèque d'E/S non bloquante (java.nio). Si votre application nécessite une ancienne version du JDK, il existe un package qui prend en charge les E/S non bloquantes.
8. Ne pas initialiser les variables à plusieurs reprises
Par défaut, lors de l'appel du constructeur d'une classe, Java initialisera les variables à certaines valeurs : tous les objets sont définis sur null, les variables entières (byte, short, int, long) sont définies sur 0 et les variables float et double sont définies sur 0.0, la valeur logique est définie sur false.
Cela doit être particulièrement noté lorsqu'une classe est dérivée d'une autre classe, car lorsqu'un objet est créé à l'aide du mot-clé new, tous les constructeurs de la chaîne de constructeurs seront automatiquement appelés.
9. Essayez de spécifier le modificateur final de la classe
Les classes avec le modificateur final ne sont pas dérivées. Dans l'API principale Java, il existe de nombreux exemples d'application de final, tels que java.lang.String. La spécification de final pour la classe String empêche les utilisateurs de remplacer la méthode length().
De plus, si une classe est désignée comme finale, toutes les méthodes de la classe seront définitives. Le compilateur Java recherchera des opportunités pour intégrer toutes les méthodes finales (cela dépend de l'implémentation spécifique du compilateur). Cela peut améliorer les performances de 50 % en moyenne.
10. Utilisez des variables locales autant que possible
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és dans la pile (Stack), ce qui est plus rapide. D'autres variables, telles que les variables statiques, les variables d'instance, etc., sont créées dans le tas et sont plus lentes. De plus, en fonction du compilateur/JVM spécifique, les variables locales peuvent être optimisées davantage. Voir Utiliser les variables de pile autant que possible.
11. Multiplication et division
Considérez le code suivant :
pour (val = 0 ; val < 100 000 ; val +=5) { alterX = val * 8 ; monRésultat = val * 2 ;
Après optimisation :
pour (val = 0 ; val < 100000 ; val += 5) { alterX = val << 3 ; monRésultat = val << 1 ;
Le code modifié n'effectue plus l'opération de multiplication par 8, mais utilise plutôt l'opération équivalente de décalage de 3 bits vers la gauche. Chaque décalage vers la gauche de 1 bit équivaut à une multiplication par 2. De manière correspondante, une opération de décalage vers la droite de 1 bit équivaut à diviser par 2. Il convient de mentionner que même si l'opération de décalage est rapide, elle peut rendre le code plus difficile à comprendre, il est donc préférable d'ajouter quelques commentaires.
Crédit statique privé BaseCredit = new Credit(); Crédit statique public getNewCredit() {return (Credit) BaseCredit.clone();}