Java中使代碼對齊的快捷鍵是什么

Ctrl+Shift+F 格式化當(dāng)前代碼

成都創(chuàng)新互聯(lián)自成立以來，一直致力于為企業(yè)提供從網(wǎng)站策劃、網(wǎng)站設(shè)計、成都網(wǎng)站建設(shè)、網(wǎng)站制作、電子商務(wù)、網(wǎng)站推廣、網(wǎng)站優(yōu)化到為企業(yè)提供個性化軟件開發(fā)等基于互聯(lián)網(wǎng)的全面整合營銷服務(wù)。公司擁有豐富的網(wǎng)站建設(shè)和互聯(lián)網(wǎng)應(yīng)用系統(tǒng)開發(fā)管理經(jīng)驗、成熟的應(yīng)用系統(tǒng)解決方案、優(yōu)秀的網(wǎng)站開發(fā)工程師團(tuán)隊及專業(yè)的網(wǎng)站設(shè)計師團(tuán)隊。

其他快捷鍵：

Ctrl+1 快速修復(fù)(最經(jīng)典的快捷鍵,就不用多說了)

Ctrl+D: 刪除當(dāng)前行

Ctrl+Alt+↓ 復(fù)制當(dāng)前行到下一行(復(fù)制增加)

Ctrl+Alt+↑ 復(fù)制當(dāng)前行到上一行(復(fù)制增加)

Alt+↓ 當(dāng)前行和下面一行交互位置(特別實用,可以省去先剪切,再粘貼了)

Alt+↑ 當(dāng)前行和上面一行交互位置(同上)

Alt+← 前一個編輯的頁面

Alt+→ 下一個編輯的頁面(當(dāng)然是針對上面那條來說了)

Alt+Enter 顯示當(dāng)前選擇資源(工程,or 文件 or文件)的屬性

Shift+Enter 在當(dāng)前行的下一行插入空行(這時鼠標(biāo)可以在當(dāng)前行的任一位置,不一定是最后)

Shift+Ctrl+Enter 在當(dāng)前行插入空行(原理同上條)

Ctrl+Q 定位到最后編輯的地方

Ctrl+L 定位在某行 (對于程序超過100的人就有福音了)

Ctrl+M 最大化當(dāng)前的Edit或View (再按則反之)

Ctrl+/ 注釋當(dāng)前行,再按則取消注釋

Ctrl+O 快速顯示 OutLine

Ctrl+T 快速顯示當(dāng)前類的繼承結(jié)構(gòu)

Ctrl+W 關(guān)閉當(dāng)前Editer

Ctrl+K 參照選中的Word快速定位到下一個

Ctrl+E 快速顯示當(dāng)前Editer的下拉列表(如果當(dāng)前頁面沒有顯示的用黑體表示)

Ctrl+/(小鍵盤) 折疊當(dāng)前類中的所有代碼

Ctrl+×(小鍵盤) 展開當(dāng)前類中的所有代碼

Ctrl+Space 代碼助手完成一些代碼的插入(但一般和輸入法有沖突,可以修改輸入法的熱鍵,也可以暫用Alt+/來代替)

Ctrl+Shift+E 顯示管理當(dāng)前打開的所有的View的管理器(可以選擇關(guān)閉,激活等操作)

Ctrl+J 正向增量查找(按下Ctrl+J后,你所輸入的每個字母編輯器都提供快速匹配定位到某個單詞,如果沒有,則在stutes line中顯示沒有找到了,查一個單詞時,特別實用,這個功能Idea兩年前就有了)

Ctrl+Shift+J 反向增量查找(和上條相同,只不過是從后往前查)

Ctrl+Shift+F4 關(guān)閉所有打開的Editer

Ctrl+Shift+X 把當(dāng)前選中的文本全部變味小寫

Ctrl+Shift+Y 把當(dāng)前選中的文本全部變?yōu)樾?/p>

Ctrl+Shift+F 格式化當(dāng)前代碼

Ctrl+Shift+P 定位到對于的匹配符(譬如{}) (從前面定位后面時,光標(biāo)要在匹配符里面,后面到前面,則反之)

下面的快捷鍵是重構(gòu)里面常用的,本人就自己喜歡且常用的整理一下(注:一般重構(gòu)的快捷鍵都是Alt+Shift開頭的了)

Alt+Shift+R 重命名 (是我自己最愛用的一個了,尤其是變量和類的Rename,比手工方法能節(jié)省很多勞動力)

Alt+Shift+M 抽取方法 (這是重構(gòu)里面最常用的方法之一了,尤其是對一大堆泥團(tuán)代碼有用)

Alt+Shift+C 修改函數(shù)結(jié)構(gòu)(比較實用,有N個函數(shù)調(diào)用了這個方法,修改一次搞定)

Alt+Shift+L 抽取本地變量( 可以直接把一些魔法數(shù)字和字符串抽取成一個變量,尤其是多處調(diào)用的時候)

Alt+Shift+F 把Class中的local變量變?yōu)閒ield變量 (比較實用的功能)

Alt+Shift+I 合并變量(可能這樣說有點不妥Inline)

Alt+Shift+V 移動函數(shù)和變量(不怎么常用)

Alt+Shift+Z 重構(gòu)的后悔藥(Undo)

編輯

作用域 功能 快捷鍵

全局 查找并替換 Ctrl+F

文本編輯器 查找上一個 Ctrl+Shift+K

文本編輯器 查找下一個 Ctrl+K

全局 撤銷 Ctrl+Z

全局 復(fù)制 Ctrl+C

全局 恢復(fù)上一個選擇 Alt+Shift+↓

全局 剪切 Ctrl+X

全局 快速修正 Ctrl1+1

全局 內(nèi)容輔助 Alt+/

全局 全部選中 Ctrl+A

全局 刪除 Delete

全局 上下文信息 Alt+？

Alt+Shift+?

Ctrl+Shift+Space

Java編輯器 顯示工具提示描述 F2

Java編輯器 選擇封裝元素 Alt+Shift+↑

Java編輯器 選擇上一個元素 Alt+Shift+←

Java編輯器 選擇下一個元素 Alt+Shift+→

文本編輯器 增量查找 Ctrl+J

文本編輯器 增量逆向查找 Ctrl+Shift+J

全局 粘貼 Ctrl+V

全局 重做 Ctrl+Y

查看

作用域 功能 快捷鍵

全局 放大 Ctrl+=

全局 縮小 Ctrl+-

窗口

作用域 功能 快捷鍵

全局 激活編輯器 F12

全局 切換編輯器 Ctrl+Shift+W

全局 上一個編輯器 Ctrl+Shift+F6

全局 上一個視圖 Ctrl+Shift+F7

全局 上一個透視圖 Ctrl+Shift+F8

全局 下一個編輯器 Ctrl+F6

全局 下一個視圖 Ctrl+F7

全局 下一個透視圖 Ctrl+F8

文本編輯器 顯示標(biāo)尺上下文菜單 Ctrl+W

全局 顯示視圖菜單 Ctrl+F10

全局 顯示系統(tǒng)菜單 Alt+-

導(dǎo)航

作用域 功能 快捷鍵

Java編輯器 打開結(jié)構(gòu) Ctrl+F3

全局 打開類型 Ctrl+Shift+T

全局 打開類型層次結(jié)構(gòu) F4

全局 打開聲明 F3

全局 打開外部javadoc Shift+F2

全局 打開資源 Ctrl+Shift+R

全局 后退歷史記錄 Alt+←

全局 前進(jìn)歷史記錄 Alt+→

全局 上一個 Ctrl+,

全局 下一個 Ctrl+.

Java編輯器 顯示大綱 Ctrl+O

全局 在層次結(jié)構(gòu)中打開類型 Ctrl+Shift+H

全局 轉(zhuǎn)至匹配的括號 Ctrl+Shift+P

全局 轉(zhuǎn)至上一個編輯位置 Ctrl+Q

Java編輯器 轉(zhuǎn)至上一個成員 Ctrl+Shift+↑

Java編輯器 轉(zhuǎn)至下一個成員 Ctrl+Shift+↓

文本編輯器 轉(zhuǎn)至行 Ctrl+L

搜索

作用域 功能 快捷鍵

全局 出現(xiàn)在文件中 Ctrl+Shift+U

全局 打開搜索對話框 Ctrl+H

全局 工作區(qū)中的聲明 Ctrl+G

全局 工作區(qū)中的引用 Ctrl+Shift+G

文本編輯

作用域 功能 快捷鍵

文本編輯器 改寫切換 Insert

文本編輯器 上滾行 Ctrl+↑

文本編輯器 下滾行 Ctrl+↓

文件

作用域 功能 快捷鍵

全局 保存 Ctrl+X

Ctrl+S

全局 打印 Ctrl+P

全局 關(guān)閉 Ctrl+F4

全局 全部保存 Ctrl+Shift+S

全局 全部關(guān)閉 Ctrl+Shift+F4

全局 屬性 Alt+Enter

全局 新建 Ctrl+N

項目

作用域 功能 快捷鍵

全局 全部構(gòu)建 Ctrl+B

源代碼

作用域 功能 快捷鍵

Java編輯器 格式化 Ctrl+Shift+F

Java編輯器 取消注釋 Ctrl+\

Java編輯器 注釋 Ctrl+/

Java編輯器 添加導(dǎo)入 Ctrl+Shift+M

Java編輯器 組織導(dǎo)入 Ctrl+Shift+O

Java編輯器 使用try/catch塊來包圍 未設(shè)置，太常用了，所以在這里列出,建議自己設(shè)置。

也可以使用Ctrl+1自動修正。

運行

作用域 功能 快捷鍵

全局 單步返回 F7

全局 單步跳過 F6

全局 單步跳入 F5

全局 單步跳入選擇 Ctrl+F5

全局 調(diào)試上次啟動 F11

全局 繼續(xù) F8

全局 使用過濾器單步執(zhí)行 Shift+F5

全局 添加/去除斷點 Ctrl+Shift+B

全局 顯示 Ctrl+D

全局 運行上次啟動 Ctrl+F11

全局 運行至行 Ctrl+R

全局 執(zhí)行 Ctrl+U

重構(gòu)

作用域 功能 快捷鍵

全局 撤銷重構(gòu) Alt+Shift+Z

全局 抽取方法 Alt+Shift+M

全局 抽取局部變量 Alt+Shift+L

全局 內(nèi)聯(lián) Alt+Shift+I

全局 移動 Alt+Shift+V

全局 重命名 Alt+Shift+R

全局 重做 Alt+Shift+Y

如何寫出更好的Java代碼

1． 優(yōu)雅需要付出代價。

從短期利益來看，對某個問題提出優(yōu)雅的解決方法，似乎可能花你更多的時間。但當(dāng)它終于能夠正確執(zhí)行并可輕易套用于新案例中，不需要花上數(shù)以時計，甚至以天計或以月計的辛苦代價時，你會看得到先前所花功夫的回報（即使沒有人可以衡量這一點）。這不僅給你一個可更容易開發(fā)和調(diào)試的程序，也更易于理解和維護(hù)。這正是它在金錢上的價值所在。這一點有賴某種人生經(jīng)驗才能夠了解，因為當(dāng)你努力讓某一段程序代碼變得比較優(yōu)雅時，你并不是處于一種具生產(chǎn)力的狀態(tài)下。但是，請抗拒那些催促你趕工的人們，因為那么做只會減緩你的速度罷了。

2． 先求能動，再求快。

即使你已確定某段程序代碼極為重要，而且是系統(tǒng)的重要瓶頸，這個準(zhǔn)則依然成立。盡可能簡化設(shè)計，讓系統(tǒng)能夠先正確動作。如果程序的執(zhí)行不夠快，再量測其效能。幾乎你總是會發(fā)現(xiàn)，你所認(rèn)為的”瓶頸”其實都不是問題所在。把你的時間花在刀口上吧。

3． 記住”各個擊破”的原理。

如果你所探討的問題過于混雜，試著想像該問題的基本動作會是什么，并假設(shè)這一小塊東西能夠神奇地處理掉最難的部分。這”一小塊”東西其實就是對象–請撰寫運用該對象的程序代碼，然后檢視對象，并將其中困難的部分再包裝成其他對象，依此類推。

4． 區(qū)分class開發(fā)者和class使用者（使用端程序員）。

Class 使用者扮演著”客戶”角色，不需要（也不知道）class的底層運作方式。Class開發(fā)者必須是class設(shè)計專家，并撰寫class，使它能夠盡可能被大多數(shù)新手程序員所用，而且在程序中能夠穩(wěn)當(dāng)執(zhí)行。一套程序庫只有在具備通透性的情況下，使用起來才會容易。

5．當(dāng)你撰寫class時，試著給予明了易懂的名稱，減少不必要的注解。

你給客戶端程序員的接口，應(yīng)該保持概念上的單純性。不了這個目的，當(dāng)函數(shù)的重載（overloading）適合制作出直覺、易用的接口時，請善加使用。

6． 也必你的分析和設(shè)計必須讓系統(tǒng)中的classes保持最少，須讓其Public interfaces保持最少，以及讓這些classes和其他classes之間的關(guān)聯(lián)性（ 尤其是base classes）保持最少。

如果你的設(shè)計所得結(jié)果更甚于此，請問問自己，是否其中每一樣?xùn)|西在整個程序生命期中都饒富價值？如果并非如此，那么，維護(hù)它們會使你付出代價。開發(fā)團(tuán)隊的成員都有不維護(hù)”無益于生產(chǎn)力提升”的任何東西的傾向；這是許多設(shè)計方法無法解釋的現(xiàn)象。

7． 讓所有東西盡量自動化。先撰寫測試用的程序代碼（在你撰寫class之前），并讓它和class結(jié)合在一起。請使用makefile或類似工具，自動進(jìn)行測試動作。

通過這種方式，只要執(zhí)行測試程序，所有的程序變動就可以自動獲得驗證，而且可以立即發(fā)現(xiàn)錯誤。由于你知道的測試架構(gòu)所具備的安全性，所以當(dāng)你發(fā)現(xiàn)新的需求時，你會更勇于進(jìn)行全面修改。請記住，程序語言最大的改進(jìn)，是來自型別檢查、異常處理等機(jī)制所賦予的內(nèi)置測試動作。但這些功能只能協(xié)助你到達(dá)某種程度。開發(fā)一個穩(wěn)固系統(tǒng)時，你得自己驗證自己的classes或程序的性質(zhì)。

8． 在你撰寫class之前先寫測試碼，以便驗證你的class 是否設(shè)計完備。如果你無法撰寫測試碼，你便無法知道你的class 的可能長相。撰寫測試碼通常能夠顯現(xiàn)出額外的特性（features）或限制 ( constraints)__它們并不一定總是能夠在分析和設(shè)計過程中出現(xiàn)。測試碼也可做為展示class 用法的示例程序。

9． 所有軟件設(shè)計上的問題，都可以通過”引入額外的概念性間接層（conceptual indirection）”加以簡化。這個軟件工程上的基礎(chǔ)法則是抽象化概念的根據(jù)，而抽象化概念正是面向?qū)ο蟪绦蛟O(shè)計的主要性質(zhì)。

10． 間接層(indirection)應(yīng)該要有意義（和準(zhǔn)則-9致）。

這里所指的意義可以像”將共用程序代碼置于惟一函數(shù)”這么簡單。如果你加入的間接層（或抽象化、或封裝等等）不具意義，它可能就和沒有適當(dāng)?shù)拈g接層一樣糟糕。

11． 讓class盡可能微小而無法切割（atomic）。

賦予每個class單一而清楚的用途。如果你的classes或你的系統(tǒng)成長得過于復(fù)雜，請將復(fù)雜的classes切割成比較簡單的幾個classes。最明顯的一個判斷指針就是class的大小：如果它很大，那么它工作量過多的機(jī)會就可能很高，那就應(yīng)該被切割。重新設(shè)計class的建議線索是：

1） 復(fù)雜的switch語句：請考慮運用多態(tài)（Polymorphism）。

2） 許多函數(shù)各自處理類型極為不同的動作：請考慮切割為多個不同的（classes）。

12． 小心冗長的引數(shù)列（argument lists）。

冗長的引數(shù)列會使函數(shù)的調(diào)用動作不易撰寫、閱讀、維護(hù)。你應(yīng)該試著將函數(shù)搬移到更適當(dāng)?shù)腸lass中，并盡量以對象為引數(shù)。

13． 不要一再重復(fù)。

如果某段程序代碼不斷出現(xiàn)于許多derived class函數(shù)中，請將該段程序代碼置于某個base class 函數(shù)內(nèi)，然后在derived class函數(shù)中調(diào)用。這么做不僅可以省下程序代碼空間，也可以讓修改該段程序代碼動作更易于進(jìn)行。有時候找出此種共通程序代碼還可以為接口增加實用功能。

14． 小心switch語句或成串的if-else 子句。

通常這種情況代表所謂的”type-check coding”。也就是說究竟會執(zhí)行哪一段程序代碼，乃是依據(jù)某種型別信息來做抉擇（最初，確切型別可能不十分明顯）。你通常可以使用繼承和多態(tài)來取代此類程序代碼；Polymorphical method （多態(tài)函數(shù)）的調(diào)用會自動執(zhí)行此類型別檢驗，并提供更可靠更容易的擴(kuò)充性。

15． 從設(shè)計觀點來看，請找出變動的事物，并使它和不變的事物分離。

也就是說，找出系統(tǒng)中可能被你改變的元素，將它們封裝于classes中。你可以在《Thinking in Patterns with Java》（可免費下載于 www. BruceEckel. Com）大量學(xué)習(xí)到這種觀念。

16． 不要利用subclassing來擴(kuò)充基礎(chǔ)功能。

如果某個接口元素對class而言極重要，它應(yīng)該被放在base class 里頭，而不是直到衍生（derivation）時才被加入。如果你在繼承過程中加入了函數(shù)，或許你應(yīng)該重新思考整個設(shè)計。

17． 少就是多。

從class 的最小接口開始妨展，盡可能在解決問題的前提下讓它保持既小又單純。不要預(yù)先考量你的class被使用的所有可能方式。一旦class被實際運用，你自然會知道你得如何擴(kuò)充接口。不過，一旦class被使用后，你就無法在不影響客戶程序代碼的情況下縮減其接口。如果你要加入更多函數(shù)倒是沒有問題–不會影響既有的客戶程序代碼，它們只需重新編譯即可。但即使新函數(shù)取代了舊函數(shù)的功能，也請你保留既有接口。如果你得通過”加入更多引數(shù)”的方式來擴(kuò)充既有函數(shù)的接口，請你以新引數(shù)寫出一個重載化的函數(shù)；通過 這種方式就不會影響既有函數(shù)的任何客戶了。

18． 大聲念出你的classes,確認(rèn)它們符合邏輯。

請base class和derived class 之間的關(guān)系是”is-a”(是一種)，讓class和成員對象之間的關(guān)系是”has-a”(有一個)。

19． 當(dāng)你猶豫不決于繼承（inheritance）或合成（組合，composition）時，請你問問自己，是否需要向上轉(zhuǎn)型（upcast）為基礎(chǔ)型別。

如果不需要，請優(yōu)先選擇合成（也就是是使用成員對象）。這種作法可以消除”過多基礎(chǔ)型別”。如果你采用繼承，使用者會認(rèn)為他們應(yīng)該可以向上轉(zhuǎn)型。

20． 運用數(shù)據(jù)成員來表示數(shù)值的變化，運用經(jīng)過覆寫的函數(shù)（overrided method）來代表行為的變化 。

也就是說，如果你找到了某個 class, 帶有一些狀態(tài)變量，而其函數(shù)會依據(jù)這些變量值切換不同的行為，那么你或許就應(yīng)該重新設(shè)計，在subclasses 和覆寫后的函數(shù)（overrided methods）中展現(xiàn)行為止的差異。

21． 小心重載（overloading）。

函數(shù)不應(yīng)該依據(jù)引數(shù)值條件式地選擇執(zhí)行某一段程序代碼。這種情況下你應(yīng)該撰寫兩個或更多個重載函數(shù)（overloaded methods）

22． 使用異常體系（exception hierarchies）

最好是從Java標(biāo)準(zhǔn)異常體系中衍生特定的classes, 那么，捕捉異常的人便可以捕捉特定異常，之后才捕捉基本異常。如果你加入新的衍生異常，原有的客戶端程序仍能通過其基礎(chǔ)型別來捕捉它。

23． 有時候簡單的聚合（aggregation）就夠了。

飛機(jī)上的”旅客舒適系統(tǒng)”包括數(shù)個分離的元素：座椅、空調(diào)、視訊設(shè)備等等，你會需要在飛機(jī)上產(chǎn)生許多這樣的東西。你會將它們聲明為Private成員并開發(fā)出一個全新的接口嗎？不會的，在這個例子中，元素也是Public接口的一部分，所以仍然是安全的。當(dāng)然啦，簡單聚合并不是一個常被運用的解法，但有時候的確是。

24． 試著從客戶程序員和程序維護(hù)的角度思考。

你的class應(yīng)該設(shè)計得盡可能容易使用。你應(yīng)該預(yù)先考量可能性有的變動，并針對這些 可能的變動進(jìn)行設(shè)計，使這些變動日后可輕易完成。

25． 小心”巨大對象并發(fā)癥”。

這往往是剛踏OOP領(lǐng)域的過程式（procedural）程序員的一個苦惱，因為他們往往最終還是寫出一個過程式程序，并將它們擺放到一個或兩個巨大對象中。注意，除了application framework (應(yīng)用程序框架，譯注：一種很特殊的、大型OO程序庫，幫你架構(gòu)程序本體)之外，對象代表的是程序中的觀念，而不是程序本身。

26． 如果你得用某種丑陋的方式來達(dá)成某個動作，請將丑陋的部分局限在某個class里頭。

27． 如果你得用某種不可移植方式來達(dá)成某個動作，請將它抽象化并局限于某個class里頭。這樣一個”額外間接層”能夠防止不可移植的部分?jǐn)U散到整個程序。這種作法的具體呈現(xiàn)便是Bridge設(shè)計模式（design pattern）。

28． 對象不應(yīng)僅僅只用來持有數(shù)據(jù)。

對象也應(yīng)該具有定義明確界限清楚的行為。有時候使用”數(shù)據(jù)對象”是適當(dāng)?shù)模挥性谕ㄓ眯稳萜鞑贿m用時，才適合刻意以數(shù)據(jù)對象來包裝、傳輸一群數(shù)據(jù)項。

29． 欲從既有的classes身上產(chǎn)生新的classes時，請以組合(composition)為優(yōu)先考量。

你應(yīng)該只在必要時才使用繼承。如果在組合適用之處你卻選擇了繼承，你的設(shè)計就滲雜了非必要的復(fù)雜性。

30． 運用繼承和函數(shù)覆寫機(jī)制來展現(xiàn)行為上的差異，運用fields(數(shù)據(jù)成員)來展現(xiàn)狀態(tài)上的差異。

這句話的極端例子，就是繼承出不同的classes表現(xiàn)各種不同的顏色，而不使用”color”field.

31． 當(dāng)心變異性（variance）。

語意相異的兩個對象擁有相同的動作（或說責(zé)任）是可能的。OO世界中存在著一種天生的引誘，讓人想要從某個class繼承出另一個subclass,為的是獲得繼承帶來的福利。這便是所謂”變異性”。但是，沒有任何正當(dāng)理由足以讓我們強(qiáng)迫制造出某個其實并不存在的superclass/subclass關(guān)系。比較好的解決方式是寫出一個共用的base class,它為兩個derived classes制作出共用接口–這種方式會耗用更多空間，但你可以如你所盼望地從繼承機(jī)制獲得好處，而且或許能夠在設(shè)計上獲得重大發(fā)現(xiàn)。

32． 注意繼承上的限制。

最清晰易懂的設(shè)計是將功能加到繼承得來的class里頭；繼承過程中拿掉舊功能（而非增加新功能）則是一種可疑的設(shè)計。不過，規(guī)則可以打破。如果你所處理的是舊有的class程序庫，那么在某個class的subclass限制功能，可能會比重新制定整個結(jié)構(gòu)（俾使新class得以良好地相稱于舊 class）有效率得多。

33． 使用設(shè)計模式（design patterns）來減少”赤裸裸無加掩飾的機(jī)能（naked functionality）”。

舉個例子，如果你的class只應(yīng)該產(chǎn)出惟一一個對象，那么請不要以加思索毫無設(shè)計的手法來完成它，然后撰寫”只該產(chǎn)生一份對象”這樣的注解就拍拍屁股走人。請將它包裝成singleton（譯注：一個有名的設(shè)計模式，可譯為”單件”）。如果主程序中有多而混亂的”用以產(chǎn)生對象”的程序代碼，請找出類似 factory method這樣的生成模式（creational patterns），使價錢可用以封裝生成動作減少”赤裸裸無加掩飾的機(jī)能”（naked functionality）不僅可以讓你的程序更易理解和維護(hù)，也可以阻止出于好意卻帶來意外的維護(hù)者。

34． 當(dāng)心”因分析而導(dǎo)致的癱瘓（analysis paralysis）”。

請記住，你往往必須在獲得所有信息之前讓項目繼續(xù)前進(jìn)。而且理解未知部分的最好也最快的方式，通常就是實際前進(jìn)一步而不只是紙上談兵。除非找到解決辦法，否則無法知道解決辦法。Java擁有內(nèi)置的防火墻，請讓它們發(fā)揮作用。你在單一class或一組classes中所犯的錯誤，并不會傷害整個系統(tǒng)的完整性。

35． 當(dāng)你認(rèn)為你已經(jīng)獲得一份優(yōu)秀的分析、設(shè)計或?qū)崿F(xiàn)時，請試著加以演練。

將團(tuán)隊以外的某些人帶進(jìn)來-他不必非得是個顧問不可，他可以是公司其他團(tuán)隊的成員。請那個人以新鮮的姿態(tài)審視你們的成果，這樣可以在尚可輕易修改的階段找出問題，其收獲會比因演練而付出的時間和金錢代價來得高。實現(xiàn) （Implementation）

36. 一般來說，請遵守Sun的程序編寫習(xí)慣。

價錢可以在以下網(wǎng)址找到相關(guān)文檔：java.sun.com/docs/codeconv/idex.html。本書盡可能遵守這些習(xí)慣。眾多Java程序員看到的程序代碼，都有是由這些習(xí)慣構(gòu)成的。如果你固執(zhí)地停留在過去的編寫風(fēng)格中，你的（程序代碼）讀者會比較辛苦。不論你決定采用什么編寫習(xí)慣，請在整個程序中保持一致。你可以在home.wtal.de/software-solutions/jindent上找到一個用來重排Java程序的免費工具。

37. 無論使用何種編寫風(fēng)格，如果你的團(tuán)隊（或整個公司，那就更好了）能夠加以標(biāo)準(zhǔn)化，那么的確會帶來顯著效果。這代表每個人都可以在其他人不遵守編寫風(fēng)格修改其作品，這是個公平的游戲。標(biāo)準(zhǔn)化的價值在于，分析程序代碼時所花的腦力較小，因而可以專心于程序代碼的實質(zhì)意義。

38. 遵守標(biāo)準(zhǔn)的大小寫規(guī)范。

將 class名稱的第一個字母應(yīng)為大寫。數(shù)據(jù)成員、函數(shù)、對象（references）的第一個字母應(yīng)為小寫。所有識別名稱的每個字都應(yīng)該連在一塊兒，所有非首字的第一個字母都應(yīng)該大寫。例如： ThisIsAClassName thisIsAMethodOrFieldName 如果你在static final 基本型別的定義處指定了常量初始式（constant initializers）,那么該識別名稱應(yīng)該全為大寫，代表一個編譯期常量。 Packages是個特例，其名稱皆為小寫，即使非首字的字母亦是如此。域名（org, net, edu 等等）皆應(yīng)為小寫。（這是Java 1.1遷移至Java 2時的一項改變） 。

39、不要自己發(fā)明”裝飾用的”Private數(shù)據(jù)成員名稱。

通常這種的形式是在最前端加上底線和其他字符，匈牙利命名法（Hungarian notation）是其中最差的示范。在這種命名法中，你得加入額外字符來表示數(shù)據(jù)的型別、用途、位置等等。仿佛你用的是匯編語言（assembly language）而編譯器沒有提供任何協(xié)肋似的。這樣的命名方式容易讓人混淆又難以閱讀，也不易推行和維護(hù)。就讓classes和packages來進(jìn)行”名稱上的范

圍制定（name scoping）”吧。

40、當(dāng)你擬定通用性的class時，請遵守正規(guī)形式（canonical form）。

包括equals( )、hashCode( )、clone( ) ( 實現(xiàn)出Cloneable),并實現(xiàn)出Comparable和Serialiable等等。

eclipse怎樣對java代碼自動排版，快速格式化，快速使代碼對齊

使代碼快速對齊的方法有兩種，咱們先看第一種：首先打開代碼

如圖所示，找到"Source",點擊

在彈出的下拉框內(nèi)，找到"Format",然后點擊

然后對比一下，就可以看到代碼自動對齊了

還有一種方法是直接使用快捷鍵“Ctrl+shift+f”，就ok了

返回代碼區(qū)，然后對比一下，就可以看到代碼自動對齊了

Java代碼優(yōu)化有哪些常用的方法

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)一個類從另一個類派生時，這一點尤其應(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ù)組然后重新將舊字符和新字符都拷貝一遍――這也太昂貴了點。所以總是給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 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類一樣，每次擴(kuò)展存儲能力時，所有現(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進(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()命令。

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都必須是同類型或者可以進(jìn)行轉(zhuǎn)換類型的數(shù)組．

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沒有顯示的使用 關(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ā)者隨意地把大量信息保存到用戶會話之中。一些時候，保存在會話中的對象沒有及時地被垃圾回收機(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指令的頁面和指定的資源被合并成一個文件。被引用的外部資源在編譯時就確定，比運行時才確定資源更高效。

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)于兩次進(jìn)入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時進(jìn)行類型檢查。

從這一點上看來，ArrayList與數(shù)組的區(qū)別主要就是由于動態(tài)增容的效率問題了

28、盡量使用HashMap 和ArrayList ,除非必要，否則不推薦使用HashTable和Vector ，后者由于使用同步機(jī)制，而導(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由于支持正則表達(dá)式，所以效率比較低，如果是頻繁的幾十，幾百萬的調(diào)用將會耗費大量資源，如果確實需要頻繁的調(diào)用split，可以考慮使用apache的 StringUtils.split(string,char)，頻繁split的可以緩存結(jié)果。

其他補(bǔ)充:

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。這對那些擴(kuò)展自其它類的類尤其重要，這跟使用一個新的關(guān)鍵詞創(chuàng)建一個對象時所有一連串的構(gòu)造器被自動調(diào)用一樣。

3. 在任何可能的地方讓類為Final

標(biāo)記為final的類不能被擴(kuò)展。在《核心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)把其放置在最外層

java用快捷鍵怎么將代碼整齊

Ctrl+shift+F

Java開發(fā)，首選eclipse，Ctrl+shift+F。別的編輯器就看它有沒有這功能。在線工具，也有格式化代碼的功能，自己找一下。

本文名稱：Java把代碼變整潔 java代碼整潔之道
轉(zhuǎn)載來于：http://vcdvsql.cn/article44/hehjhe.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供商城網(wǎng)站、電子商務(wù)、外貿(mào)網(wǎng)站建設(shè)、小程序開發(fā)、全網(wǎng)營銷推廣、搜索引擎優(yōu)化

廣告

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