Java代碼如何優(yōu)化

1. 盡量在合適的場合使用單例

創(chuàng)新互聯(lián)主要從事網(wǎng)站設(shè)計制作、做網(wǎng)站、網(wǎng)頁設(shè)計、企業(yè)做網(wǎng)站、公司建網(wǎng)站等業(yè)務(wù)。立足成都服務(wù)任丘,十載網(wǎng)站建設(shè)經(jīng)驗,價格優(yōu)惠、服務(wù)專業(yè),歡迎來電咨詢建站服務(wù):18980820575

使用單例可以減輕加載的負(fù)擔(dān)，縮短加載的時間，提高加載的效率，但并不是所有地方都適用于單例，簡單來說，單例主要適用于以下三個方面：

第一，控制資源的使用，通過線程同步來控制資源的并發(fā)訪問;

第二，控制實例的產(chǎn)生，以達(dá)到節(jié)約資源的目的;

第三，控制數(shù)據(jù)共享，在不建立直接關(guān)聯(lián)的條件下，讓多個不相關(guān)的進(jìn)程或線程之間實現(xiàn)通信。

2. 盡量避免隨意使用靜態(tài)變量

要知道，當(dāng)某個對象被定義為stataic變量所引用，那么gc通常是不會回收這個對象所占有的內(nèi)存

3. 盡量避免過多過常的創(chuàng)建Java對象

盡量避免在經(jīng)常調(diào)用的方法，循環(huán)中new對象，由于系統(tǒng)不僅要花費(fèi)時間來創(chuàng)建對象，而且還要花時間對這些對象進(jìn)行垃圾回收和處理，在我們可以控制的范圍內(nèi)，最大限度的重用對象，最好能用基本的數(shù)據(jù)類型或數(shù)組來替代對象。

4. 盡量使用final修飾符

帶有final修飾符的類是不可派生的。在Java核心API中，有許多應(yīng)用final的例子，例如java.lang.String.為String類指定final防止了使用者覆蓋length()方法。另外，如果一個類是final的，則該類所有方法都是final的。Java編譯器會尋找機(jī)會內(nèi)聯(lián)(inline)所有的final方法(這和具體的編譯器實現(xiàn)有關(guān))。此舉能夠使性能平均提高50%.

5. 盡量使用局部變量

調(diào)用方法時傳遞的參數(shù)以及在調(diào)用中創(chuàng)建的臨時變量都保存在棧(Stack)中，速度較快。其他變量，如靜態(tài)變量、實例變量等，都在堆(Heap)中創(chuàng)建，速度較慢。

6. 盡量處理好包裝類型和基本類型兩者的使用場所

雖然包裝類型和基本類型在使用過程中是可以相互轉(zhuǎn)換，但它們兩者所產(chǎn)生的內(nèi)存區(qū)域是完全不同的，基本類型數(shù)據(jù)產(chǎn)生和處理都在棧中處理，包裝類型是對象，是在堆中產(chǎn)生實例。

在集合類對象，有對象方面需要的處理適用包裝類型，其他的處理提倡使用基本類型。

7. 慎用synchronized,盡量減小synchronize的方法

都知道，實現(xiàn)同步是要很大的系統(tǒng)開銷作為代價的，甚至可能造成死鎖，所以盡量避免無謂的同步控制。synchronize方法被調(diào)用時，直接會把當(dāng)前對象鎖 了，在方法執(zhí)行完之前其他線程無法調(diào)用當(dāng)前對象的其他方法。所以synchronize的方法盡量小，并且應(yīng)盡量使用方法同步代替代碼塊同步。

8. 盡量使用StringBuilder和StringBuffer進(jìn)行字符串連接

這個就不多講了。

9. 盡量不要使用finalize方法

實際上，將資源清理放在finalize方法中完成是非常不好的選擇，由于GC的工作量很大，尤其是回收Young代內(nèi)存時，大都會引起應(yīng)用程序暫停，所以再選擇使用finalize方法進(jìn)行資源清理，會導(dǎo)致GC負(fù)擔(dān)更大，程序運(yùn)行效率更差。

10. 盡量使用基本數(shù)據(jù)類型代替對象

String str = "hello";

上面這種方式會創(chuàng)建一個"hello"字符串，而且JVM的字符緩存池還會緩存這個字符串;

String str = new String("hello");

此時程序除創(chuàng)建字符串外，str所引用的String對象底層還包含一個char[]數(shù)組，這個char[]數(shù)組依次存放了h,e,l,l,o

11. 單線程應(yīng)盡量使用HashMap、ArrayList

HashTable、Vector等使用了同步機(jī)制，降低了性能。

12. 盡量合理的創(chuàng)建HashMap

當(dāng)你要創(chuàng)建一個比較大的hashMap時，充分利用另一個構(gòu)造函數(shù)

public HashMap(int initialCapacity, float loadFactor)

避免HashMap多次進(jìn)行了hash重構(gòu)，擴(kuò)容是一件很耗費(fèi)性能的事，在默認(rèn)中initialCapacity只有16,而loadFactor是 0.75,需要多大的容量，你最好能準(zhǔn)確的估計你所需要的最佳大小，同樣的Hashtable,Vectors也是一樣的道理。

13. 盡量減少對變量的重復(fù)計算

并且在循環(huán)中應(yīng)該避免使用復(fù)雜的表達(dá)式，在循環(huán)中，循環(huán)條件會被反復(fù)計算，如果不使用復(fù)雜表達(dá)式，而使循環(huán)條件值不變的話，程序?qū)\(yùn)行的更快。

14. 盡量避免不必要的創(chuàng)建

15. 盡量在finally塊中釋放資源

程序中使用到的資源應(yīng)當(dāng)被釋放，以避免資源泄漏。這最好在finally塊中去做。不管程序執(zhí)行的結(jié)果如何，finally塊總是會執(zhí)行的，以確保資源的正確關(guān)閉。

16. 盡量使用移位來代替'a/b'的操作

"/"是一個代價很高的操作，使用移位的操作將會更快和更有效

17.盡量使用移位來代替'a*b'的操作

同樣的，對于'*'操作，使用移位的操作將會更快和更有效

18. 盡量確定StringBuffer的容量

StringBuffer 的構(gòu)造器會創(chuàng)建一個默認(rèn)大小(通常是16)的字符數(shù)組。在使用中，如果超出這個大小，就會重新分配內(nèi)存，創(chuàng)建一個更大的數(shù)組，并將原先的數(shù)組復(fù)制過來，再 丟棄舊的數(shù)組。在大多數(shù)情況下，你可以在創(chuàng)建 StringBuffer的時候指定大小，這樣就避免了在容量不夠的時候自動增長，以提高性能。

19. 盡量早釋放無用對象的引用

大部分時，方法局部引用變量所引用的對象 會隨著方法結(jié)束而變成垃圾，因此，大部分時候程序無需將局部，引用變量顯式設(shè)為null.

20. 盡量避免使用二維數(shù)組

二維數(shù)據(jù)占用的內(nèi)存空間比一維數(shù)組多得多，大概10倍以上。

21. 盡量避免使用split

除非是必須的，否則應(yīng)該避免使用split,split由于支持正則表達(dá)式，所以效率比較低，如果是頻繁的幾十，幾百萬的調(diào)用將會耗費(fèi)大量資源，如果確實需 要頻繁的調(diào)用split,可以考慮使用apache的StringUtils.split(string,char)，頻繁split的可以緩存結(jié)果。

22. ArrayList LinkedList

一 個是線性表，一個是鏈表，一句話，隨機(jī)查詢盡量使用ArrayList,ArrayList優(yōu)于LinkedList,LinkedList還要移動指 針，添加刪除的操作LinkedList優(yōu)于ArrayList,ArrayList還要移動數(shù)據(jù)，不過這是理論性分析，事實未必如此，重要的是理解好2 者得數(shù)據(jù)結(jié)構(gòu)，對癥下藥。

23. 盡量使用System.arraycopy ()代替通過來循環(huán)復(fù)制數(shù)組

System.arraycopy() 要比通過循環(huán)來復(fù)制數(shù)組快的多

24. 盡量緩存經(jīng)常使用的對象

盡可能將經(jīng)常使用的對象進(jìn)行緩存，可以使用數(shù)組，或HashMap的容器來進(jìn)行緩存，但這種方式可能導(dǎo)致系統(tǒng)占用過多的緩存，性能下降，推薦可以使用一些第三方的開源工具，如EhCache,Oscache進(jìn)行緩存，他們基本都實現(xiàn)了FIFO/FLU等緩存算法。

25. 盡量避免非常大的內(nèi)存分配

有時候問題不是由當(dāng)時的堆狀態(tài)造成的，而是因為分配失敗造成的。分配的內(nèi)存塊都必須是連續(xù)的，而隨著堆越來越滿，找到較大的連續(xù)塊越來越困難。

26. 慎用異常

當(dāng)創(chuàng)建一個異常時，需要收集一個棧跟蹤(stack track)，這個棧跟蹤用于描述異常是在何處創(chuàng)建的。構(gòu)建這些棧跟蹤時需要為運(yùn)行時棧做一份快照，正是這一部分開銷很大。當(dāng)需要創(chuàng)建一個 Exception 時，JVM 不得不說：先別動，我想就您現(xiàn)在的樣子存一份快照，所以暫時停止入棧和出棧操作。棧跟蹤不只包含運(yùn)行時棧中的一兩個元素，而是包含這個棧中的每一個元素。

如 果您創(chuàng)建一個 Exception ,就得付出代價。好在捕獲異常開銷不大，因此可以使用 try-catch 將核心內(nèi)容包起來。從技術(shù)上講，您甚至可以隨意地拋出異常，而不用花費(fèi)很大的代價。招致性能損失的并不是 throw 操作--盡管在沒有預(yù)先創(chuàng)建異常的情況下就拋出異常是有點(diǎn)不尋常。真正要花代價的是創(chuàng)建異常。幸運(yùn)的是，好的編程習(xí)慣已教會我們，不應(yīng)該不管三七二十一就 拋出異常。異常是為異常的情況而設(shè)計的，使用時也應(yīng)該牢記這一原則。

(1)。 用Boolean.valueOf(boolean b)代替new Boolean()

包裝類的內(nèi)存占用是很恐怖的，它是基本類型內(nèi)存占用的N倍(N2)，同時new一個對象也是性能的消耗。

(2)。 用Integer.valueOf(int i)代替new Integer()

和Boolean類似，java開發(fā)中使用Integer封裝int的場合也非常多，并且通常用int表示的數(shù)值都非常小。SUN SDK中對Integer的實例化進(jìn)行了優(yōu)化，Integer類緩存了-128到127這256個狀態(tài)的Integer,如果使用 Integer.valueOf(int i)，傳入的int范圍正好在此內(nèi)，就返回靜態(tài)實例。這樣如果我們使用Integer.valueOf代替new Integer的話也將大大降低內(nèi)存的占用。

(3)。 用StringBuffer的append方法代替"+"進(jìn)行字符串相加。

這個已經(jīng)被N多人說過N次了，這個就不多說了。

(4)。 避免過深的類層次結(jié)構(gòu)和過深的方法調(diào)用。

因為這兩者都是非常占用內(nèi)存的(特別是方法調(diào)用更是堆?？臻g的消耗大戶)。

(5)。 變量只有在用到它的時候才定義和實例化。

這是初學(xué)者最容易犯的錯，合理的使用變量，并且只有在用到它的時候才定義和實例化，能有效的避免內(nèi)存空間和執(zhí)行性能上的浪費(fèi)，從而提高了代碼的效率。

(6)。 避免在循環(huán)體中聲明創(chuàng)建對象，即使該對象占用內(nèi)存空間不大。

這種情況在我們的實際應(yīng)用中經(jīng)常遇到，而且我們很容易犯類似的錯誤

采用上面的第二種編寫方式，僅在內(nèi)存中保存一份對該對象的引用，而不像上面的第一種編寫方式中代碼會在內(nèi)存中產(chǎn)生大量的對象引用，浪費(fèi)大量的內(nèi)存空間，而且增大了垃圾回收的負(fù)荷。因此在循環(huán)體中聲明創(chuàng)建對象的編寫方式應(yīng)該盡量避免。

(7)。 如果if判斷中多個條件用'||'或者''連接，請將出現(xiàn)頻率最高的條件放在表達(dá)式最前面。

這個小技巧往往能有效的提高程序的性能，尤其是當(dāng)if判斷放在循環(huán)體里面時，效果更明顯。

1.JVM管理兩種類型的內(nèi)存：堆內(nèi)存(heap)，棧內(nèi)存(stack)，堆內(nèi)在主要用來存儲程序在運(yùn)行時創(chuàng)建或?qū)嵗膶ο笈c變量。而棧內(nèi)存則是用來存儲程序代碼中聲明為靜態(tài)(static)(或非靜態(tài))的方法。

2.JVM中對象的生命周期，創(chuàng)建階段，應(yīng)用階段，不可視階段，不可到達(dá)階段，可收集階段，終結(jié)階段，釋放階段

3.避免在循環(huán)體中創(chuàng)建對象，即使該對象點(diǎn)用內(nèi)存空間不大。

4.軟引用的主要特點(diǎn)是具有較強(qiáng)的引用功能。只有當(dāng)內(nèi)存不夠的時候，才回收這類內(nèi)存，因此在內(nèi)存足夠的時候，它們通常不被回收。它可以用于實現(xiàn)一些常用資源的緩存，實現(xiàn)Cache的功能

5.弱引用對象與Soft引用對象最大不同就在于：GC在進(jìn)行回收時，需要通過算法檢查是否回收Soft引用對象，而對于Weak引用對象，GC總是進(jìn)行回收。

6.共享靜態(tài)變量存儲空間

7.有時候我們?yōu)榱颂岣呦到y(tǒng)性能，避免重復(fù)耗時的操作，希望能夠重用一些創(chuàng)建完成的對象，利用對象池實現(xiàn)。類似JDBC連接池。

8.瞬間值，序列化對象大變量時，如果此大變量又沒有用途，則使用transient聲明，不序列化此變量。同時網(wǎng)絡(luò)傳輸中也不傳輸。

9.不要提前創(chuàng)建對象

10 .(1)最基本的建議就是盡早釋放無用對象的引用

A a = new A();

a = null; //當(dāng)使用對象a之后主動將其設(shè)置為空

(2)盡量少用finalize函數(shù)。

(3) 如果需要使用經(jīng)常用到的圖片展，可以使用軟引用。

(4) 注意集合數(shù)據(jù)類型，包括數(shù)組，樹等數(shù)據(jù)，這些數(shù)據(jù)結(jié)構(gòu)對GC來說，回收更為復(fù)雜，

(5) 盡量避免在類的默認(rèn)構(gòu)造器中創(chuàng)建，初始化大量的對象，防止在調(diào)用其自類的構(gòu)造器時造成不必要的內(nèi)存資源浪費(fèi)。

(6) 盡量避免強(qiáng)制系統(tǒng)做垃圾內(nèi)存回收。

(7) 盡量避免顯式申請數(shù)組空間。

(8) 盡量在合適的場景下使用對象池技術(shù)以提高系統(tǒng)性能，縮減系統(tǒng)內(nèi)存開銷。

11.當(dāng)做數(shù)組拷貝操作時，采用System.arraycopy()方法完成拷貝操作要比采用循環(huán)的辦法完成數(shù)組拷貝操作效率高

12. 盡量避免在循環(huán)體中調(diào)用方法，因為方法調(diào)用是比較昂貴的。

13. 盡量避免在循環(huán)體中使用try-catch 塊，最好在循環(huán)體外使用try--catch塊以提高系統(tǒng)性能。

14. 在多重循環(huán)中，如果有可能，盡量將最長的循環(huán)放在最內(nèi)層，最短的循環(huán)放在最外層，以減少循環(huán)層間的變換次數(shù)。

15. 在需要線程安全的情況下，使用List list = Collections.synchronizedList(new ArrayList());

16. 如果預(yù)知長度，就設(shè)置ArrayList的長度。

17. ArrayList 與 LinkedList 選擇，熟悉底層的實現(xiàn)原理，選擇適當(dāng)?shù)娜萜鳌?/p>

18. 字符串累加采用StringBuffer.

19. 系統(tǒng)I/O優(yōu)化，采用緩沖和壓縮技術(shù)。優(yōu)化性能。

20. 避免在類在構(gòu)造器的初始化其他類

21 盡量避免在構(gòu)造中對靜態(tài)變量做賦值操作

22. 不要在類的構(gòu)造器中創(chuàng)建類的實例

23. 組合優(yōu)化繼承

24. 最好通過Class.forname() 動態(tài)的裝載類

25. JSP優(yōu)化，采用out 對象中的print方法代替println()方法

26 .采用ServletOutputStream 對象代替JSPWriter對象

27. 采用適當(dāng)?shù)闹党跏蓟痮ut 對象緩沖區(qū)的大小

28. 盡量采用forward()方法重定向新的JSP

29. 利用線程池技術(shù)處理客戶請求

30.Servlet優(yōu)化

(1) 通過init()方法來緩存一些靜態(tài)數(shù)據(jù)以提高應(yīng)用性能。

(2) 用print() 方法取代println()方法。

(3) 用ServletOutputStream 取代 PrintWriter.

(4) 盡量縮小同步代碼數(shù)量

31. 改善Servlet應(yīng)用性能的方法

(1)不要使用SingleThreadModel

(2)使用線程池ThreadPool

32. EJB優(yōu)化

實體EJB:

(1)實體EJB中常用數(shù)據(jù)緩存與釋放

(2)采用延遲加載的方式裝載關(guān)聯(lián)數(shù)據(jù)

(3)盡可能地應(yīng)用CMP類型實體EJB

(4)直接采用JDBC技術(shù)處理大型數(shù)據(jù)

33. 優(yōu)化JDBC連接

(1)設(shè)置合適的預(yù)取行值

(2)采用連接池技術(shù)

(3)全合理應(yīng)用事務(wù)

(4)選擇合適的事務(wù)隔離層與及時關(guān)閉連接對象

34. PreparedStatemetn只編譯解析一次，而Statement每次都編譯解析。

35. 盡可能地做批處理更新

36. 通過采用合適的getXXX方法提高系統(tǒng)性能

37. 采用設(shè)計模式。

北大青鳥java培訓(xùn)：Java應(yīng)用的五項性能優(yōu)化技巧？

要想對Java應(yīng)用代碼進(jìn)行優(yōu)化，我們首先需要分析其具體工作原理。

事實上，影響性能優(yōu)化效果的因素多種多樣，我們需要從垃圾回收、操作系統(tǒng)設(shè)置以及虛擬機(jī)制等多個角度著眼，方可順利完成任務(wù)。

在今天的文章中，河南IT培訓(xùn)將分享五項性能優(yōu)化技巧，希望能為你的Java應(yīng)用提升工作帶來啟示。

1.從最小Heap分配入手2.使用各類Java性能工具3.使用StringBuilder而非+運(yùn)算符4.避免使用迭代器5.建立更好的并發(fā)控制機(jī)制

北大青鳥java培訓(xùn)：程序員需要關(guān)注哪些代碼優(yōu)化質(zhì)量問題？

對于程序員來說，軟件編程開發(fā)代碼質(zhì)量能夠直接反應(yīng)出一個程序員能力的高低，下面北大青鳥就一起來了解一下，在代碼質(zhì)量優(yōu)化方面，我們需要關(guān)注哪些問題。

1.吹毛求疵般地執(zhí)行編碼規(guī)范嚴(yán)格執(zhí)行代碼編寫規(guī)范，可以使一個項目乃至一個公司的代碼具有完全統(tǒng)一的風(fēng)格，就像同一個人編寫的一樣，而且命名良好的變量，函數(shù)，類和注釋，也無疑可以提高代碼的可讀性.具體落實到執(zhí)行層面，可以參照Google的編碼規(guī)范或者java官方的編碼規(guī)范，網(wǎng)上可以找到，關(guān)鍵是要嚴(yán)格遵守，并且在codereview時，嚴(yán)格要求，沒有按照規(guī)范的一定要指出并且要求修改.實際情況往往是雖然大家都知道優(yōu)秀的代碼規(guī)范是怎樣的，但在具體寫代碼的過程中，卻執(zhí)行的差強(qiáng)人意，很多情況是認(rèn)識上不夠重視，覺得一個變量或者函數(shù)的命名成哪樣關(guān)系不大，所以不夠推敲，注釋很多也都不寫，codereview的時候大家也都事不關(guān)己心態(tài)，或者覺得沒必要太摳細(xì)節(jié)，導(dǎo)致慢慢的整個codebase變得越來越差.所以這里還是要強(qiáng)調(diào)一下，細(xì)節(jié)決定成敗，提高團(tuán)隊對代碼規(guī)范的認(rèn)同及其嚴(yán)格的執(zhí)行是關(guān)鍵.2.編寫高質(zhì)量的單元測試單元測試是容易執(zhí)行，且對提高代碼質(zhì)量見效快的方法之一還。

但還是有很多公司對單元測試重視不夠，包括一些大的互聯(lián)網(wǎng)公司，不寫或者隨便寫寫。

有些工程師覺得有測試團(tuán)隊就夠了，再寫單元測試就是浪費(fèi)時間。

其實測試團(tuán)隊的測試和單元測試是在不同層面上的，測試團(tuán)隊的測試一般是黑盒測試，系統(tǒng)層面的集成測試，對于復(fù)雜系統(tǒng)來說，組合爆炸，測試團(tuán)隊無法窮舉所有的測試用例。

單元測試是代碼層面的測試，一般是針對類的測試。

既然無法從系統(tǒng)的整體上保證100%符合我們的預(yù)期，那單元測試起碼能保證我們代碼在細(xì)粒度上運(yùn)行符合預(yù)期。

有些工程師認(rèn)為開發(fā)任務(wù)重沒時間寫。

這個還是沒有足夠重視單元測試，覺得是可有可無的部分，才會有這樣的想法。

寫好單元測試，節(jié)省很多解決線上bug的時間，開發(fā)時間反而更充足了。

還有很多工程師雖然在寫單元測試，但只對正常流程做測試。

代碼中的bug多數(shù)是寫代碼時異常情況沒有考慮全面導(dǎo)致的，正常流程一般不會出問題。

單元測試的作用就在于測試各種異常情況下代碼的運(yùn)行是否符合預(yù)期，所以只對正常流程測試無法發(fā)揮單元測試真正的作用。

北大青鳥java培訓(xùn)：Java學(xué)習(xí)中代碼優(yōu)化的方法有哪些？

每個人都說代碼是程序員手中的一把雕刻刀，是對他們產(chǎn)品輪廓和細(xì)節(jié)的打磨。

每個程序員在代碼優(yōu)化方面需要做的是，即使是每天處理代碼的程序員也有很多關(guān)于他們編寫代碼的問題，所以優(yōu)化很重要。

下面廣東廣東IT培訓(xùn)為大家介紹代碼優(yōu)化的方法。

1、盡量重用目標(biāo)特別是，使用代表字符串收斂的String目標(biāo)應(yīng)該使用StringBuilder/StringBuffer。

因為Java虛擬機(jī)不僅要花時間生成目標(biāo)，而且可能還需要花時間檢索和刪除這些目標(biāo)，所以廣東計算機(jī)學(xué)院發(fā)現(xiàn)生成太多目標(biāo)會對程序的功能產(chǎn)生重大影響。

2、可以運(yùn)用局部變量調(diào)用方法時傳遞的參數(shù)和調(diào)用中創(chuàng)建的臨時變量保存在堆棧中的速度更快。

其他變量，如靜態(tài)變量、實例變量等等，在堆中創(chuàng)建，速度較慢。

此外，廣東北大青鳥發(fā)現(xiàn)在堆棧中創(chuàng)建的變量，方法的操作結(jié)束，當(dāng)這些內(nèi)容都消失了，就不需要額定廢物回收。

3、及時封閉流Java的程序編寫過程中，數(shù)據(jù)庫連接，I/O流操作必須謹(jǐn)慎，應(yīng)用結(jié)束后，應(yīng)該及時關(guān)閉發(fā)布資源。

因為廣東java培訓(xùn)發(fā)現(xiàn)這些大目標(biāo)的運(yùn)行會造成大系統(tǒng)支出，稍有不慎就會導(dǎo)致嚴(yán)重的結(jié)果。

如何優(yōu)化Java代碼

1）盡量指定類、方法的final修飾符。帶有final修飾符的類是不可派生的，Java編譯器會尋找機(jī)會內(nèi)聯(lián)所有的final方法，內(nèi)聯(lián)對于提升Java運(yùn)行效率作用重大，此舉能夠使性能平均提高50%。

2）盡量重用對象。由于Java虛擬機(jī)不僅要花時間生成對象，以后可能還需要花時間對這些對象進(jìn)行垃圾回收和處理，因此生成過多的對象將會給程序的性能帶來很大的影響。

3）盡可能使用局部變量。調(diào)用方法時傳遞的參數(shù)以及在調(diào)用中創(chuàng)建的臨時變量都保存在棧中速度較快，其他變量，如靜態(tài)變量、實例變量等，都在堆中創(chuàng)建速度較慢。

4）慎用異常。異常對性能不利，只要有異常被拋出，Java虛擬機(jī)就必須調(diào)整調(diào)用堆棧，因為在處理過程中創(chuàng)建了一個新的對象。異常只能用于錯誤處理，不應(yīng)該用來控制程序流程。

5）乘法和除法使用移位操作。用移位操作可以極大地提高性能，因為在計算機(jī)底層，對位的操作是最方便、最快的，但是移位操作雖然快，可能會使代碼不太好理解，因此最好加上相應(yīng)的注釋。

6）盡量使用HashMap、ArrayList、StringBuilder，除非線程安全需要，否則不推薦使用 Hashtable、Vector、StringBuffer，后三者由于使用同步機(jī)制而導(dǎo)致了性能開銷。

盡量在合適的場合使用單例。使用單例可以減輕加載的負(fù)擔(dān)、縮短加載的時間、提高加載的效率，但并不是所有地方都適用于單例。

如何優(yōu)化JAVA代碼及提高執(zhí)行效率

可供程序利用的資源（內(nèi)存、CPU時間、網(wǎng)絡(luò)帶寬等）是有限的，優(yōu)化的目的就是讓程序用盡可能少的資源完成預(yù)定的任務(wù)。優(yōu)化通常包含兩方面的內(nèi)容：減小代碼的體積，提高代碼的運(yùn)行效率。本文討論的主要是如何提高代碼的效率。

在Java程序中，性能問題的大部分原因并不在于Java語言，而是在于程序本身。養(yǎng)成好的代碼編寫習(xí)慣非常重要，比如正確地、巧妙地運(yùn)用java.lang.String類和java.util.Vector類，它能夠顯著地提高程序的性能。下面我們就來具體地分析一下這方面的問題。

1、 盡量指定類的final修飾符帶有final修飾符的類是不可派生的。在Java核心API中，有許多應(yīng)用final的例子，例如java.lang.String。為String類指定final防止了人們覆蓋length()方法。另外，如果指定一個類為final，則該類所有的方法都是final。Java編譯器會尋找機(jī)會內(nèi)聯(lián)（inline）所有的final方法（這和具體的編譯器實現(xiàn)有關(guān)）。此舉能夠使性能平均提高50%

。

2、 盡量重用對象。特別是String 對象的使用中，出現(xiàn)字符串連接情況時應(yīng)用StringBuffer 代替。由于系統(tǒng)不僅要花時間生成對象，以后可能還需花時間對這些對象進(jìn)行垃圾回收和處理。因此，生成過多的對象將會給程序的性能帶來很大的影響。

3、 盡量使用局部變量，調(diào)用方法時傳遞的參數(shù)以及在調(diào)用中創(chuàng)建的臨時變量都保存在棧（Stack）中，速度較快。其他變量，如靜態(tài)變量、實例變量等，都在堆（Heap）中創(chuàng)建，速度較慢。另外，依賴于具體的編譯器/JVM，局部變量還可能得到進(jìn)一步優(yōu)化。請參見《盡可能使用堆棧變量》。

4、 不要重復(fù)初始化變量 默認(rèn)情況下，調(diào)用類的構(gòu)造函數(shù)時，

Java會把變量初始化成確定的值：所有的對象被設(shè)置成null，整數(shù)變量（byte、short、int、long）設(shè)置成0，float和double變量設(shè)置成0.0，邏輯值設(shè)置成false。當(dāng)一個類從另一個類派生時，這一點(diǎn)尤其應(yīng)該注意，因為用new關(guān)鍵詞創(chuàng)建一個對象時，構(gòu)造函數(shù)鏈中的所有構(gòu)造函數(shù)都會被自動調(diào)用。

5、 在JAVA + ORACLE 的應(yīng)用系統(tǒng)開發(fā)中，java中內(nèi)嵌的SQL語句盡量使用大寫的形式，以減輕ORACLE解析器的解析負(fù)擔(dān)。

6、 Java 編程過程中，進(jìn)行數(shù)據(jù)庫連接、I/O流操作時務(wù)必小心，在使用完畢后，即使關(guān)閉以釋放資源。因為對這些大對象的操作會造成系統(tǒng)大的開銷，稍有不慎，會導(dǎo)致嚴(yán)重的后果。

7、 由于JVM的有其自身的GC機(jī)制，不需要程序開發(fā)者的過多考慮，從一定程度上減輕了開發(fā)者負(fù)擔(dān)，但同時也遺漏了隱患，過分的創(chuàng)建對象會消耗系統(tǒng)的大量內(nèi)存，嚴(yán)重時會導(dǎo)致內(nèi)存泄露，因此，保證過期對象的及時回收具有重要意義。JVM回收垃圾的條件是：對象不在被引用；然而，JVM的GC并非十分的機(jī)智，即使對象滿足了垃圾回收的條件也不一定會被立即回收。所以，建議我們在對象使用完畢，應(yīng)手動置成null。

8、 在使用同步機(jī)制時，應(yīng)盡量使用方法同步代替代碼塊同步。

9、 盡量減少對變量的重復(fù)計算

例如：for(int i = 0;i list.size; i ++) {

…

}

應(yīng)替換為：

for(int i = 0,int len = list.size();i len; i ++) {

…

}

10、盡量采用lazy loading 的策略，即在需要的時候才開始創(chuàng)建。

例如： String str = “aaa”;

if(i == 1) {

list.add(str);

}

應(yīng)替換為：

if(i == 1) {

String str = “aaa”;

list.add(str);

}

11、慎用異常

異常對性能不利。拋出異常首先要創(chuàng)建一個新的對象。Throwable接口的構(gòu)造函數(shù)調(diào)用名為fillInStackTrace()的本地（Native）方法，fillInStackTrace()方法檢查堆棧，收集調(diào)用跟蹤信息。只要有異常被拋出，VM就必須調(diào)整調(diào)用堆棧，因為在處理過程中創(chuàng)建了一個新的對象。異常只能用于錯誤處理，不應(yīng)該用來控制程序流程。

12、不要在循環(huán)中使用：

Try {

} catch() {

}

應(yīng)把其放置在最外層。

13、StringBuffer 的使用：

StringBuffer表示了可變的、可寫的字符串。

有三個構(gòu)造方法 :

StringBuffer (); //默認(rèn)分配16個字符的空間

StringBuffer (int size); //分配size個字符的空間

StringBuffer (String str); //分配16個字符+str.length()個字符空間

你可以通過StringBuffer的構(gòu)造函數(shù)來設(shè)定它的初始化容量，這樣可以明顯地提升性能。這里提到的構(gòu)造函數(shù)是StringBuffer(int

length)，length參數(shù)表示當(dāng)前的StringBuffer能保持的字符數(shù)量。你也可以使用ensureCapacity(int

minimumcapacity)方法在StringBuffer對象創(chuàng)建之后設(shè)置它的容量。首先我們看看StringBuffer的缺省行為，然后再找出一條更好的提升性能的途徑。

StringBuffer在內(nèi)部維護(hù)一個字符數(shù)組，當(dāng)你使用缺省的構(gòu)造函數(shù)來創(chuàng)建StringBuffer對象的時候，因為沒有設(shè)置初始化字符長度，StringBuffer的容量被初始化為16個字符，也就是說缺省容量就是16個字符。當(dāng)StringBuffer達(dá)到最大容量的時候，它會將自身容量增加到當(dāng)前的2倍再加2，也就是（2*舊值+2）。如果你使用缺省值，初始化之后接著往里面追加字符，在你追加到第16個字符的時候它會將容量增加到34（2*16+2），當(dāng)追加到34個字符的時候就會將容量增加到70（2*34+2）。無論何事只要StringBuffer到達(dá)它的最大容量它就不得不創(chuàng)建一個新的字符數(shù)組然后重新將舊字符和新字符都拷貝一遍――這也太昂貴了點(diǎn)。所以總是給StringBuffer設(shè)置一個合理的初始化容量值是錯不了的，這樣會帶來立竿見影的性能增益。

StringBuffer初始化過程的調(diào)整的作用由此可見一斑。所以，使用一個合適的容量值來初始化StringBuffer永遠(yuǎn)都是一個最佳的建議。

14、合理的使用Java類 java.util.Vector。

簡單地說，一個Vector就是一個java.lang.Object實例的數(shù)組。Vector與數(shù)組相似，它的元素可以通過整數(shù)形式的索引訪問。但是，Vector類型的對象在創(chuàng)建之后，對象的大小能夠根據(jù)元素的增加或者刪除而擴(kuò)展、縮小。請考慮下面這個向Vector加入元素的例子：

Object obj = new Object();

Vector v = new Vector(100000);

for(int I=0;

I100000; I++) { v.add(0,obj); }

除非有絕對充足的理由要求每次都把新元素插入到Vector的前面，否則上面的代碼對性能不利。在默認(rèn)構(gòu)造函數(shù)中，Vector的初始存儲能力是10個元素，如果新元素加入時存儲能力不足，則以后存儲能力每次加倍。Vector類就象StringBuffer類一樣，每次擴(kuò)展存儲能力時，所有現(xiàn)有的元素都要復(fù)制到新的存儲空間之中。下面的代碼片段要比前面的例子快幾個數(shù)量級：

Object obj = new Object();

Vector v = new Vector(100000);

for(int I=0; I100000; I++) { v.add(obj); }

同樣的規(guī)則也適用于Vector類的remove()方法。由于Vector中各個元素之間不能含有“空隙”，刪除除最后一個元素之外的任意其他元素都導(dǎo)致被刪除元素之后的元素向前移動。也就是說，從Vector刪除最后一個元素要比刪除第一個元素“開銷”低好幾倍。

假設(shè)要從前面的Vector刪除所有元素，我們可以使用這種代碼：

for(int I=0; I100000; I++)

{

　v.remove(0);

}

但是，與下面的代碼相比，前面的代碼要慢幾個數(shù)量級：

for(int I=0; I100000; I++)

{

　v.remove(v.size()-1);

}

從Vector類型的對象v刪除所有元素的最好方法是：

v.removeAllElements();

假設(shè)Vector類型的對象v包含字符串“Hello”?？紤]下面的代碼，它要從這個Vector中刪除“Hello”字符串：

String s = "Hello";

int i = v.indexOf(s);

if(I != -1) v.remove(s);

這些代碼看起來沒什么錯誤，但它同樣對性能不利。在這段代碼中，indexOf()方法對v進(jìn)行順序搜索尋找字符串“Hello”，remove(s)方法也要進(jìn)行同樣的順序搜索。改進(jìn)之后的版本是：

String s = "Hello";

int i = v.indexOf(s);

if(I != -1) v.remove(i);

這個版本中我們直接在remove()方法中給出待刪除元素的精確索引位置，從而避免了第二次搜索。一個更好的版本是：

String s = "Hello"; v.remove(s);

最后，我們再來看一個有關(guān)Vector類的代碼片段：

for(int I=0; I++;I v.length)

如果v包含100,000個元素，這個代碼片段將調(diào)用v.size()方法100,000次。雖然size方法是一個簡單的方法，但它仍舊需要一次方法調(diào)用的開銷，至少JVM需要為它配置以及清除堆棧環(huán)境。在這里，for循環(huán)內(nèi)部的代碼不會以任何方式修改Vector類型對象v的大小，因此上面的代碼最好改寫成下面這種形式：

int size = v.size(); for(int I=0; I++;Isize)

雖然這是一個簡單的改動，但它仍舊贏得了性能。畢竟，每一個CPU周期都是寶貴的。

15、當(dāng)復(fù)制大量數(shù)據(jù)時，使用System.arraycopy()命令。

16、代碼重構(gòu)：增強(qiáng)代碼的可讀性。

例如：

public class ShopCart {

private List carts ;

…

public void add (Object item) {

if(carts == null) {

carts = new ArrayList();

}

crts.add(item);

}

public void remove(Object item) {

if(carts. contains(item)) {

carts.remove(item);

}

}

public List getCarts() {

//返回只讀列表

return Collections.unmodifiableList(carts);

}

//不推薦這種方式

//this.getCarts().add(item);

}

17、不用new關(guān)鍵詞創(chuàng)建類的實例

用new關(guān)鍵詞創(chuàng)建類的實例時，構(gòu)造函數(shù)鏈中的所有構(gòu)造函數(shù)都會被自動調(diào)用。但如果一個對象實現(xiàn)了Cloneable接口，我們可以調(diào)用它的clone()方法。clone()方法不會調(diào)用任何類構(gòu)造函數(shù)。

在使用設(shè)計模式（Design Pattern）的場合，如果用Factory模式創(chuàng)建對象，則改用clone()方法創(chuàng)建新的對象實例非常簡單。例如，下面是Factory模式的一個典型實現(xiàn)：

public static Credit getNewCredit() {

return new Credit();

}

改進(jìn)后的代碼使用clone()方法，如下所示：

private static Credit BaseCredit = new Credit();

public static Credit getNewCredit() {

return (Credit) BaseCredit.clone();

}

上面的思路對于數(shù)組處理同樣很有用。

18、乘法和除法

考慮下面的代碼：

for (val = 0; val 100000; val +=5) {

alterX = val * 8; myResult = val * 2;

}

用移位操作替代乘法操作可以極大地提高性能。下面是修改后的代碼：

for (val = 0; val 100000; val += 5) {

alterX = val 3; myResult = val 1;

}

修改后的代碼不再做乘以8的操作，而是改用等價的左移3位操作，每左移1位相當(dāng)于乘以2。相應(yīng)地，右移1位操作相當(dāng)于除以2。值得一提的是，雖然移位操作速度快，但可能使代碼比較難于理解，所以最好加上一些注釋。

19、在JSP頁面中關(guān)閉無用的會話。

一個常見的誤解是以為session在有客戶端訪問時就被創(chuàng)建，然而事實是直到某server端程序調(diào)用HttpServletRequest.getSession(true)這樣的語句時才被創(chuàng)建，注意如果JSP沒有顯示的使用 %@pagesession="false"% 關(guān)閉session，則JSP文件在編譯成Servlet時將會自動加上這樣一條語句HttpSession

session = HttpServletRequest.getSession(true);這也是JSP中隱含的session對象的來歷。由于session會消耗內(nèi)存資源，因此，如果不打算使用session，應(yīng)該在所有的JSP中關(guān)閉它。

對于那些無需跟蹤會話狀態(tài)的頁面，關(guān)閉自動創(chuàng)建的會話可以節(jié)省一些資源。使用如下page指令：%@ page session="false"%

20、JDBC與I/O

如果應(yīng)用程序需要訪問一個規(guī)模很大的數(shù)據(jù)集，則應(yīng)當(dāng)考慮使用塊提取方式。默認(rèn)情況下，JDBC每次提取32行數(shù)據(jù)。舉例來說，假設(shè)我們要遍歷一個5000行的記錄集，JDBC必須調(diào)用數(shù)據(jù)庫157次才能提取到全部數(shù)據(jù)。如果把塊大小改成512，則調(diào)用數(shù)據(jù)庫的次數(shù)將減少到10次。

[p][/p]21、Servlet與內(nèi)存使用

許多開發(fā)者隨意地把大量信息保存到用戶會話之中。一些時候，保存在會話中的對象沒有及時地被垃圾回收機(jī)制回收。從性能上看，典型的癥狀是用戶感到系統(tǒng)周期性地變慢，卻又不能把原因歸于任何一個具體的組件。如果監(jiān)視JVM的堆空間，它的表現(xiàn)是內(nèi)存占用不正常地大起大落。

解決這類內(nèi)存問題主要有二種辦法。第一種辦法是，在所有作用范圍為會話的Bean中實現(xiàn)HttpSessionBindingListener接口。這樣，只要實現(xiàn)valueUnbound()方法，就可以顯式地釋放Bean使用的資源。另外一種辦法就是盡快地把會話作廢。大多數(shù)應(yīng)用服務(wù)器都有設(shè)置會話作廢間隔時間的選項。另外，也可以用編程的方式調(diào)用會話的setMaxInactiveInterval()方法，該方法用來設(shè)定在作廢會話之前，Servlet容器允許的客戶請求的最大間隔時間，以秒計。

22、使用緩沖標(biāo)記

一些應(yīng)用服務(wù)器加入了面向JSP的緩沖標(biāo)記功能。例如，BEA的WebLogic Server從6.0版本開始支持這個功能，Open

Symphony工程也同樣支持這個功能。JSP緩沖標(biāo)記既能夠緩沖頁面片斷，也能夠緩沖整個頁面。當(dāng)JSP頁面執(zhí)行時，如果目標(biāo)片斷已經(jīng)在緩沖之中，則生成該片斷的代碼就不用再執(zhí)行。頁面級緩沖捕獲對指定URL的請求，并緩沖整個結(jié)果頁面。對于購物籃、目錄以及門戶網(wǎng)站的主頁來說，這個功能極其有用。對于這類應(yīng)用，頁面級緩沖能夠保存頁面執(zhí)行的結(jié)果，供后繼請求使用。

23、選擇合適的引用機(jī)制

在典型的JSP應(yīng)用系統(tǒng)中，頁頭、頁腳部分往往被抽取出來，然后根據(jù)需要引入頁頭、頁腳。當(dāng)前，在JSP頁面中引入外部資源的方法主要有兩種：include指令，以及include動作。

include指令：例如%@ include file="copyright.html"

%。該指令在編譯時引入指定的資源。在編譯之前，帶有include指令的頁面和指定的資源被合并成一個文件。被引用的外部資源在編譯時就確定，比運(yùn)行時才確定資源更高效。

include動作：例如jsp:include page="copyright.jsp"

/。該動作引入指定頁面執(zhí)行后生成的結(jié)果。由于它在運(yùn)行時完成，因此對輸出結(jié)果的控制更加靈活。但時，只有當(dāng)被引用的內(nèi)容頻繁地改變時，或者在對主頁面的請求沒有出現(xiàn)之前，被引用的頁面無法確定時，使用include動作才合算。

24、及時清除不再需要的會話

為了清除不再活動的會話，許多應(yīng)用服務(wù)器都有默認(rèn)的會話超時時間，一般為30分鐘。當(dāng)應(yīng)用服務(wù)器需要保存更多會話時，如果內(nèi)存容量不足，操作系統(tǒng)會把部分內(nèi)存數(shù)據(jù)轉(zhuǎn)移到磁盤，應(yīng)用服務(wù)器也可能根據(jù)“最近最頻繁使用”（Most

Recently

Used）算法把部分不活躍的會話轉(zhuǎn)儲到磁盤，甚至可能拋出“內(nèi)存不足”異常。在大規(guī)模系統(tǒng)中，串行化會話的代價是很昂貴的。當(dāng)會話不再需要時，應(yīng)當(dāng)及時調(diào)用HttpSession.invalidate()方法清除會話。HttpSession.invalidate()方法通?？梢栽趹?yīng)用的退出頁面調(diào)用。

25、不要將數(shù)組聲明為：public static final 。

26、HashMap的遍歷效率討論

經(jīng)常遇到對HashMap中的key和value值對的遍歷操作，有如下兩種方法：MapString, String[] paraMap = new HashMapString, String[]();

................//第一個循環(huán)

SetString appFieldDefIds = paraMap.keySet();

for (String appFieldDefId : appFieldDefIds) {

String[] values = paraMap.get(appFieldDefId);

......

}

//第二個循環(huán)

for(EntryString, String[] entry : paraMap.entrySet()){

String appFieldDefId = entry.getKey();

String[] values = entry.getValue();

.......

}

第一種實現(xiàn)明顯的效率不如第二種實現(xiàn)。

分析如下 SetString appFieldDefIds = paraMap.keySet(); 是先從HashMap中取得keySet

代碼如下：

public SetK keySet() {

SetK ks = keySet;

return (ks != null ? ks : (keySet = new KeySet()));

}

private class KeySet extends AbstractSetK {

public IteratorK iterator() {

return newKeyIterator();

}

public int size() {

return size;

}

public boolean contains(Object o) {

return containsKey(o);

}

public boolean remove(Object o) {

return HashMap.this.removeEntryForKey(o) != null;

}

public void clear() {

HashMap.this.clear();

}

}

其實就是返回一個私有類KeySet, 它是從AbstractSet繼承而來，實現(xiàn)了Set接口。

再來看看for/in循環(huán)的語法

for(declaration : expression_r)

statement

在執(zhí)行階段被翻譯成如下各式

for(IteratorE #i = (expression_r).iterator(); #i.hashNext();){

declaration = #i.next();

statement

}

因此在第一個for語句for (String appFieldDefId : appFieldDefIds) 中調(diào)用了HashMap.keySet().iterator() 而這個方法調(diào)用了newKeyIterator()

IteratorK newKeyIterator() {

return new KeyIterator();

}

private class KeyIterator extends HashIteratorK {

public K next() {

return nextEntry().getKey();

}

}

所以在for中還是調(diào)用了

在第二個循環(huán)for(EntryString, String[] entry : paraMap.entrySet())中使用的Iterator是如下的一個內(nèi)部類

private class EntryIterator extends HashIteratorMap.EntryK,V {

public Map.EntryK,V next() {

return nextEntry();

}

}

此時第一個循環(huán)得到key，第二個循環(huán)得到HashMap的Entry

效率就是從循環(huán)里面體現(xiàn)出來的第二個循環(huán)此致可以直接取key和value值

而第一個循環(huán)還是得再利用HashMap的get(Object key)來取value值

現(xiàn)在看看HashMap的get(Object key)方法

public V get(Object key) {

Object k = maskNull(key);

int hash = hash(k);

int i = indexFor(hash, table.length); //Entry[] table

EntryK,V e = table;

while (true) {

if (e == null)

return null;

if (e.hash == hash eq(k, e.key))

return e.value;

e = e.next;

}

}

其實就是再次利用Hash值取出相應(yīng)的Entry做比較得到結(jié)果，所以使用第一中循環(huán)相當(dāng)于兩次進(jìn)入HashMap的Entry中

而第二個循環(huán)取得Entry的值之后直接取key和value，效率比第一個循環(huán)高。其實按照Map的概念來看也應(yīng)該是用第二個循環(huán)好一點(diǎn)，它本來就是key和value的值對，將key和value分開操作在這里不是個好選擇。

分享題目：java中優(yōu)化代碼 java代碼優(yōu)化的方法和準(zhǔn)則
鏈接地址：http://m.rwnh.cn/article40/hichho.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供企業(yè)建站、搜索引擎優(yōu)化、微信公眾號、網(wǎng)站制作、網(wǎng)站內(nèi)鏈、網(wǎng)站排名

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點(diǎn)不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)