Optimiser les programmes via les spécifications du code Java, optimiser l'utilisation de la mémoire et empêcher les fuites de mémoire
Les ressources disponibles pour les programmes à utiliser (mémoire, temps de processeur, bande passante du réseau, etc.) sont limitées. L'optimisation comprend généralement deux aspects: réduire la taille du code et améliorer l'efficacité du code du code. Cet article explique principalement sur la façon d'améliorer l'efficacité du code.
Dans les programmes Java, la plupart des raisons des problèmes de performance ne sont pas dans la langue Java, mais dans le programme lui-même. Il est très important de développer de bonnes habitudes d'écriture de code, telles que l'application correctement et intelligemment de la classe Java.lang.String et Java.util.vector, qui peut améliorer considérablement les performances du programme. Analysons ce problème en détail ci-dessous.
1. Essayez de spécifier que le modificateur final de la classe.
Dans l'API Java Core, il existe de nombreux exemples d'application finale, comme java.lang.string. La spécification de la classe Final pour la chaîne empêche les gens de remplacer la méthode Longueur (). De plus, si une classe est spécifiée en finale, toutes les méthodes de cette classe sont finales. Le compilateur Java recherchera des opportunités pour alimenter toutes les méthodes finales (ceci est lié à l'implémentation spécifique du compilateur). Cette décision peut améliorer les performances en moyenne de 50%.
2. Essayez de réutiliser l'objet.
Surtout lors de l'utilisation d'objets String, StringBuffer est utilisé à la place lorsque la concaténation de la chaîne se produit. Étant donné que le système prend non seulement du temps pour générer des objets, il peut également prendre du temps pour collecter les ordures et traiter ces objets à l'avenir. Par conséquent, la génération trop d'objets aura un grand impact sur les performances du programme.
3. Essayez d'utiliser des variables locales.
D'autres variables, telles que des variables statiques, des variables d'instance, etc., sont créées dans le tas et sont plus lentes. De plus, les variables locales peuvent être encore optimisées en fonction du compilateur / JVM spécifique. Voir "Utilisez des variables de pile lorsque cela est possible".
4. Ne répétez pas l'initialisation des variables <br /> par défaut, lors de l'appel du constructeur de classe, Java initialisera la variable à une certaine valeur: tous les objets sont définis sur null, entier variables (octet, court, int, long) set à 0, les variables flottantes et doubles sont définies sur 0,0 et les valeurs logiques sont définies sur False. Cela doit être particulièrement remarqué lorsqu'une classe est dérivée d'une autre, car lorsqu'un objet est créé avec le nouveau mot-clé, tous les constructeurs de la chaîne de constructeurs sont automatiquement appelés.
5. Dans le développement du système d'application Java + Oracle, essayez d'utiliser une forme majuscule en Java pour réduire la charge d'analyse de l'analyseur Oracle.
6. Pendant la programmation Java, soyez prudent lorsque vous effectuez des connexions de base de données et des opérations de streaming d'E / S.
Parce que le fonctionnement de ces grands objets provoquera des frais généraux du système et si vous ne faites pas attention, cela entraînera de graves conséquences.
7. Étant donné que le JVM a son propre mécanisme GC, il ne nécessite pas trop de considération des développeurs de programmes, ce qui réduit le fardeau des développeurs dans une certaine mesure, mais manque également des dangers cachés. Dans le système.
La condition pour JVM de recycler les ordures est que l'objet n'est pas référencé; Par conséquent, il est recommandé de le régler manuellement sur Null après l'utilisation de l'objet.
8. Lorsque vous utilisez le mécanisme de synchronisation, essayez d'utiliser la synchronisation de la méthode au lieu de la synchronisation du bloc de code.
9. Minimiser les calculs répétés des variables <br /> par exemple: pour (int i = 0; i <list.size; i ++) {
…
}
Devrait être remplacé par:
for (int i = 0, int len = list.size (); i <len; i ++) {
…
}
10. Essayez d'adopter la stratégie de chargement paresseuse, c'est-à-dire commencer à créer en cas de besoin.
Par exemple: String str = «aaa»;
if (i == 1) {
list.add (str);
}
Devrait être remplacé par:
if (i == 1) {
String str = «aaa»;
list.add (str);
}
11. Utiliser des anomalies avec prudence
L'anomalie n'est pas bonne pour la performance. Pour lancer une exception, vous devez d'abord créer un nouvel objet. Le constructeur de l'interface jetable appelle la méthode locale (native) nommée FillInstackTrace (), et la méthode FillinStackTrace () vérifie la pile et collecte les informations de trace d'appel. Tant qu'une exception est lancée, la machine virtuelle doit ajuster la pile d'appels car un nouvel objet est créé pendant le traitement. Les exceptions ne peuvent être utilisées que pour la gestion des erreurs et ne doivent pas être utilisées pour contrôler le flux du programme.
12. Ne l'utilisez pas dans une boucle:
Essayer {
} attraper() {
}
Il doit être placé sur la couche la plus externe.
13. Utilisation de StringBuffer:
StringBuffer représente une chaîne de variables, écrite.
Il existe trois méthodes de construction:
StringBuffer ();
StringBuffer (Taille int);
StringBuffer (String Str);
Le constructeur mentionné ici est StringBuffer (int longueur), et le paramètre de longueur indique le nombre de caractères que le stringbuffer actuel peut maintenir. Vous pouvez également utiliser la méthode Assurecapacité (INT Minimum Capacité) pour définir sa capacité après la création de l'objet StringBuffer. Tout d'abord, jetons un coup d'œil au comportement par défaut de StringBuffer, puis trouvons une meilleure façon d'améliorer les performances.
StringBuffer maintient un tableau de caractères en interne. Lorsque le StringBuffer atteint sa capacité maximale, il augmentera sa capacité à 2 fois la capacité actuelle et ajoutera 2, c'est-à-dire (2 * Valeur ancienne +2). Si vous utilisez la valeur par défaut, après l'initialisation, ajoutez-y des caractères. à 70 (2 * 34 + 2). Peu importe quoi, tant que le StringBuffer atteint sa capacité maximale, il doit créer un nouveau tableau de caractères, puis re-copier à la fois les anciens et les nouveaux caractères. Par conséquent, il n'est pas faux de toujours définir une valeur de capacité d'initialisation raisonnable pour StringBuffer, ce qui apportera un gain de performance immédiat. Cela montre le rôle de l'ajustement du processus d'initialisation de StringBuffer. Ainsi, l'utilisation d'une valeur de capacité appropriée pour initialiser un stringbuffer est toujours une suggestion optimale.
14. Utilisez la classe Java java.util.vector raisonnablement.
Autrement dit, un vecteur est un tableau d'instances java.lang.object. Le vecteur est similaire à un tableau, et ses éléments sont accessibles via un index sous la forme d'un entier. Cependant, après la création d'un objet de type vecteur, la taille de l'objet peut être élargie et réduite en fonction de l'addition ou de la suppression des éléments. Veuillez considérer l'exemple suivant de l'ajout d'éléments à Vector:
Objet bj = nouveau objet ();
Vecteur v = nouveau vecteur (100000);
pour (int i = 0;
I <100000; i ++) {v.add (0, obj);
À moins qu'il n'y ait absolument une raison suffisante pour exiger que de nouveaux éléments soient insérés devant le vecteur à chaque fois, le code ci-dessus est mauvais pour les performances. Dans le constructeur par défaut, la capacité de stockage initiale du vecteur est de 10 éléments. La classe vectorielle est comme la classe d'objet StringBuffer. L'extrait de code suivant est plus rapide des ordres de grandeur que l'exemple précédent:
Objet bj = nouveau objet ();
Vecteur v = nouveau vecteur (100000);
pour (int i = 0; i <100000; i ++) {v.add (obj);
La même règle s'applique à la méthode supprimée () de la classe vectorielle. Étant donné que chaque élément du vecteur ne peut pas contenir un "espace" entre chaque élément, la suppression d'un autre élément, sauf que le dernier élément provoque les éléments après l'avenir de l'élément supprimé. Autrement dit, la suppression du dernier élément d'un vecteur est plusieurs fois moins "surcharge" que la suppression du premier élément.
En supposant que nous voulons supprimer tous les éléments du vecteur précédent, nous pouvons utiliser ce code:
pour (int i = 0; i <100000; i ++)
{
V.Remove (0);
}
Cependant, par rapport au code suivant, le code précédent est des ordres de grandeur plus lents:
pour (int i = 0; i <100000; i ++)
{
V.Remove (V.Size () - 1);
}
La meilleure façon de supprimer tous les éléments d'un objet V de type vecteur est:
v.removeallelements ();
Supposons que l'objet V de type vecteur contient la chaîne "bonjour". Considérez le code suivant, qui supprime la chaîne "Hello" de ce vecteur:
String S = "Hello";
int i = v.indexof (s);
if (i! = -1) v.Remove (s);
Le code ne ressemble à rien de mal, mais il est également mauvais pour les performances. Dans ce code, la méthode indexof () recherche V en séquence pour trouver la chaîne "bonjour", et la méthode de supprimer doit également rechercher dans le même ordre. La version améliorée est:
String S = "Hello";
int i = v.indexof (s);
if (i! = -1) v.Remove (i);
Dans cette version, nous donnons directement la position index exacte de l'élément à supprimer dans la méthode supprime (), évitant ainsi la deuxième recherche. Une meilleure version est:
String S = "Hello"; V.Remove (S);
Enfin, regardons un extrait de code sur la classe vectorielle:
pour (int i = 0; i ++; i <v.length)
Si V contient 100 000 éléments, cet extrait de code appellera la méthode V.Size () 100 000 fois. Bien que la méthode de taille soit une méthode simple, elle nécessite toujours la surcharge d'un appel de méthode, au moins le JVM doit configurer et effacer l'environnement de pile pour cela. Ici, le code à l'intérieur de la boucle pour ne modifiera en aucune façon la taille de l'objet Vector Type V, donc le code ci-dessus est mieux réécrit dans le formulaire suivant:
int size = v.size ();
Bien qu'il s'agisse d'un changement simple, il gagne toujours des performances. Après tout, chaque cycle du processeur est précieux.
15. Lors de la copie d'une grande quantité de données, utilisez la commande System.ArrayCopy ().
16. Refactorisation du code: améliorez la lisibilité du code .
Par exemple:
classe publique ShopCart {chariots privés de liste;… public void add (objet item) {if (carts == null) {CARTS = new ArrayList ();} crts.add (item);} public void retire (objet item) {if (CARTS. CONTAINS (ITEM)) {CARS.Remove (item);}} public list getCarts () {// return lisly list return College.UnModifiBeblelist (CARTS);} // Cette méthode n'est pas recommandée // ceci . 17. Créez une instance d'une classe sans utiliser de nouveaux mots clés
Lors de la création d'une instance d'une classe avec le nouveau mot-clé, tous les constructeurs de la chaîne de constructeurs seront appelés automatiquement. Mais si un objet implémente l'interface clonable, nous pouvons appeler sa méthode clone (). La méthode clone () n'appelle aucun constructeur de classe.
Lorsque vous utilisez le modèle de conception, si vous utilisez le mode d'usine 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 d'usine:
Crédit statique public getNewCredit () {
retourner nouveau crédit ();
}
Le code amélioré utilise la méthode clone () comme suit:
Basecredit de crédit statique privé = nouveau crédit ();
Crédit statique public getNewCredit () {
retour (crédit) Basecredit.clone ();
}
L'idée ci-dessus est également très utile pour le traitement des tableaux.
18. Multiplication et division
Considérez le code suivant:
pour (val = 0; val <100000; val + = 5) {
alterx = val * 8; MyResult = Val * 2;
}
Le remplacement de la multiplication par des opérations de décalage peut améliorer considérablement les performances. Voici le code modifié:
pour (val = 0; val <100000; val + = 5) {
alterx = val << 3; MyResult = Val << 1;
}
Le code modifié ne se multiplie plus par 8, mais utilise plutôt le décalage gauche équivalent de 3 bits, avec 1 bit par décalage gauche équivalent à la multiplication par 2. En conséquence, l'opération de déménagement de droite par 1 bit est équivalente à la division par 2. Il convient de mentionner que bien que l'opération de décalage soit rapide, cela peut rendre le code difficile à comprendre, il est donc préférable d'ajouter des commentaires.
19. Fermer les sessions inutiles dans la page JSP.
Un malentendu commun est que la session est créée lorsqu'il y a un accès client. , utilisez <> pour le fermer. Étant donné que la session consomme des ressources de mémoire, si vous ne prévoyez pas d'utiliser la session, vous devez la fermer dans tous les JSP.
Pour les pages qui n'ont pas besoin de suivre l'état de la session, la fermeture de sessions créées automatiquement peut économiser certaines ressources. Utilisez la directive de page suivante: <% @ page session = "false"%>
20. JDBC et E / S
Si une application doit accéder à un ensemble de données à grande échelle, vous devez envisager d'utiliser l'extraction de blocs. Par défaut, JDBC extrait 32 lignes de données à chaque fois. Par exemple, supposons que nous souhaitions parcourir un ensemble d'enregistrements de 5000 lignes, JDBC doit appeler la base de données 157 fois avant de pouvoir extraire toutes les données. Si la taille du bloc est changée à 512, le nombre d'appels à la base de données sera réduit à 10 fois.
21. Utilisation des servlets et de la mémoire <BR /> De nombreux développeurs enregistrent une grande quantité d'informations aux sessions utilisateur à volonté. Parfois, les objets stockés dans la session ne sont pas recyclés par le mécanisme de collecte des ordures dans le temps. Du point de vue des performances, un symptôme typique est que l'utilisateur estime que le système ralentit périodiquement, mais ne peut attribuer la raison à un composant spécifique. Si vous surveillez l'espace de tas de JVM, il se manifeste comme des fluctuations anormales d'utilisation de la mémoire.
Il existe deux façons principales de résoudre ce type de problème de mémoire. La première méthode consiste à implémenter l'interface HTTPSessionBindingListener dans tous les beans avec une portée de session. De cette façon, tant que la méthode ValueUnbound () est mise en œuvre, les ressources utilisées par le bean peuvent être explicitement libérées.
Une autre façon consiste à invalider la session dès que possible. La plupart des serveurs d'applications ont la possibilité de définir l'intervalle d'invalidation de la session. De plus, la méthode SetMaxInactiveInterval () de la session peut également être appelée programmaticalement.
22. Utilisez des marques de tampon
Certains serveurs d'applications ont ajouté une fonction de marquage de tampon pour JSP. Par exemple, le serveur WebLogic de Bea prend en charge cette fonctionnalité depuis la version 6.0, et le projet Open Symphony prend également en charge cette fonctionnalité. Les balises de mise en mémoire tampon JSP peuvent tamponner les deux fragments de page et toute la page. Lorsque la page JSP est exécutée, si le fragment cible est déjà dans le tampon, le code qui génère le fragment n'aura plus besoin d'être exécuté. La mise en mémoire tampon du niveau de la page capture les demandes de l'URL spécifiées et tamponne toute la page de résultat. Cette fonctionnalité est extrêmement utile pour les paniers d'achat, les catalogues et les pages d'accueil du portail. Pour de telles applications, la mise en mémoire tampon du niveau de la page peut enregistrer les résultats de l'exécution de la page pour les demandes suivantes.
23. Choisissez le bon mécanisme de citation
Dans un système d'application JSP typique, les pièces d'en-tête et de pied de page sont souvent extraites, puis l'en-tête et le pied de page sont introduits au besoin. Actuellement, il existe deux méthodes principales pour introduire des ressources externes dans les pages JSP: inclure des directives et inclure des actions.
Inclure la directive: par exemple <% @ inclue file = "Copyright.html"%>. Cette directive introduit la ressource spécifiée au moment de la compilation. Avant la compilation, la page avec la directive inclue et la ressource spécifiée sont fusionnées dans un fichier. Les ressources externes référencées sont déterminées au moment de la compilation, ce qui est plus efficace que de déterminer les ressources au moment de l'exécution.
Inclure l'action: par exemple <jsp: inclure page = "copyright.jsp" />. Cette action introduit le résultat généré après l'exécution de la page spécifiée. Depuis qu'il se termine au moment de l'exécution, le contrôle des résultats de sortie est plus flexible. Cependant, il est seulement rentable d'utiliser une action inclue lorsque le contenu cité est fréquemment modifié, ou lorsque la page référencée ne peut pas être déterminée avant que la demande de page principale n'apparaisse.
24. Effacer les séances qui ne avaient plus besoin à temps
Afin d'effacer les sessions qui ne sont plus actives, de nombreux serveurs d'applications ont un délai d'expiration de session par défaut, généralement 30 minutes. Lorsque le serveur d'applications doit enregistrer plus de sessions, si la capacité de mémoire est insuffisante, le système d'exploitation transférera une partie des données de mémoire vers le disque. Stocker à disque et peut même lancer une exception "hors de mémoire". Dans les systèmes à grande échelle, les séances de sérialisation sont coûteuses. Lorsque la session n'est plus nécessaire, la méthode httpSession.invalidate () doit être appelée à temps pour effacer la session. La méthode httpSession.invalidate () peut généralement être appelée sur la page de sortie de l'application.
25. Ne déclarez pas le tableau comme: finale statique publique.
26. Discussion sur l'efficacité de traversée de Hashmap
Il existe souvent des opérations de traversée sur les paires de clés et de valeur dans HashMap, et il existe deux méthodes: map <string, string []> paramap = new
Hashmap <string, string []> (); ............ // la première boucle set <string> appfieldDefids = paramap.KeySet (); ] valeurs = paramap.get (AppFieldDefid); ......} // la deuxième boucle pour (entrée <String, String []> Entrée: paramap.entryset ()) {String AppFieldDefid = entry.getKey ( ); String [] valeurs = entry.getValue (); .......} La première implémentation est nettement moins efficace que la deuxième implémentation.
L'analyse est la suivante
Le code est le suivant:
public set <K> keySet () {set <K> ks = keyset; return (ks! = null? ks: (keyset = new KeySet ()));} la classe privée keyset étend AbstractSet <K> {public iterator <k > iterator () {return NewKeyIterator ();} public int size () {return size;} public boolean contient (objet o) {return contientKey (o);} public boolean remoe (objet o) {return hashmap.this.reMoveentRyforkey (o)! = null;} public void clear () {hashmap.this.clear ();}}En fait, il renvoie un ensemble de clés de classe privée, qui est hérité de AbstractSet et implémente l'interface définie.
Jetons un coup d'œil à la syntaxe de pour / en boucles
pour (Déclaration: expression)
déclaration
Pendant la phase d'exécution, il est traduit dans les formules suivantes
for (iterator <e> #i = (expression) .iterator (); # i.hashnext ();) {
déclaration = # i.next ();
déclaration
}
Par conséquent, Hashmap.KeySet (). Iterator () est appelé dans la première instruction pour (String AppFieldDefid: AppFieldDefids)
Cette méthode appelle NewKeyiterator ()
Iterator <K> NewKeyIterator () {
renvoyer un nouveau keyiterator ();
}
Classe privée Keyiterator étend Hashitator <K> {
public k next () {
return nextEntry (). getKey ();
}
}
Donc, dans le pour, l'itérateur utilisé dans la deuxième boucle pour (entrée <chaîne, chaîne []> entrée: paramap.entryset ()) est appelé comme suit.
gentil
Classe privée Entryiterator étend Hashitator <map.entry <k, v >> {
Map public.entry <k, v> suivant () {
return nextEntry ();
}
}
À l'heure actuelle, la première boucle obtient la clé, et la deuxième boucle obtient l'efficacité d'entrée de Hashmap est que la deuxième boucle reflétée dans la boucle. Utilisez HashMap's Get (Key) pour obtenir une valeur de valeur maintenant, regardez la méthode GET (objet) de HashMap
public v get (clé d'objet) {
Objet k = maskNull (clé);
int hash = hash (k);
int i = indexfor (hash, table.length);
Entrée <k, v> e = table;
while (true) {
if (e == null)
retourner null;
if (e.hash == hash && eq (k, e.key)))
retour e.value;
e = e.next;
}
}
En fait, il s'agit d'utiliser la valeur de hachage pour obtenir à nouveau l'entrée correspondante pour comparer et obtenir le résultat.
Dans la deuxième boucle obtient la valeur d'entrée, puis prenez directement la clé et la valeur, ce qui est plus efficace que la première boucle. En fait, selon le concept de MAP, il devrait être préférable d'utiliser la deuxième boucle.
27. Utilisation du tableau (tableau) et Arrylist
Array ([]): le plus efficace; mais sa capacité est fixe et ne peut pas être modifiée dynamiquement;
ArrayList: La capacité peut croître dynamiquement; mais l'efficacité du sacrifice;
En fonction de l'efficacité et de la vérification du type, le tableau doit être utilisé autant que possible.
ArrayList est une version complexe de Array
ArrayList résume un tableau de type objet. Méthode du tableau.
Lorsque ArrayList stocke un objet, les informations de type sont jetées et tous les objets sont bloqués comme objet.
Remarque: JDK5 a ajouté une prise en charge des génériques, et la vérification des types peut être effectuée lors de l'utilisation d'ArrayList.
De ce point de vue, la différence entre ArrayList et Array est principalement due à l'efficacité de l'augmentation de la capacité dynamique.
28. Essayez d'utiliser HashMap et ArrayList .
29. La différence entre StringBuffer et StringBuilder:
Java.lang.StringBuffer séquence de caractères mutable en filetage. Un tampon de chaîne de type chaîne, mais ne peut pas être modifié.
StringBuilder. Par rapport à cette classe, la classe java.lang.stringBuilder doit généralement être préférée car elle prend en charge toutes les mêmes opérations, mais est plus rapide car elle n'effectue pas de synchronisation. Pour de meilleures performances, la capacité de Stirngbuffer ou StirngBuilder doit être spécifiée autant que possible. Bien sûr, si la chaîne que vous utilisez ne dépasse pas 16 caractères, vous n'en aurez pas besoin. Dans le même cas, l'utilisation de StirngBuilder ne peut atteindre qu'environ 10% à 15% d'amélioration des performances par rapport à l'utilisation de StringBuffer, mais il prend le risque d'insécurité multi-thread. Dans une véritable programmation modulaire, le programmeur responsable d'un certain module peut ne pas être en mesure de déterminer clairement si le module sera placé dans un environnement multi-thread, donc: à moins que vous ne puissiez déterminer que le goulot d'étranglement de votre système est sur le STRINGBUFFER, et Assurez-vous que votre module ne s'exécutera pas en mode multithread, sinon utilisez StringBuffer.
Autres suppléments:
1. Effacer des objets qui ne sont plus utilisés dans le temps et définis sur NULL
2. Utilisez autant que possible les mots clés finaux, statiques et autres
3. Utilisez autant que possible les objets tamponnés
Comment optimiser le code pour rendre le fichier source Java et compilé le fichier de classe plus petit
1 Essayez d'utiliser l'héritage.
2 Ouvrez les options d'optimisation du compilateur Java: Javac -O Cette option supprimera le numéro de ligne dans le fichier de classe et déclarera certaines méthodes privées, statiques et finales du segment comme appels de méthode en ligne
3 Extraire le code commun
4 N'initialisez pas les grandes tableaux. Stocké dans un tableau, vous pouvez d'abord mettre ces données dans une chaîne, puis analyser la chaîne dans un tableau pendant l'exécution
5. Les objets de type date prendront beaucoup d'espace.
type long, puis convertir en type à ce jour lorsqu'il est utilisé
6. Essayez d'utiliser des noms courts pour les noms de classe, les noms de méthodes et les noms de variables.
7 Définissez les variables du type final statique dans l'interface
8 Si les opérations arithmétiques peuvent être utilisées pour le mouvement gauche / droit, n'utilisez pas * et / opérations. N'utilisez pas les mêmes opérations plusieurs fois.
2. N'initialisez pas les variables deux fois
Java initialise la variable à une valeur connue par défaut en appelant un constructeur de classe unique. Tous les objets sont définis sur NULL, les entiers (octets, courts, int, longs) sont définis sur 0, Float et Double sont définis sur 0,0 et les variables booléennes sont définies sur False. Ceci est particulièrement important pour les classes qui s'étendent d'autres classes, comme toutes les séries de constructeurs sont automatiquement appelées lors de la création d'un objet utilisant un nouveau mot-clé.
3. Faites la finale de la classe dans la mesure du possible
Les classes marquées finales ne peuvent pas être étendues. Il existe de nombreux exemples de cette technologie dans l'API Java de base, tels que java.lang.string. Le marquage de la classe String en tant que finale empêche les développeurs de créer des méthodes de longueur qu'ils se mettent en œuvre.
Pour le dire plus profondément, si la classe est définitive, toutes les méthodes de la classe sont finales. Le compilateur Java peut alimenter toutes les méthodes (cela dépend de l'implémentation du compilateur). Dans mes tests, j'ai vu une augmentation moyenne des performances de 50%.
9. L'exception est lancée là où elle doit être lancée.
Try {Some.Method1 (); (Method2Exception e) {// Gire l'exception 2} try {Some.Method3 ();} Catch (Method3Exception e) {// Gire l'exception 3} Le code téléchargé est plus facile à optimiser par le compilateur
Try {Some.Method1 (); Catch (Method3Exception e) {// Gérer l'exception 3}
10. Optimisation de la boucle
Remplacer…
pour (int i = 0; i <collection.size (); i ++) {
...
}
avec…
pour (int i = 0, n = collection.size (); i <n; i ++) {
...
}
5. Dans le développement du système d'application Java + Oracle, essayez d'utiliser des instructions SQL intégrées en majuscules en Java pour réduire la charge d'analyse de l'analyseur Oracle.
10. Essayez d'adopter la stratégie de chargement paresseuse, c'est-à-dire commencer à créer en cas de besoin.
Par exemple: String str = «aaa»;
if (i == 1) {
list.add (str);
}
Devrait être remplacé par:
if (i == 1) {
String str = «aaa»;
list.add (str);
}
12. Ne l'utilisez pas dans une boucle:
Essayer {
} attraper() {
}
Il doit être placé sur la couche la plus externe
Ce qui précède concerne cet article.
Veuillez prendre le temps de partager l'article avec vos amis ou de laisser un commentaire. Nous vous remercierons sincèrement pour votre soutien!