1_代碼重構(gòu)漫畫.jpeg
酉陽土家族苗族網(wǎng)站建設(shè)公司創(chuàng)新互聯(lián),酉陽土家族苗族網(wǎng)站設(shè)計制作，有大型網(wǎng)站制作公司豐富經(jīng)驗。已為酉陽土家族苗族1000多家提供企業(yè)網(wǎng)站建設(shè)服務(wù)。企業(yè)網(wǎng)站搭建\外貿(mào)網(wǎng)站制作要多少錢，請找那個售后服務(wù)好的酉陽土家族苗族做網(wǎng)站的公司定做！
項目在不斷演進過程中，代碼不停地在堆砌。如果沒有人為代碼的質(zhì)量負(fù)責(zé)，代碼總是會往越來越混亂的方向演進。當(dāng)混亂到一定程度之后，量變引起質(zhì)變，項目的維護成本已經(jīng)高過重新開發(fā)一套新代碼的成本，想要再去重構(gòu)，已經(jīng)沒有人能做到了。
造成這樣的原因往往有以下幾點：
對于此類問題，業(yè)界已有有很好的解決思路：通過持續(xù)不斷的重構(gòu)將代碼中的“壞味道”清除掉。
重構(gòu)一書的作者Martin Fowler對重構(gòu)的定義：
根據(jù)重構(gòu)的規(guī)模可以大致分為大型重構(gòu)和小型重構(gòu)：
大型重構(gòu) ：對頂層代碼設(shè)計的重構(gòu)，包括：系統(tǒng)、模塊、代碼結(jié)構(gòu)、類與類之間的關(guān)系等的重構(gòu)，重構(gòu)的手段有：分層、模塊化、解耦、抽象可復(fù)用組件等等。這類重構(gòu)的工具就是我們學(xué)習(xí)過的那些設(shè)計思想、原則和模式。這類重構(gòu)涉及的代碼改動會比較多，影響面會比較大，所以難度也較大，耗時會比較長，引入bug的風(fēng)險也會相對比較大。
小型重構(gòu) ：對代碼細(xì)節(jié)的重構(gòu)，主要是針對類、函數(shù)、變量等代碼級別的重構(gòu)，比如規(guī)范命名和注釋、消除超大類或函數(shù)、提取重復(fù)代碼等等。小型重構(gòu)更多的是使用統(tǒng)一的編碼規(guī)范。這類重構(gòu)要修改的地方比較集中，比較簡單，可操作性較強，耗時會比較短，引入bug的風(fēng)險相對來說也會比較小。什么時候重構(gòu) 新功能開發(fā)、修bug或者代碼review中出現(xiàn)“代碼壞味道”，我們就應(yīng)該及時進行重構(gòu)。持續(xù)在日常開發(fā)中進行小重構(gòu)，能夠降低重構(gòu)和測試的成本。
2_代碼常見問題.png
代碼重復(fù)
方法過長
過大的類
邏輯分散
嚴(yán)重的情結(jié)依戀
數(shù)據(jù)泥團/基本類型偏執(zhí)
不合理的繼承體系
過多的條件判斷
過長的參數(shù)列
臨時變量過多
令人迷惑的暫時字段
純數(shù)據(jù)類
不恰當(dāng)?shù)拿?/p>
過多的注釋
3_代碼質(zhì)量如何衡量.jpg
代碼質(zhì)量的評價有很強的主觀性，描述代碼質(zhì)量的詞匯也有很多，比如可讀性、可維護性、靈活、優(yōu)雅、簡潔。這些詞匯是從不同的維度去評價代碼質(zhì)量的。其中，可維護性、可讀性、可擴展性又是提到最多的、最重要的三個評價標(biāo)準(zhǔn)。
要寫出高質(zhì)量代碼，我們就需要掌握一些更加細(xì)化、更加能落地的編程方法論，這就包含面向?qū)ο笤O(shè)計思想、設(shè)計原則、設(shè)計模式、編碼規(guī)范、重構(gòu)技巧等。
4_SOLID原則.png
一個類只負(fù)責(zé)完成一個職責(zé)或者功能，不要存在多于一種導(dǎo)致類變更的原因。
單一職責(zé)原則通過避免設(shè)計大而全的類，避免將不相關(guān)的功能耦合在一起，來提高類的內(nèi)聚性。同時，類職責(zé)單一，類依賴的和被依賴的其他類也會變少，減少了代碼的耦合性，以此來實現(xiàn)代碼的高內(nèi)聚、松耦合。但是，如果拆分得過細(xì)，實際上會適得其反，反倒會降低內(nèi)聚性，也會影響代碼的可維護性。
添加一個新的功能，應(yīng)該是通過在已有代碼基礎(chǔ)上擴展代碼（新增模塊、類、方法、屬性等），而非修改已有代碼（修改模塊、類、方法、屬性等）的方式來完成。
開閉原則并不是說完全杜絕修改，而是以最小的修改代碼的代價來完成新功能的開發(fā)。
很多設(shè)計原則、設(shè)計思想、設(shè)計模式，都是以提高代碼的擴展性為最終目的的。特別是 23 種經(jīng)典設(shè)計模式，大部分都是為了解決代碼的擴展性問題而總結(jié)出來的，都是以開閉原則為指導(dǎo)原則的。最常用來提高代碼擴展性的方法有：多態(tài)、依賴注入、基于接口而非實現(xiàn)編程，以及大部分的設(shè)計模式（比如，裝飾、策略、模板、職責(zé)鏈、狀態(tài)）。
子類對象（object of subtype/derived class）能夠替換程序（program）中父類對象（object of base/parent class）出現(xiàn)的任何地方，并且保證原來程序的邏輯行為（behavior）不變及正確性不被破壞。
子類可以擴展父類的功能，但不能改變父類原有的功能
調(diào)用方不應(yīng)該依賴它不需要的接口；一個類對另一個類的依賴應(yīng)該建立在最小的接口上。接口隔離原則提供了一種判斷接口的職責(zé)是否單一的標(biāo)準(zhǔn)：通過調(diào)用者如何使用接口來間接地判定。如果調(diào)用者只使用部分接口或接口的部分功能，那接口的設(shè)計就不夠職責(zé)單一。
高層模塊不應(yīng)該依賴低層模塊，二者都應(yīng)該依賴其抽象；抽象不應(yīng)該依賴細(xì)節(jié)，細(xì)節(jié)應(yīng)該依賴抽象。
一個對象應(yīng)該對其他對象保持最少的了解
盡量使用合成/聚合的方式，而不是使用繼承。
單一職責(zé)原則告訴我們實現(xiàn)類要職責(zé)單一；里氏替換原則告訴我們不要破壞繼承體系；依賴倒置原則告訴我們要面向接口編程；接口隔離原則告訴我們在設(shè)計接口的時候要精簡單一；迪米特法則告訴我們要降低耦合。而開閉原則是總綱，告訴我們要對擴展開放，對修改關(guān)閉。
image.png
模塊結(jié)構(gòu)說明
代碼開發(fā)要遵守各層的規(guī)范，并注意層級之間的依賴關(guān)系。
多個方法代碼重復(fù)、方法中代碼過長或者方法中的語句不在一個抽象層級。
方法是代碼復(fù)用的最小粒度，方法過長不利于復(fù)用，可讀性低，提煉方法往往是重構(gòu)工作的第一步。
意圖導(dǎo)向編程 ：把處理某件事的流程和具體做事的實現(xiàn)方式分開。
將函數(shù)放進一個單獨對象中，如此一來局部變量就變成了對象內(nèi)的字段。然后你可以在同一個對象中將這個大型函數(shù)分解為多個小型函數(shù)。
方法參數(shù)比較多時，將參數(shù)封裝為參數(shù)對象
任何有返回值的方法，都不應(yīng)該有副作用
臨時變量僅使用一次或者取值邏輯成本很低的情況下
將復(fù)雜表達式（或其中一部分）的結(jié)果放進一個臨時變量，以此變量名稱來解釋表達式用途
把復(fù)雜的條件表達式拆分成多個條件表達式，減少嵌套。嵌套了好幾層的if - then-else語句，轉(zhuǎn)換為多個if語句
當(dāng)出現(xiàn)大量類型檢查和判斷時，if else（或switch）語句的體積會比較臃腫，這無疑降低了代碼的可讀性。 另外，if else（或switch）本身就是一個“變化點”，當(dāng)需要擴展新的類型時，我們不得不追加if else（或switch）語句塊，以及相應(yīng)的邏輯，這無疑降低了程序的可擴展性，也違反了面向?qū)ο蟮拈_閉原則。
非正常業(yè)務(wù)狀態(tài)的處理，使用拋出異常的方式代替返回錯誤碼
某一段代碼需要對程序狀態(tài)做出某種假設(shè)，以斷言明確表現(xiàn)這種假設(shè)。
當(dāng)使用一個方法返回的對象時，而這個對象可能為空，這個時候需要對這個對象進行操作前，需要進行判空，否則就會報空指針。當(dāng)這種判斷頻繁的出現(xiàn)在各處代碼之中，就會影響代碼的美觀程度和可讀性，甚至增加Bug的幾率。
空引用的問題在Java中無法避免，但可以通過代碼編程技巧（引入空對象）來改善這一問題。
根據(jù)單一職責(zé)原則，一個類應(yīng)該有明確的責(zé)任邊界。但在實際工作中，類會不斷的擴展。當(dāng)給某個類添加一項新責(zé)任時，你會覺得不值得分離出一個單獨的類。于是，隨著責(zé)任不斷增加，這個類包含了大量的數(shù)據(jù)和函數(shù)，邏輯復(fù)雜不易理解。
此時你需要考慮將哪些部分分離到一個單獨的類中，可以依據(jù)高內(nèi)聚低耦合的原則。如果某些數(shù)據(jù)和方法總是一起出現(xiàn)，或者某些數(shù)據(jù)經(jīng)常同時變化，這就表明它們應(yīng)該放到一個類中。另一種信號是類的子類化方式：如果你發(fā)現(xiàn)子類化只影響類的部分特性，或者類的特性需要以不同方式來子類化，這就意味著你需要分解原來的類。
繼承使實現(xiàn)代碼重用的有力手段，但這并非總是完成這項工作的最佳工具，使用不當(dāng)會導(dǎo)致軟件變得很脆弱。與方法調(diào)用不同的是，繼承打破了封裝性。子類依賴于其父類中特定功能的實現(xiàn)細(xì)節(jié)，如果父類的實現(xiàn)隨著發(fā)行版本的不同而變化，子類可能會遭到破壞，即使他的代碼完全沒有改變。
舉例說明，假設(shè)有一個程序使用HashSet，為了調(diào)優(yōu)該程序的性能，需要統(tǒng)計HashSet自從它創(chuàng)建以來添加了多少個元素。為了提供該功能，我們編寫一個HashSet的變體。
通過在新的類中增加一個私有域，它引用現(xiàn)有類的一個實例，這種設(shè)計被稱為組合，因為現(xiàn)有的類變成了新類的一個組件。這樣得到的類將會非常穩(wěn)固，它不依賴現(xiàn)有類的實現(xiàn)細(xì)節(jié)。即使現(xiàn)有的類添加了新的方法，也不會影響新的類。許多設(shè)計模式使用就是這種套路，比如代理模式、裝飾者模式
繼承與組合如何取舍
Java提供了兩種機制，可以用來定義允許多個實現(xiàn)的類型：接口和抽象類。自從Java8為接口增加缺省方法（default method），這兩種機制都允許為實例方法提供實現(xiàn)。主要區(qū)別在于，為了實現(xiàn)由抽象類定義的類型，類必須稱為抽象類的一個子類。因為Java只允許單繼承，所以用抽象類作為類型定義受到了限制。
接口相比于抽象類的優(yōu)勢：
接口雖然提供了缺省方法，但接口仍有有以下局限性：
接口缺省方法的設(shè)計目的和優(yōu)勢在于：
為了接口的演化
可以減少第三方工具類的創(chuàng)建
可以避免創(chuàng)建基類
由于接口的局限性和設(shè)計目的的不同，接口并不能完全替換抽象類。但是通過對接口提供一個抽象的骨架實現(xiàn)類，可以把接口和抽象類的優(yōu)點結(jié)合起來。 接口負(fù)責(zé)定義類型，或許還提供一些缺省方法，而骨架實現(xiàn)類則負(fù)責(zé)實現(xiàn)除基本類型接口方法之外，剩下的非基本類型接口方法。擴展骨架實現(xiàn)占了實現(xiàn)接口之外的大部分工作。這就是模板方法（Template Method）設(shè)計模式。
Image [5].png
接口Protocol：定義了RPC協(xié)議層兩個主要的方法，export暴露服務(wù)和refer引用服務(wù)
抽象類AbstractProtocol：封裝了暴露服務(wù)之后的Exporter和引用服務(wù)之后的Invoker實例，并實現(xiàn)了服務(wù)銷毀的邏輯
具體實現(xiàn)類XxxProtocol：實現(xiàn)export暴露服務(wù)和refer引用服務(wù)具體邏輯
由于為了保持Java代碼的兼容性，支持和原生態(tài)類型轉(zhuǎn)換，并使用擦除機制實現(xiàn)的泛型。但是使用原生態(tài)類型就會失去泛型的優(yōu)勢，會受到編譯器警告。
每一條警告都表示可能在運行時拋出ClassCastException異常。要盡最大的努力去消除這些警告。如果無法消除但是可以證明引起警告的代碼是安全的，就可以在盡可能小的范圍中，使用＠SuppressWarnings("unchecked")注解來禁止警告，但是要把禁止的原因記錄下來。
參數(shù)化類型不支持協(xié)變的，即對于任何兩個不同的類型Type1和Type2而言，List既不是List的子類型，也不是它的超類。為了解決這個問題，提高靈活性，Java提供了一種特殊的參數(shù)化類型，稱作有限制的通配符類型，即List? extends E和List? super E。使用原則是producer-extends，consumer-super（PECS）。如果即是生產(chǎn)者，又是消費者，就沒有必要使用通配符了。
還有一種特殊的無限制通配符List?，表示某種類型但不確定。常用作泛型的引用，不可向其添加除Null以外的任何對象。
嵌套類（nested class）是指定義在另一個類的內(nèi)部的類。 嵌套類存在的目的只是為了它的外部類提供服務(wù)，如果其他的環(huán)境也會用到的話，應(yīng)該成為一個頂層類（top-level class）。 嵌套類有四種：靜態(tài)成員類（static member class）、非靜態(tài)成員類（nonstatic member class）、匿名類（anonymous class）和 局部類（local class）。除了第一種之外，其他三種都稱為內(nèi)部類（inner class）。
總而言之，這四種嵌套類都有自己的用途。假設(shè)這個嵌套類屬于一個方法的內(nèi)部，如果只需要在一個地方創(chuàng)建實例，并且已經(jīng)有了一個預(yù)置的類型可以說明這個類的特征，就要把它做成匿名類。如果一個嵌套類需要在單個方法之外仍然可見，或者它太長了，不適合放在方法內(nèi)部，就應(yīng)該使用成員類。如果成員類的每個實例都需要一個指向其外圍實例的引用，就要把成員類做成非靜態(tài)的，否則就做成靜態(tài)的。
通過對常見場景的代碼邏輯進行抽象封裝，形成相應(yīng)的模板工具類，可以大大減少重復(fù)代碼，專注于業(yè)務(wù)邏輯，提高代碼質(zhì)量。
面向?qū)ο缶幊滔鄬τ诿嫦蜻^程，多了實例化這一步，而對象的創(chuàng)建必須要指定具體類型。我們常見的做法是“哪里用到，就在哪里創(chuàng)建”，使用實例和創(chuàng)建實例的是同一段代碼。這似乎使代碼更具有可讀性，但是某些情況下造成了不必要的耦合。
對于頂層的（非嵌套的）類和接口，只有兩種的訪問級別：包級私有的（沒有public修飾）和公有的（public修飾）。
對于成員（實例/域、方法、嵌套類和嵌套接口）由四種的訪問級別，可訪問性如下遞增：
正確地使用這些修飾符對于實現(xiàn)信息隱藏是非常關(guān)鍵的，原則就是：盡可能地使每個類和成員不被外界訪問（私有或包級私有）。這樣好處就是在以后的發(fā)行版本中，可以對它進行修改、替換或者刪除，而無須擔(dān)心會影響現(xiàn)有的客戶端程序。
不可變類是指其實例不能被修改的類。每個實例中包含的所有信息都必須在創(chuàng)建該實例時提供，并在對象的整個生命周期內(nèi)固定不變。不可變類好處就是簡單易用、線程安全、可自由共享而不容易出錯。Java平臺類庫中包含許多不可變的類，比如String、基本類型包裝類、BigDecimal等。
為了使類成為不可變，要遵循下面五條規(guī)則：
可變性最小化的一些建議：
TDD的最終目標(biāo)是整潔可用的代碼（clean code that works）。大多數(shù)的開發(fā)者大部分時間無法得到整潔可用的代碼。辦法是分而治之。首先解決目標(biāo)中的“可用”問題，然后再解決“代碼的整潔”問題。這與體系結(jié)構(gòu)驅(qū)動（architecture-driven）的開發(fā)相反。
采用TDD另一個好處就是讓我們擁有一套伴隨代碼產(chǎn)生的詳盡的自動化測試集。將來無論出于任何原因（需求、重構(gòu)、性能改進）需要對代碼進行維護時，在這套測試集的驅(qū)動下工作，我們代碼將會一直是健壯的。
Image [6].png
添加一個測試 - 運行所有測試并檢查測試結(jié)果 - 編寫代碼以通過測試 - 運行所有測試且全部通過 - 重構(gòu)代碼，以消除重復(fù)設(shè)計，優(yōu)化設(shè)計結(jié)構(gòu)
作者：VectorJin
重構(gòu)可以說是覆蓋,用覆蓋一詞來講就比較清楚。
在面向?qū)ο蟮囊粋€特性--繼承中就表現(xiàn)出重構(gòu)的意思。
重構(gòu)，就是繼承于父類方法的子類將子類的方法重寫，方法名及參數(shù)完全相同.
重用是繼承了就可以用父類定義的方法和變量，不用再定義一次。
比如說
class B {
public void see(){
System.out.println("this is b");
}
}
public class A extends B{
public void see() {
System.out.println("this is a");
}
public static void main(String[] args) {
B b=new A();
b.see();
}
}
這是重構(gòu)的意思。
class B {
public void see(){
System.out.println("this is b");
}
}
public class A extends B{
public static void main(String[] args) {
B b=new A();
b.see();
}
}
這是重用的意思
java重構(gòu)：指程序員對已有程序在盡量不改變接口的前提下，進行重新編寫代碼的工作，一般有以下幾方面：
1、去除已知bug。
2、提高程序運行效率。
3、增加新的功能。
重構(gòu)舉例：（簡化代碼、提升效率）
重構(gòu)前：
if(list != null list.size() 0){
for(int i = 0; i list.size(); i++){
//skip...
}
}
重構(gòu)后
if(list != null){
for(int i = 0, len = list.size(); i len; i++){
//skip...
}
}
java重構(gòu)：指程序員對已有程序在盡量不改變接口的前提下，進行重新編寫代碼的工作，一般有以下幾方面：
1、去除已知bug。
2、提高程序運行效率。
3、增加新的功能。
重構(gòu)舉例：（簡化代碼、提升效率）
重構(gòu)前：
if(list != null list.size() 0){
for(int i = 0; i list.size(); i++){
//skip... ?}}
重構(gòu)后
if(list != null){
for(int i = 0, len = list.size(); i len; i++){
//skip... ?}}
1、 盡量指定類的final修飾符 帶有final修飾符的類是不可派生的。
在Java核心API中，有許多應(yīng)用final的例子，例如java.lang.String。為String類指定final防止了人們覆蓋length()方法。另外，如果指定一個類為final，則該類所有的方法都是final。Java編譯器會尋找機會內(nèi)聯(lián)（inline）所有的final方法（這和具體的編譯器實現(xiàn)有關(guān)）。此舉能夠使性能平均提高50% 。
2、 盡量重用對象。
特別是String 對象的使用中，出現(xiàn)字符串連接情況時應(yīng)用StringBuffer 代替。由于系統(tǒng)不僅要花時間生成對象，以后可能還需花時間對這些對象進行垃圾回收和處理。因此，生成過多的對象將會給程序的性能帶來很大的影響。
3、 盡量使用局部變量，調(diào)用方法時傳遞的參數(shù)以及在調(diào)用中創(chuàng)建的臨時變量都保存在棧（Stack）中，速度較快。
其他變量，如靜態(tài)變量、實例變量等，都在堆（Heap）中創(chuàng)建，速度較慢。另外，依賴于具體的編譯器/JVM，局部變量還可能得到進一步優(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)一個類從另一個類派生時，這一點尤其應(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 編程過程中，進行數(shù)據(jù)庫連接、I/O流操作時務(wù)必小心，在使用完畢后，即使關(guān)閉以釋放資源。
因為對這些大對象的操作會造成系統(tǒng)大的開銷，稍有不慎，會導(dǎo)致嚴(yán)重的后果。
7、 由于JVM的有其自身的GC機制，不需要程序開發(fā)者的過多考慮，從一定程度上減輕了開發(fā)者負(fù)擔(dān)，但同時也遺漏了隱患，過分的創(chuàng)建對象會消耗系統(tǒng)的大量內(nèi)存，嚴(yán)重時會導(dǎo)致內(nèi)存泄露，因此，保證過期對象的及時回收具有重要意義。
JVM回收垃圾的條件是：對象不在被引用；然而，JVM的GC并非十分的機智，即使對象滿足了垃圾回收的條件也不一定會被立即回收。所以，建議我們在對象使用完畢，應(yīng)手動置成null。
8、 在使用同步機制時，應(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)部維護一個字符數(shù)組，當(dāng)你使用缺省的構(gòu)造函數(shù)來創(chuàng)建StringBuffer對象的時候，因為沒有設(shè)置初始化字符長度，StringBuffer的容量被初始化為16個字符，也就是說缺省容量就是16個字符。當(dāng)StringBuffer達到最大容量的時候，它會將自身容量增加到當(dāng)前的2倍再加2，也就是（2*舊值+2）。如果你使用缺省值，初始化之后接著往里面追加字符，在你追加到第16個字符的時候它會將容量增加到34（2*16+2），當(dāng)追加到34個字符的時候就會將容量增加到70（2*34+2）。無論何事只要StringBuffer到達它的最大容量它就不得不創(chuàng)建一個新的字符數(shù)組然后重新將舊字符和新字符都拷貝一遍――這也太昂貴了點。所以總是給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ù)元素的增加或者刪除而擴展、縮小。請考慮下面這個向Vector加入元素的例子：
Object bj = 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類一樣，每次擴展存儲能力時，所有現(xiàn)有的元素都要復(fù)制到新的存儲空間之中。下面的代碼片段要比前面的例子快幾個數(shù)量級：
Object bj = 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進行順序搜索尋找字符串“Hello”，remove(s)方法也要進行同樣的順序搜索。改進之后的版本是：
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()命令。
int[] src={1,3,5,6,7,8};
int[] dest = new int[6];
System.arraycopy(src, 0, dest, 0, 6);
src:源數(shù)組; srcPos:源數(shù)組要復(fù)制的起始位置;
dest:目的數(shù)組; destPos:目的數(shù)組放置的起始位置;
length:復(fù)制的長度.
注意：src and dest都必須是同類型或者可以進行轉(zhuǎn)換類型的數(shù)組．
16、代碼重構(gòu)：增強代碼的可讀性。
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();
}
改進后的代碼使用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沒有顯示的使用 關(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次。
21、Servlet與內(nèi)存使用
許多開發(fā)者隨意地把大量信息保存到用戶會話之中。一些時候，保存在會話中的對象沒有及時地被垃圾回收機制回收。從性能上看，典型的癥狀是用戶感到系統(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、選擇合適的引用機制
在典型的JSP應(yīng)用系統(tǒng)中，頁頭、頁腳部分往往被抽取出來，然后根據(jù)需要引入頁頭、頁腳。當(dāng)前，在JSP頁面中引入外部資源的方法主要有兩種：include指令，以及include動作。
include指令：例如%@ include file="copyright.html" %。該指令在編譯時引入指定的資源。在編譯之前，帶有include指令的頁面和指定的資源被合并成一個文件。被引用的外部資源在編譯時就確定，比運行時才確定資源更高效。
include動作：例如jsp:include page="copyright.jsp" /。該動作引入指定頁面執(zhí)行后生成的結(jié)果。由于它在運行時完成，因此對輸出結(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)
statement
在執(zhí)行階段被翻譯成如下各式
for(IteratorE #i = (expression).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)于兩次進入HashMap的Entry
中而第二個循環(huán)取得Entry的值之后直接取key和value，效率比第一個循環(huán)高。其實按照Map的概念來看也應(yīng)該是用第二個循環(huán)好一點，它本來就是key和value的值對，將key和value分開操作在這里不是個好選擇。
27、array(數(shù)組) 和 ArryList的使用
array（[]）：最高效；但是其容量固定且無法動態(tài)改變；
ArrayList：容量可動態(tài)增長；但犧牲效率；
基于效率和類型檢驗，應(yīng)盡可能使用array，無法確定數(shù)組大小時才使用ArrayList！
ArrayList是Array的復(fù)雜版本
ArrayList內(nèi)部封裝了一個Object類型的數(shù)組，從一般的意義來說，它和數(shù)組沒有本質(zhì)的差別，甚至于ArrayList的許多方法，如Index、IndexOf、Contains、Sort等都是在內(nèi)部數(shù)組的基礎(chǔ)上直接調(diào)用Array的對應(yīng)方法。
ArrayList存入對象時，拋棄類型信息，所有對象屏蔽為Object，編譯時不檢查類型，但是運行時會報錯。
注：jdk5中加入了對泛型的支持，已經(jīng)可以在使用ArrayList時進行類型檢查。
從這一點上看來，ArrayList與數(shù)組的區(qū)別主要就是由于動態(tài)增容的效率問題了
28、盡量使用HashMap 和ArrayList ,除非必要，否則不推薦使用HashTable和Vector ，后者由于使用同步機制，而導(dǎo)致了性能的開銷。
29、StringBuffer 和StringBuilder的區(qū)別：
java.lang.StringBuffer線程安全的可變字符序列。一個類似于 String 的字符串緩沖區(qū)，但不能修改。
StringBuilder。與該類相比，通常應(yīng)該優(yōu)先使用 java.lang.StringBuilder類，因為它支持所有相同的操作，但由于它不執(zhí)行同步，所以速度更快。為了獲得更好的性能，在構(gòu)造 StirngBuffer 或 StirngBuilder 時應(yīng)盡可能指定它的容量。當(dāng)然，如果你操作的字符串長度不超過 16 個字符就不用了。 相同情況下使用 StirngBuilder 相比使用 StringBuffer 僅能獲得 10%-15% 左右的性能提升，但卻要冒多線程不安全的風(fēng)險。而在現(xiàn)實的模塊化編程中，負(fù)責(zé)某一模塊的程序員不一定能清晰地判斷該模塊是否會放入多線程的環(huán)境中運行，因此：除非你能確定你的系統(tǒng)的瓶頸是在 StringBuffer 上，并且確定你的模塊不會運行在多線程模式下，否則還是用 StringBuffer 吧。
30、盡量避免使用split
除非是必須的，否則應(yīng)該避免使用split，split由于支持正則表達式，所以效率比較低，如果是頻繁的幾十，幾百萬的調(diào)用將會耗費大量資源，如果確實需要頻繁的調(diào)用split，可以考慮使用apache的 StringUtils.split(string,char)，頻繁split的可以緩存結(jié)果。
其他補充:
1、及時清除不再使用的對象，設(shè)為null
2、盡可能使用final,static等關(guān)鍵字
3、盡可能使用buffered對象
如何優(yōu)化代碼使JAVA源文件及編譯后CLASS文件更小
1 盡量使用繼承，繼承的方法越多，你要寫的代碼量也就越少
2 打開JAVA編譯器的優(yōu)化選項： javac -O 這個選項將刪除掉CLASS文件中的行號，并能把
一些private, static,final的小段方法申明為inline方法調(diào)用
3 把公用的代碼提取出來
4 不要初始化很大的數(shù)組，盡管初始化一個數(shù)組在JAVA代碼中只是一行的代碼量，但
編譯后的代碼是一行代碼插入一個數(shù)組的元素，所以如果你有大量的數(shù)據(jù)需要存在數(shù)組
中的話，可以先把這些數(shù)據(jù)放在String中，然后在運行期把字符串解析到數(shù)組中
5 日期類型的對象會占用很大的空間，如果你要存儲大量的日期對象，可以考慮把它存儲為
long型，然后在使用的時候轉(zhuǎn)換為Date類型
6 類名，方法名和變量名盡量使用簡短的名字，可以考慮使用Hashjava, Jobe, Obfuscate and Jshrink等工具自動完成這個工作
7 將static final類型的變量定義到Interface中去
8 算術(shù)運算 能用左移/右移的運算就不要用*和/運算，相同的運算不要運算多次
2. 不要兩次初始化變量
Java通過調(diào)用獨特的類構(gòu)造器默認(rèn)地初始化變量為一個已知的值。所有的對象被設(shè)置成null，integers (byte, short, int, long)被設(shè)置成0，float和double設(shè)置成0.0，Boolean變量設(shè)置成false。這對那些擴展自其它類的類尤其重要，這跟使用一個新的關(guān)鍵詞創(chuàng)建一個對象時所有一連串的構(gòu)造器被自動調(diào)用一樣。
3. 在任何可能的地方讓類為Final
標(biāo)記為final的類不能被擴展。在《核心Java API》中有大量這個技術(shù)的例子，諸如java.lang.String。將String類標(biāo)記為final阻止了開發(fā)者創(chuàng)建他們自己實現(xiàn)的長度方法。
更深入點說，如果類是final的，所有類的方法也是final的。Java編譯器可能會內(nèi)聯(lián)所有的方法（這依賴于編譯器的實現(xiàn)）。在我的測試?yán)?，我已?jīng)看到性能平均增加了50%。
9. 異常在需要拋出的地方拋出，try catch能整合就整合
try {
some.method1(); // Difficult for javac
} catch( method1Exception e ) { // and the JVM runtime
// Handle exception 1 // to optimize this
} // code
try {
some.method2();
} catch( method2Exception e ) {
// Handle exception 2
}
try {
some.method3();
} catch( method3Exception e ) {
// Handle exception 3
}
已下代碼 更容易被編譯器優(yōu)化
try {
some.method1(); // Easier to optimize
some.method2();
some.method3();
} catch( method1Exception e ) {
// Handle exception 1
} catch( method2Exception e ) {
// Handle exception 2
} catch( method3Exception e ) {
// Handle exception 3
}
10. For循環(huán)的優(yōu)化
Replace…
for( int i = 0; i collection.size(); i++ ) {
...
}
with…
for( int i = 0, n = collection.size(); i n; i++ ) {
...
}
5、 在JAVA + ORACLE 的應(yīng)用系統(tǒng)開發(fā)中，java中內(nèi)嵌的SQL語句盡量使用大寫的形式，以減輕ORACLE解析器的解析負(fù)擔(dān)。
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);
}
12、不要在循環(huán)中使用：
Try {
} catch() {
}
應(yīng)把其放置在最外層
首先，重構(gòu)這個概念，不是JAVA所特有的，而是軟件工程的一個概念。
主要是指改善現(xiàn)有的程序代碼，使其更方便、簡單的使用，提高可重用性、可維護性。
在面向?qū)ο驝++\C#\JAVA等語言中，重構(gòu)的概念一般是指對類進行重構(gòu)，一般在現(xiàn)有類的某些功能方法不能滿足擴展需要，或者修復(fù)BUG時，就需要重構(gòu)
重構(gòu)是一個可迭代的過程，可以對一個功能重復(fù)重構(gòu)，直到其滿足軟件的需求、維護和可擴展性
重構(gòu)的方法比較多，一本書也說不完，一些概念性的內(nèi)容見百科
重慶分公司
重慶分公司
