Optimieren Sie die Programme durch Java -Code -Spezifikationen, optimieren
Die für die Nutzung von Programmen verfügbaren Ressourcen (Speicher, CPU -Zeit, Netzwerkbandbreite usw.) sind begrenzt. Die Optimierung umfasst normalerweise zwei Aspekte: Reduzierung der Größe des Codes und Verbesserung der laufenden Effizienz des Codes. In diesem Artikel wird hauptsächlich erläutert, wie die Effizienz des Codes verbessert werden kann.
In Java -Programmen liegen die meisten Gründe für Leistungsprobleme nicht in der Java -Sprache, sondern in dem Programm selbst. Es ist sehr wichtig, gute Code -Schreibgewohnheiten zu entwickeln, z. B. korrekt und geschickt die Java.lang.String -Klasse und die Java.util.Vector -Klasse, die die Leistung des Programms erheblich verbessern kann. Lassen Sie uns dieses Problem nachstehend im Detail analysieren.
1. Versuchen Sie, festzustellen, dass der endgültige Modifikator der Klasse mit endgültigen Modifikatoren mit endgültigen Modifikatoren nicht abgeleitet ist.
In der Java -Kern -API gibt es viele Beispiele für die endgültige Anwendung, wie Java.lang.String. Das Angeben der endgültigen für die String -Klasse verhindert, dass Personen die Länge () -Methode überschreiben. Wenn eine Klasse als endgültig angegeben ist, sind alle Methoden dieser Klasse endgültig. Der Java -Compiler sucht nach Möglichkeiten, alle endgültigen Methoden zu inline (dies hängt mit der spezifischen Compiler -Implementierung zusammen). Dieser Schritt kann die Leistung durchschnittlich 50%verbessern.
2. Versuchen Sie, das Objekt wiederzuverwenden.
Insbesondere bei der Verwendung von String -Objekten wird StringBuffer stattdessen verwendet, wenn eine String -Verkettung auftritt. Da das System nicht nur Zeit braucht, um Objekte zu generieren, kann es auch Zeit brauchen, um diese Objekte in Zukunft zu sammeln und zu verarbeiten. Daher hat die Erzeugung von zu vielen Objekten einen großen Einfluss auf die Leistung des Programms.
3. Versuchen Sie, lokale Variablen zu verwenden.
Andere Variablen, wie z. B. statische Variablen, Instanzvariablen usw., werden im Haufen erstellt und sind langsamer. Darüber hinaus können lokale Variablen je nach spezifischem Compiler/JVM weiter optimiert werden. Siehe "Verwenden Sie Stapelvariablen, wann immer möglich".
4. Wiederholen Sie die Initialisierung von Variablen nicht standardmäßig. Wenn Sie den Klassenkonstruktor aufrufen bis 0 werden Float und Doppelvariablen auf 0,0 gesetzt und logische Werte werden auf false eingestellt. Dies sollte besonders bemerkt werden, wenn eine Klasse von einem anderen abgeleitet wird, denn wenn ein Objekt mit dem neuen Schlüsselwort erstellt wird, werden alle Konstruktoren in der Konstruktorkette automatisch aufgerufen.
5. Versuchen Sie bei der Entwicklung des Java + Oracle Application Systems, Großbuchstaben in Java zu verwenden, um die Analysebelastung des Oracle -Parsers zu verringern.
6. Seien Sie während der Java -Programmierung vorsichtig, wenn Sie Datenbankverbindungen und E/A -Streaming -Vorgänge nach der Verwendung ausführen.
Da der Betrieb dieser großen Objekte große Systemaufwand verursacht und wenn Sie nicht vorsichtig sind, führt dies zu schwerwiegenden Folgen.
7. Da der JVM einen eigenen GC -Mechanismus hat, erfordert sie nicht zu viel von Programmentwicklern, was die Belastung der Entwickler in gewissem Maße verringert, aber auch versteckte Gefahren verfehlt. In dem System wird in schweren Fällen ein Gedächtnisleckage verursacht, sodass es von großer Bedeutung ist, das rechtzeitige Recycling abgelaufener Objekte zu gewährleisten .
Die Bedingung für JVM zum Recyceln von Müll besteht darin, dass auf das Objekt nicht verwiesen wird. Daher wird empfohlen, dass wir es nach Verwendung des Objekts manuell auf Null setzen.
8. Versuchen Sie bei Verwendung des Synchronisationsmechanismus die Methodensynchronisation anstelle der Codeblock -Synchronisation.
9. Minimieren Sie wiederholte Berechnungen von Variablen <br /> zum Beispiel: für (int i = 0; i <list.size; i ++) {
…
}
Sollte ersetzt werden durch:
für (int i = 0, int len = list.size (); i <len; i ++) {
…
}
10. Versuchen Sie, die faule Ladestrategie zu übernehmen, dh bei Bedarf zu erstellen.
Zum Beispiel: String str = "aaa";
if (i == 1) {
list.add (str);
}
Sollte ersetzt werden durch:
if (i == 1) {
String str = "aaa";
list.add (str);
}
11. Verwenden Sie Anomalien mit Vorsicht
Abnormalität ist nicht gut für die Leistung. Um eine Ausnahme auszulösen, müssen Sie zunächst ein neues Objekt erstellen. Der Konstruktor der Throwable Interface ruft die lokale (native) Methode mit dem Namen fillInstacktrace () auf, und die Methode FillInstackTrace () überprüft den Stapel und sammelt Anrufverfolgungsinformationen. Solange eine Ausnahme ausgelöst wird, muss die VM den Anrufstapel anpassen, da während der Verarbeitung ein neues Objekt erstellt wird. Ausnahmen können nur für die Fehlerbehandlung verwendet werden und sollten nicht zur Steuerung des Programmflusses verwendet werden.
12. Verwenden Sie es nicht in einer Schleife:
Versuchen {
} fangen() {
}
Es sollte auf die äußerste Schicht platziert werden.
13. Verwendung von StringBuffer:
StringBuffer repräsentiert eine variable, beschreibbare Zeichenfolge.
Es gibt drei Baumethoden:
StringBuffer ();
StringBuffer (int Größe);
StringBuffer (String Str);
Der hier erwähnte Konstruktor ist StringBuffer (int Länge), und der Längenparameter zeigt die Anzahl der Zeichen an, die der aktuelle StringBuffer halten kann. Sie können auch die Methode zur Sicherungstätigkeit (int minimale Kapazität) verwenden, um die Kapazität nach dem Erstellen des StringBuffer -Objekts festzulegen. Schauen wir uns zunächst das Standardverhalten von StringBuffer an und finden Sie dann einen besseren Weg, um die Leistung zu verbessern.
StringBuffer verwaltet intern ein Zeichenarray. Wenn der StringBuffer seine maximale Kapazität erreicht, erhöht er seine Kapazität auf das 2 -fache der aktuellen Kapazität und fügt 2 hinzu, dh (2*alter Wert +2). Wenn Sie den Standardwert nach der Initialisierung verwenden, fügen Sie die Zeichen hinzu. bis 70 (2*34+2). Egal was, solange der StringBuffer seine maximale Kapazität erreicht, muss er ein neues Charakter-Array erstellen und dann sowohl die alten als auch die neuen Charaktere neu kopieren. Daher ist es nicht falsch, immer einen angemessenen Initialisierungskapazitätswert für StringBuffer festzulegen, der einen sofortigen Leistungsgewinn bringt. Dies zeigt die Rolle der Anpassung des StringBuffer -Initialisierungsprozesses. Die Verwendung eines geeigneten Kapazitätswerts zum Initialisieren eines StringBuffer ist also immer ein optimaler Vorschlag.
14. Verwenden Sie die Java -Klasse Java.util.Vector vernünftig.
Einfach ausgedrückt, ein Vektor ist ein Array von Java.lang.Object -Instanzen. Vektor ähnelt einem Array, und auf seine Elemente kann über einen Index in Form einer Ganzzahl zugegriffen werden. Nach der Erstellung eines Objekts vom Vektortyp kann die Größe des Objekts jedoch gemäß der Zugabe oder Löschung von Elementen erweitert und reduziert werden. Bitte betrachten Sie das folgende Beispiel für das Hinzufügen von Elementen zu Vektor:
Objekt BJ = neues Objekt ();
Vektor v = neuer Vektor (100000);
für (int i = 0;
I <100000;
Es sei denn, es gibt absolut ausreichend Grund, dass neue Elemente jedes Mal vor Vektor eingefügt werden, ist der obige Code schlecht für die Leistung. Im Standardkonstruktor beträgt die anfängliche Speicherkapazität von Vektor 10 Elemente. Die Vektorklasse ist wie die Object StringBuffer -Klasse. Das folgende Code -Snippet ist Größenordnungen schneller als das vorherige Beispiel:
Objekt BJ = neues Objekt ();
Vektor v = neuer Vektor (100000);
für (int i = 0; i <100000; i ++) {v.add (obj);
Die gleiche Regel gilt für die Methode von REME () der Vektorklasse. Da jedes Element im Vektor keinen "Speicherplatz" zwischen jedem Element enthalten kann, führt das Löschen eines anderen Elements außer dem letzten Element dazu, dass die Elemente nach dem gelöschten Element vorwärts gehen. Das heißt, das Löschen des letzten Elements aus einem Vektor ist mehrmals weniger "Overhead" als das Löschen des ersten Elements.
Unter der Annahme, dass wir alle Elemente aus dem vorherigen Vektor entfernen möchten, können wir diesen Code verwenden:
für (int i = 0; i <100000; i ++)
{
v.Remove (0);
}
Im Vergleich zu dem folgenden Code ist der vorherige Code jedoch langsamer Ordnungen:
für (int i = 0; i <100000; i ++)
{
v.Remove (v.Size ()-1);
}
Der beste Weg, um alle Elemente aus einem Objekt V des Typs Vektor zu löschen, ist:
v.removeallelementements ();
Angenommen, das Objekt V des Typs Vektor enthält die Zeichenfolge "Hallo". Betrachten Sie den folgenden Code, der die Zeichenfolge "Hallo" aus diesem Vektor entfernt:
String S = "Hallo";
int i = v.Indexof (s);
if (i! = -1) v.remove (s);
Der Code sieht nach nichts aus, aber er ist auch schlecht für die Leistung. In diesem Code sucht die Indexof () -Methode v in der Sequenz, um die Zeichenfolge "Hallo" zu finden, und die Methode entfernen (s) auch in derselben Reihenfolge suchen. Die verbesserte Version lautet:
String S = "Hallo";
int i = v.Indexof (s);
if (i! = -1) v.remove (i);
In dieser Version geben wir direkt die genaue Indexposition des Elements an, das in der Methode von REME () gelöscht werden soll, wodurch die zweite Suche vermieden wird. Eine bessere Version ist:
String S = "Hallo";
Schauen wir uns schließlich einen Code -Snippet über die Vektorklasse an:
für (int i = 0; i ++; i <v.Length)
Wenn V 100.000 Elemente enthält, ruft dieser Code -Snippet die V.SIZE () -Methode 100.000 Mal auf. Obwohl die Größenmethode eine einfache Methode ist, erfordert sie immer noch den Overhead eines Methodenaufrufs, zumindest das JVM muss die Stapelumgebung dafür konfigurieren und löschen. Hier ändert der Code in der For -Loop die Größe des Vektortypobjekts V in keiner Weise, sodass der obige Code am besten in das folgende Formular umgeschrieben wird:
int size = v.size ();
Dies ist zwar eine einfache Veränderung, gewinnt immer noch die Leistung. Schließlich ist jeder CPU -Zyklus kostbar.
15. Verwenden Sie beim Kopieren einer großen Datenmenge das System.ArrayCopy () Befehl.
16. Code Refactoring: Verbessern Sie die Lesbarkeit des Codes .
Zum Beispiel:
öffentliche Klasse Shopcart {private List Carts;… public void add (Objektelement) {if (carts == null) {carts = new ArrayList ();} crts.add (item);} public void remove (Objektelement) {if (CARTS. Enthält (Element)) {carts.remove (item);}} publiclist getCarts () {// return-only list return collections.unmodifiablelist (Wagen);} // Diese Methode wird nicht empfohlen // dieses . 17. Erstellen Sie eine Instanz einer Klasse, ohne neue Schlüsselwörter zu verwenden
Beim Erstellen einer Instanz einer Klasse mit dem neuen Schlüsselwort werden alle Konstruktoren in der Konstruktorkette automatisch aufgerufen. Wenn ein Objekt jedoch die klonbare Schnittstelle implementiert, können wir seine Clone () -Methode aufrufen. Die Clone () -Methode ruft keine Klassenkonstruktoren auf.
Wenn Sie das Entwurfsmuster verwenden, können Sie eine neue Objektinstanz sehr einfach verwenden, wenn Sie den Werksmodus zum Erstellen eines Objekts verwenden, um eine neue Objektinstanz zu erstellen. Beispielsweise ist Folgendes eine typische Implementierung des Fabrikmusters:
public statische Kredit GetNewcredit () {
Return New Credit ();
}
Der verbesserte Code verwendet die Clone () -Methode wie folgt:
private statische Kredit -Basis -Basis = neuer Kredit ();
public statische Kredit GetNewcredit () {
return (credit) basecredit.clone ();
}
Die obige Idee ist auch sehr nützlich für die Array -Verarbeitung.
18. Multiplikation und Abteilung
Betrachten Sie den folgenden Code:
für (val = 0; val <100000; val += 5) {
Alterx = val * 8;
}
Das Ersetzen der Multiplikation durch Schichtbetriebe kann die Leistung erheblich verbessern. Hier ist der geänderte Code:
für (val = 0; val <100000; val += 5) {
Alterx = val << 3;
}
Der modifizierte Code multipliziert nicht mehr mit 8, sondern verwendet stattdessen die äquivalente linke Verschiebung von 3 Bits, wobei 1 Bit pro linker Verschiebung äquivalent mit 2 multipliziert wird. Dementsprechend entspricht die richtige Verschiebung um 1 Bit -Operation der Dividierung durch 2. Erwähnenswert ist erwähnenswert, dass der Schichtbetrieb, obwohl er schnell ist, den Code schwierig zu verstehen kann. Es ist also am besten, einige Kommentare hinzuzufügen.
19. Nutzlose Sitzungen auf der JSP -Seite schließen.
Ein häufiges Missverständnis ist, dass die Sitzung bei Client -Zugriff erstellt wird. Verwenden Sie <>, um es zu schließen. Da die Sitzung Speicherressourcen verbraucht, sollten Sie sie in allen JSPs schließen, wenn Sie nicht planen, die Sitzung zu verwenden.
Bei Seiten, die keinen Sitzungsstatus verfolgen müssen, können automatisch erstellte Sitzungen einige Ressourcen speichern. Verwenden Sie die folgende Seitenrichtlinie: <%@ page session = "false"%>
20. JDBC und I/O.
Wenn eine Anwendung auf einen großflächigen Datensatz zugreifen muss, sollten Sie in Betracht ziehen, die Blockextraktion zu verwenden. Standardmäßig extrahiert JDBC jedes Mal 32 Datenzeilen. Angenommen, wir möchten einen Datensatzsatz von 5000 Zeilen durchqueren. JDBC muss die Datenbank 157 Mal aufrufen, bevor sie alle Daten extrahieren kann. Wenn die Blockgröße in 512 geändert wird, wird die Anzahl der Anrufe in die Datenbank auf das 10 -fache reduziert.
21. Servlet- und Speicherverbrauch <BR /> Viele Entwickler sparen nach Belieben eine große Menge an Informationen für Benutzersitzungen. Manchmal werden die in der Sitzung gespeicherten Objekte nicht rechtzeitig vom Müllsammlungsmechanismus recycelt. Aus Perspektive der Leistung besteht ein typisches Symptom darin, dass der Benutzer der Ansicht ist, dass das System regelmäßig langsamer wird, aber den Grund nicht auf eine bestimmte Komponente zurückzuführen ist. Wenn Sie den Heap -Raum des JVM überwachen, manifestiert er sich als abnormale Gedächtnisverwendungsschwankungen.
Es gibt zwei Hauptmethoden, um diese Art von Speicherproblemen zu lösen. Die erste Methode besteht darin, die HTTPSessionBindingListener -Schnittstelle in allen Bohnen mit einem Sitzungsbereich zu implementieren. Auf diese Weise können die von der Bean verwendeten Ressourcen explizit veröffentlicht werden, solange die ValueUnbound () -Methode implementiert ist.
Eine andere Möglichkeit besteht darin, die Sitzung so schnell wie möglich ungültig zu machen. Die meisten Anwendungsserver haben die Option, das Sitzungsintervall der Sitzung zu setzen. Zusätzlich kann die SetMaxinactionInterVal () -Methode der Sitzung programmgesteuert aufgerufen werden.
22. Verwenden Sie Puffermarken
Einige Anwendungsserver haben die Puffermarkierungsfunktion für JSP hinzugefügt. Zum Beispiel unterstützt der Weblogic Server von Bea diese Funktion seit Version 6.0, und das Open Symphony -Projekt unterstützt diese Funktion ebenfalls. JSP -Puffer -Tags können beide Seitenfragmente und die gesamte Seite pufferen. Wenn die JSP -Seite ausgeführt wird, muss der Code, der das Fragment generiert, nicht mehr ausgeführt werden, wenn sich das Zielfragment bereits im Puffer befindet. Pufferung auf Seitenebene erfasst Anfragen an die angegebene URL und puffert die gesamte Ergebnisseite. Diese Funktion ist äußerst nützlich für Einkaufskörbe, Kataloge und Portal -Homepages. Für solche Anwendungen kann die Pufferung auf Seitenebene die Ergebnisse der Seitenausführung für nachfolgende Anforderungen speichern.
23. Wählen Sie den richtigen Zitiermechanismus
In einem typischen JSP -Anwendungssystem werden häufig die Header- und Fußzeile -Teile extrahiert, und dann werden die Header und die Fußzeile nach Bedarf eingeführt. Derzeit gibt es zwei Hauptmethoden, um externe Ressourcen in JSP -Seiten einzuführen: Einbeziehung von Richtlinien und Einbeziehung von Maßnahmen.
Richtlinie einschließen: Zum Beispiel < %@ include File = "Copyright.html" %>. Diese Richtlinie führt die angegebene Ressource zur Kompilierung des Zeitpunkts ein. Vor der Zusammenstellung werden die Seite mit der Richtlinie und der angegebenen Ressource in eine Datei zusammengeführt. Die referenzierten externen Ressourcen werden zur Kompilierungszeit ermittelt, was effizienter ist als die Ressourcen zur Laufzeit zu bestimmen.
Handlung eingeben: Zum Beispiel <jsp: include page = "copyright.jsp" />. Diese Aktion führt das nach der Ausführung der angegebene Seite generierte Ergebnis ein. Da es zur Laufzeit abgeschlossen ist, ist die Steuerung der Ausgangsergebnisse flexibler. Es ist jedoch nur kostengünstig, Aktionen einzuschließen, wenn der zitierte Inhalt häufig geändert wird oder wenn die referenzierte Seite nicht ermittelt werden kann, bevor die Anforderung für die Hauptseite angezeigt wird.
24. Clear Non Notwendigkeiten mehr als rechtzeitig benötigte Sitzungen mehr
Um Sitzungen zu löschen, die nicht mehr aktiv sind, haben viele Anwendungsserver eine Standard -Sitzungs -Zeitüberschreitung, normalerweise 30 Minuten. Wenn der Anwendungsserver mehr Sitzungen speichern muss, überträgt das Betriebssystem einen Teil der Speicherdaten auf die Festplatte. Speichern Sie auf der Festplatte und kann sogar eine "Ausnahme aus dem Gedächtnis" auslegen. In groß angelegten Systemen sind die Serialisierungssitzungen teuer. Wenn die Sitzung nicht mehr benötigt wird, sollte die Methode httpSession.invalidate () rechtzeitig aufgerufen werden, um die Sitzung zu löschen. Die Methode httpSession.invalidate () kann normalerweise auf der Ausgangsseite der Anwendung aufgerufen werden.
25. Erklären Sie Array nicht als: öffentliches statisches Finale.
26. Diskussion über die Durchfahrteneffizienz von HashMap
In HashMap gibt es häufig Traversaloperationen für Schlüssel- und Wertpaare, und es gibt zwei Methoden: MAP <String, String []> paramap = new
HashMap <String, String []> (); ............ // Die erste Schleife set <string> appfieldDefids = paramap.keyset (); ] values = paramap.get (AppFieldDefid); ......} // Die zweite Schleife für (Eintrag <String, String []> Eintrag: paramap.EnrySet ()) {String AppFieldDefid = Eintrag.getKey ( ); String [] values = Eintrag.getValue (); .......} Die erste Implementierung ist deutlich weniger effizient als die zweite Implementierung.
Die Analyse ist wie folgt set <string> appfieldDefids = paramap.keyset ();
Der Code ist wie folgt:
public set <k> keyset () {set <k> ks = keyset; return (ks! = null? ks: (keyset = new keyset ());} private Klasse Keyset erweitert AbstractSet <k> {public iterator <k > iterator () {return NewKeiperator ();} public int size () {return size;} public boolean enthält (Objekt o) {return enthält kontainkey (o);} public boolean entfernen (Objekt o) {return hashmap.this.ReMoveEntryforkey (o)!Tatsächlich gibt es einen privaten Klassenschlüssel zurück, der von AbstractSet geerbt wird und die festgelegte Schnittstelle implementiert.
Schauen wir uns die Syntax von für/in Schleifen an
für (Deklaration: Ausdruck)
Stellungnahme
Während der Ausführungsphase wird es in die folgenden Formeln übersetzt
für (iterator <e> #i = (Ausdruck) .Iiterator (); #i.hasnext ();) {
Deklaration = #I.Next ();
Stellungnahme
}
Daher wird Hashmap.keyset (). Iterator () in der ersten für eine Anweisung für (String AppFieldDefid: AppfieldDefids) aufgerufen.
Diese Methode ruft NewKlearIterator () auf
Iterator <K> NewKeyiterator () {
return New Keyiterator ();
}
Private Class Keyiterator erweitert Hashiterator <k> {
public k Next () {
return NextEntry (). getKey ();
}
}
In der for wird der Iterator in der zweiten Schleife für (Eintrag <String, String []> Eintrag: paramap.EnrySet ()) wie folgt aufgerufen.
Art
Private Class EntryTiterator erweitert Hashiterator <map.Entry <k, v >> {
public map.entry <k, v> next () {
return NextEntry ();
}
}
Zu diesem Zeitpunkt erhält die erste Schleife den Schlüssel, und die zweite Schleife erhält die Eintrittseffizienz von HashMap, dass die zweite Schleife in der Schleife reflektiert wird. Verwenden Sie HashMaps GET (Objektschlüssel), um den Wertwert zu erhalten
public v Get (Objektschlüssel) {
Objekt k = Masknull (Schlüssel);
int Hash = Hash (k);
int i = indexFor (Hash, Tabelle.Length);
Eintrag <k, v> e = Tabelle;
while (wahr) {
if (e == null)
null zurückkehren;
if (e.hash == Hash && EQ (k, E.Key))
Return E. value;
e = E.Next;
}
}
In der Tat ist es, den Hash -Wert zu verwenden, um den entsprechenden Eintrag erneut zu vergleichen und das Ergebnis zu erzielen.
In der zweiten Schleife erhalten Sie den Einstiegswert und nehmen Sie dann direkt den Schlüssel und den Wert an, der effizienter ist als die erste Schleife. In der Tat sollte es nach dem Konzept der Karte besser sein, die zweite Schleife zu verwenden.
27. Verwendung von Array (Array) und Arrylist
Array ([]): die effizienteste;
ArrayList: Kapazität kann dynamisch wachsen;
Basierend auf Effizienz und Typüberprüfung sollte Array so weit wie möglich verwendet werden.
ArrayList ist eine komplexe Version von Array
ArrayList umfasst ein Objekt-Array Array -Methode.
Wenn ArrayList ein Objekt speichert, werden die Typinformationen verworfen und alle Objekte als Objekt blockiert.
Hinweis: JDK5 hat Unterstützung für Generika hinzugefügt, und bei Verwendung von ArrayList kann die Typüberprüfung durchgeführt werden.
Aus dieser Sicht ist der Unterschied zwischen ArrayList und Array hauptsächlich auf die Effizienz der dynamischen Kapazitätserhöhung zurückzuführen.
28. Versuchen Sie, HashMap und ArrayList zu verwenden .
29. Der Unterschied zwischen StringBuffer und StringBuilder:
Java.lang.StringBuffer-Thread-safe mutable Zeichensequenz. Ein String-ähnlicher String-Puffer, kann aber nicht geändert werden.
StringBuilder. Im Vergleich zu dieser Klasse sollte die Klasse von Java.lang.StringBuilder normalerweise bevorzugt werden, da sie dieselben Operationen unterstützt, jedoch schneller ist, da sie keine Synchronisation durchführt. Für eine bessere Leistung sollte die Kapazität von Streifengbuffer oder Sturzbuilder so viel wie möglich angegeben werden. Wenn die von Ihnen betriebene Zeichenfolge 16 Zeichen nicht überschreitet, brauchen Sie sie natürlich nicht. Im gleichen Fall kann die Verwendung von STRURNGBuilder im Vergleich zur Verwendung von StringBuffer nur etwa 10% -15% Leistungsverbesserung erzielen, es besteht jedoch das Risiko, dass Multi-Threading-Unsichere. In real modularer Programmierung kann der für ein bestimmte Modul verantwortliche Programmierer möglicherweise nicht klar feststellen Stellen Sie sicher, dass Ihr Modul nicht im Multithread -Modus ausgeführt wird, andernfalls verwenden Sie StringBuffer.
Andere Ergänzungen:
1. Löschen Sie Objekte, die nicht mehr rechtzeitig verwendet und auf Null gesetzt werden
2. Verwenden Sie so viel wie möglich endgültige, statische und andere Schlüsselwörter
3. Verwenden Sie so weit wie möglich gepufferte Objekte
So optimieren Sie den Code, um die Java -Quelldatei zu machen und die Klassendatei kleiner zu kompilieren
1 Versuchen Sie, die Vererbung zu verwenden.
2 Öffnen Sie die Optimierungsoptionen des Java -Compilers: Javac -o Diese Option löscht die Zeilennummer in der Klassendatei und deklariert einige private, statische und endgültige Klein -Segment -Methoden als Inline -Methode Calls
3 Extrahieren Sie den gemeinsamen Code
4 Initialisieren Sie keine großen Arrays. In einem Array gespeichert, können Sie diese Daten zuerst in eine Zeichenfolge einfügen und dann die Zeichenfolge während der Laufzeit in ein Array analysieren
5. Date -Typ -Objekte nehmen viel Platz ein.
langer Typ, dann bei Verwendung zum Datumstyp konvertieren
6. Versuchen Sie, kurze Namen für Klassennamen, Methodennamen und Variablennamen zu verwenden.
7 Definieren Sie Variablen des statischen Endtyps in die Schnittstelle
8 Wenn arithmetische Operationen für die linke / rechte Bewegung verwendet werden können, verwenden Sie nicht mehrmals die gleichen Vorgänge.
2. Initialisieren Sie Variablen nicht zweimal
Java initialisiert die Variable standardmäßig mit einem bekannten Wert, indem Sie einen eindeutigen Klassenkonstruktor aufrufen. Alle Objekte werden auf Null gesetzt, Ganzzahlen (Byte, kurz, int, lang) werden auf 0, float und doppelt auf 0,0 gesetzt, und Boolesche Variablen werden auf false eingestellt. Dies ist besonders wichtig für Klassen, die sich aus anderen Klassen erstrecken, genau wie alle Konstruktoren, die beim Erstellen eines Objekts mit einem neuen Schlüsselwort automatisch aufgerufen werden.
3. Machen Sie die Klasse, wo immer möglich
Die endgültigen Klassen können nicht erweitert werden. Es gibt viele Beispiele für diese Technologie in der Kern -Java -API wie Java.lang.String. Das Markieren der Streicherklasse als endgültig verhindert Entwickler daran, Längenmethoden zu erstellen, die sie selbst implementieren.
Um es tiefer auszudrücken, wenn die Klasse endgültig ist, sind alle Methoden der Klasse endgültig. Der Java -Compiler kann alle Methoden einführen (dies hängt von der Implementierung des Compilers ab). In meinen Tests habe ich einen durchschnittlichen Leistungsanstieg um 50%verzeichnet.
9. Die Ausnahme wird dorthin geworfen, wo sie geworfen werden muss.
Versuchen Sie {einige.Method1 (); (method2Exception e) {// Ausnahme 2} try {einige.Method3 (); Der heruntergeladene Code ist vom Compiler einfacher zu optimieren
Versuchen Sie {einige.Method1 (); catch (method3Exception e) {// Ausnahme 3} handeln}
10. Optimierung von für Schleife
Ersetzen…
für (int i = 0; i <collection.size (); i ++) {
...
}
mit…
für (int i = 0, n = collection.size (); i <n; i ++) {
...
}
5. Versuchen Sie bei der Entwicklung des Java + Oracle Application Systems, in Java eingebettete SQL -Anweisungen in Großbuchstaben zu verwenden, um die Analysebelastung des Oracle -Parsers zu verringern.
10. Versuchen Sie, die faule Ladestrategie zu übernehmen, dh bei Bedarf zu erstellen.
Zum Beispiel: String str = "aaa";
if (i == 1) {
list.add (str);
}
Sollte ersetzt werden durch:
if (i == 1) {
String str = "aaa";
list.add (str);
}
12. Verwenden Sie es nicht in einer Schleife:
Versuchen {
} fangen() {
}
Es sollte auf die äußerste Schicht platziert werden
Das oben genannte dreht sich um diesen Artikel.
Bitte nehmen Sie sich etwas Zeit, um den Artikel mit Ihren Freunden zu teilen oder einen Kommentar zu hinterlassen. Wir werden uns aufrichtig für Ihre Unterstützung bedanken!