1. Créez 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. Si vous créez un objet à l'aide du modèle Factory, il est très simple d'utiliser la méthode clone() pour créer une nouvelle instance d'objet.
2. N'initialisez pas les variables à plusieurs reprises
Par défaut, Java initialise les variables à certaines valeurs lorsque le constructeur d'une classe est appelé. 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.
3. Utilisez les exceptions avec prudence
Les exceptions sont mauvaises pour les performances. Lancer une exception crée 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 jVM 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.
Faites attention aux deux points suivants. (1) Évitez d'utiliser try/catch pour la logique de l'application. S'il peut être traité avec des instructions logiques telles que if et while, essayez de ne pas utiliser d'instructions try/catch autant que possible. (2) Réutilisez les exceptions lorsque la gestion des exceptions est nécessaire. , réutilisez autant que possible les objets d’exception existants. Car dans la gestion des exceptions, générer un objet d’exception prend la plupart du temps.
4. Fil
Les threads peuvent utiliser pleinement les ressources du système. Pendant que d'autres threads attendent la lecture et l'écriture sur le disque dur ou sur le réseau, le programme peut continuer à traiter et à s'exécuter. Cependant, une mauvaise utilisation des threads affectera également les performances du programme. Exemple : utilisez correctement la classe Vector. Le vecteur est principalement utilisé pour enregistrer différents types d'objets (y compris des objets du même type et des types différents). Vector fournit des fonctions de protection de sécurité des threads. Même si de nombreuses méthodes de la classe Vector sont synchronisées. Mais si vous avez confirmé que votre application est monothread, la synchronisation de ces méthodes est totalement inutile. De plus, lors de la recherche de divers objets stockés dans Vector, la correspondance des types prend souvent beaucoup de temps. Lorsque ces objets sont tous du même type, ces correspondances sont totalement inutiles. Par conséquent, il est nécessaire de concevoir une classe ou une collection monothread qui enregistre les objets d'un type spécifique pour remplacer la classe Vector.
Concernant les opérations sur les threads, veuillez noter : (1) Évitez une synchronisation excessive. Si le programme est monothread, veillez à ne pas utiliser la synchronisation. (2) Synchronisez les méthodes au lieu de synchroniser l'intégralité du segment de code. La synchronisation d'une méthode offre de meilleures performances que la synchronisation de l'intégralité du segment de code.
5. Essayez d'utiliser des 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és dans la pile (Stack), ce qui est plus rapide.
6. Utilisez autant que possible des variables statiques
Laissez toutes les instances partager cette variable.
7. Essayez de spécifier le modificateur final de la classe
Les classes avec le modificateur final ne sont pas dérivées. 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, ce qui peut améliorer les performances de 50 % en moyenne.
8. Création d'objets et allocation d'un espace et d'une taille raisonnables
Un grand nombre d'objets (ou d'instances) sont souvent générés dans la programmation JAVA. Étant donné que le système prend non seulement du temps pour générer des objets, il peut également prendre du temps pour récupérer et traiter ces objets ultérieurement. Par conséquent, générer trop d’objets aura un grand impact sur les performances du programme ; de plus, de nombreuses classes en JAVA ont leurs tailles d’allocation d’espace par défaut. Pour la classe StringBuffer, la taille de l'espace alloué par défaut est de 16 caractères. Si la taille de l'espace de StringBuffer utilisé dans le programme n'est pas de 16 caractères, alors une initialisation correcte doit être effectuée.
9. Utilisez des E/S non bloquantes
Les versions inférieures du JDK ne prennent pas en charge l'API d'E/S non bloquante. Pour éviter le blocage des E/S, certaines applications créent un grand nombre de threads (dans le meilleur des cas, un pool de tampons est utilisé). Cette technique peut être utilisée dans de nombreuses applications qui doivent prendre en charge des flux d'E/S simultanés, tels que les serveurs Web. JDK 1.4 a introduit une bibliothèque d'E/S non bloquante (java.nio).
Cet article provient du blog CSDN Veuillez indiquer la source lors de la réimpression : http://blog.csdn.net/Foxalien/archive/2009/12/18/5029659.aspx.