日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
Java編程：常見問題匯總

每天在寫Java程序，其實里面有一些細節(jié)大家可能沒怎么注意，這不，有人總結(jié)了一個我們編程中常見的問題。雖然一般沒有什么大問題，但是最好別這樣做。另外這里提到的很多問題其實可以通過Findbugs( http://findbugs.sourceforge.net/ )來幫我們進行檢查出來。

廣靈網(wǎng)站建設(shè)公司成都創(chuàng)新互聯(lián)公司,廣靈網(wǎng)站設(shè)計制作，有大型網(wǎng)站制作公司豐富經(jīng)驗。已為廣靈上千家提供企業(yè)網(wǎng)站建設(shè)服務(wù)。企業(yè)網(wǎng)站搭建\外貿(mào)網(wǎng)站制作要多少錢，請找那個售后服務(wù)好的廣靈做網(wǎng)站的公司定做！

字符串連接誤用

錯誤的寫法：

 
 
 
    
  
  
  
  1. String s = ""; 
    2. 
  
  
  
  2. for (Person p : persons) { 
    3. 
  
  
  
  3.     s += ", " + p.getName(); 
    4. 
  
  
  
  4. } 
    5. 
  
  
  
  5. s = s.substring(2); //remove first comma
    6.

正確的寫法：

 
 
 
    
  
  
  
  1. StringBuilder sb = new StringBuilder(persons.size() * 16); // well estimated buffer 
    2. 
  
  
  
  2. for (Person p : persons) { 
    3. 
  
  
  
  3.     if (sb.length() > 0) sb.append(", "); 
    4. 
  
  
  
  4.     sb.append(p.getName); 
    5. 
  
  
  
  5. }
    6.

錯誤的使用StringBuffer

錯誤的寫法：

 
 
 
    
  
  
  
  1. StringBuffer sb = new StringBuffer(); 
    2. 
  
  
  
  2. sb.append("Name: "); 
    3. 
  
  
  
  3. sb.append(name + '\n'); 
    4. 
  
  
  
  4. sb.append("!"); 
    5. 
  
  
  
  5. ... 
    6. 
  
  
  
  6. String s = sb.toString();
    7.

問題在第三行，append char比String性能要好，另外就是初始化StringBuffer沒有指定size，導致中間append時可能重新調(diào)整內(nèi)部數(shù)組大小。如果是JDK1.5最好用StringBuilder取代StringBuffer，除非有線程安全的要求。還有一種方式就是可以直接連接字符串。缺點就是無法初始化時指定長度。

正確的寫法：

 
 
 
    
  
  
  
  1. StringBuilder sb = new StringBuilder(100); 
    2. 
  
  
  
  2. sb.append("Name: "); 
    3. 
  
  
  
  3. sb.append(name); 
    4. 
  
  
  
  4. sb.append("\n!"); 
    5. 
  
  
  
  5. String s = sb.toString();
    6.

或者這樣寫：

 
 
 
    
  
  
  
  1. String s = "Name: " + name + "\n!";
    2.

測試字符串相等性

錯誤的寫法：

 
 
 
    
  
  
  
  1. if (name.compareTo("John") == 0) ... 
    2. 
  
  
  
  2. if (name == "John") ... 
    3. 
  
  
  
  3. if (name.equals("John")) ... 
    4. 
  
  
  
  4. if ("".equals(name)) ...
    5.

上面的代碼沒有錯，但是不夠好。compareTo不夠簡潔，==原義是比較兩個對象是否一樣。另外比較字符是否為空，最好判斷它的長度。

正確的寫法：

 
 
 
    
  
  
  
  1. if ("John".equals(name)) ... 
    2. 
  
  
  
  2. if (name.length() == 0) ... 
    3. 
  
  
  
  3. if (name.isEmpty()) ...
    4.

數(shù)字轉(zhuǎn)換成字符串

錯誤的寫法：

 
 
 
    
  
  
  
  1. "" + set.size() 
    2. 
  
  
  
  2. new Integer(set.size()).toString() 
    3.

正確的寫法：

 
 
 
    
  
  
  
  1. String.valueOf(set.size())
    2.

利用不可變對象(Immutable)

錯誤的寫法：

 
 
 
    
  
  
  
  1. zero = new Integer(0); 
    2. 
  
  
  
  2. return Boolean.valueOf("true");
    3.

正確的寫法：

 
 
 
    
  
  
  
  1. zero = Integer.valueOf(0); 
    2. 
  
  
  
  2. return Boolean.TRUE;
    3.

請使用XML解析器

錯誤的寫法：

 
 
 
    
  
  
  
  1. int start = xml.indexOf("") + "".length(); 
    2. 
  
  
  
  2. int end = xml.indexOf(""); 
    3. 
  
  
  
  3. String name = xml.substring(start, end);
    4.

正確的寫法：

 
 
 
    
  
  
  
  1. SAXBuilder builder = new SAXBuilder(false); 
    2. 
  
  
  
  2. Document doc = doc = builder.build(new StringReader(xml)); 
    3. 
  
  
  
  3. String name = doc.getRootElement().getChild("name").getText();
    4.

請使用JDom組裝XML

錯誤的寫法：

 
 
 
    
  
  
  
  1. String name = ... 
    2. 
  
  
  
  2. String attribute = ... 
    3. 
  
  
  
  3. String xml = ""
    4. 
  
  
  
  4.             +""+ name +""
    5. 
  
  
  
  5.             +"";
    6.

正確的寫法：

 
 
 
    
  
  
  
  1. Element root = new Element("root"); 
    2. 
  
  
  
  2. root.setAttribute("att", attribute); 
    3. 
  
  
  
  3. root.setText(name); 
    4. 
  
  
  
  4. Document doc = new Documet(); 
    5. 
  
  
  
  5. doc.setRootElement(root); 
    6. 
  
  
  
  6. XmlOutputter out = new XmlOutputter(Format.getPrettyFormat()); 
    7. 
  
  
  
  7. String xml = out.outputString(root);
    8.

XML編碼陷阱

錯誤的寫法：

 
 
 
    
  
  
  
  1. String xml = FileUtils.readTextFile("my.xml");
    2.

因為xml的編碼在文件中指定的，而在讀文件的時候必須指定編碼。另外一個問題不能一次就將一個xml文件用String保存，這樣對內(nèi)存會造成不必要的浪費，正確的做法用InputStream來邊讀取邊處理。為了解決編碼的問題, 最好使用XML解析器來處理。

未指定字符編碼

錯誤的寫法：

 
 
 
    
  
  
  
  1. Reader r = new FileReader(file); 
    2. 
  
  
  
  2. Writer w = new FileWriter(file); 
    3. 
  
  
  
  3. Reader r = new InputStreamReader(inputStream); 
    4. 
  
  
  
  4. Writer w = new OutputStreamWriter(outputStream); 
    5. 
  
  
  
  5. String s = new String(byteArray); // byteArray is a byte[] 
    6. 
  
  
  
  6. byte[] a = string.getBytes();
    7.

這樣的代碼主要不具有跨平臺可移植性。因為不同的平臺可能使用的是不同的默認字符編碼。

正確的寫法：

 
 
 
    
  
  
  
  1. Reader r = new InputStreamReader(new FileInputStream(file), "ISO-8859-1"); 
    2. 
  
  
  
  2. Writer w = new OutputStreamWriter(new FileOutputStream(file), "ISO-8859-1"); 
    3. 
  
  
  
  3. Reader r = new InputStreamReader(inputStream, "UTF-8"); 
    4. 
  
  
  
  4. Writer w = new OutputStreamWriter(outputStream, "UTF-8"); 
    5. 
  
  
  
  5. String s = new String(byteArray, "ASCII"); 
    6. 
  
  
  
  6. byte[] a = string.getBytes("ASCII");
    7.

未對數(shù)據(jù)流進行緩存

錯誤的寫法：

 
 
 
    
  
  
  
  1. InputStream in = new FileInputStream(file);  
    2. 
  
  
  
  2. int b;  
    3. 
  
  
  
  3. while ((b = in.read()) != -1) {  
    4. 
  
  
  
  4. ...  
    5. 
  
  
  
  5. } 
    6.

上面的代碼是一個byte一個byte的讀取，導致頻繁的本地JNI文件系統(tǒng)訪問，非常低效，因為調(diào)用本地方法是非常耗時的。最好用BufferedInputStream包裝一下。曾經(jīng)做過一個測試，從/dev/zero下讀取1MB，大概花了1s，而用BufferedInputStream包裝之后只需要60ms，性能提高了94%! 這個也適用于output stream操作以及socket操作。

正確的寫法：

 
 
 
    
  
  
  
  1. InputStream in = new BufferedInputStream(new FileInputStream(file)); 
    2.

無限使用heap內(nèi)存

錯誤的寫法：

 
 
 
    
  
  
  
  1. byte[] pdf = toPdf(file); 
    2.

這里有一個前提，就是文件大小不能講JVM的heap撐爆。否則就等著OOM吧，尤其是在高并發(fā)的服務(wù)器端代碼。最好的做法是采用Stream的方式邊讀取邊存儲(本地文件或database)。

正確的寫法：

 
 
 
    
  
  
  
  1. File pdf = toPdf(file); 
    2.

另外，對于服務(wù)器端代碼來說，為了系統(tǒng)的安全，至少需要對文件的大小進行限制。

不指定超時時間

錯誤的代碼：

 
 
 
    
  
  
  
  1. Socket socket = ...  
    2. 
  
  
  
  2. socket.connect(remote);  
    3. 
  
  
  
  3. InputStream in = socket.getInputStream();  
    4. 
  
  
  
  4. int i = in.read(); 
    5.

這種情況在工作中已經(jīng)碰到不止一次了。個人經(jīng)驗一般超時不要超過20s。這里有一個問題，connect可以指定超時時間，但是read無法指定超時時間。但是可以設(shè)置阻塞(block)時間。

正確的寫法：

 
 
 
    
  
  
  
  1. Socket socket = ...  
    2. 
  
  
  
  2. socket.connect(remote, 20000); // fail after 20s  
    3. 
  
  
  
  3. InputStream in = socket.getInputStream();  
    4. 
  
  
  
  4. socket.setSoTimeout(15000);  
    5. 
  
  
  
  5. int i = in.read(); 
    6.

另外，文件的讀取(FileInputStream, FileChannel, FileDescriptor, File)沒法指定超時時間, 而且IO操作均涉及到本地方法調(diào)用, 這個更操作了JVM的控制范圍，在分布式文件系統(tǒng)中，對IO的操作內(nèi)部實際上是網(wǎng)絡(luò)調(diào)用。一般情況下操作60s的操作都可以認為已經(jīng)超時了。為了解決這些問題，一般采用緩存和異步/消息隊列處理。

頻繁使用計時器

錯誤代碼：

 
 
 
    
  
  
  
  1. for (...) {  
    2. 
  
  
  
  2. long t = System.currentTimeMillis();  
    3. 
  
  
  
  3. long t = System.nanoTime();  
    4. 
  
  
  
  4. Date d = new Date();  
    5. 
  
  
  
  5. Calendar c = new GregorianCalendar();  
    6. 
  
  
  
  6. } 
    7.

每次new一個Date或Calendar都會涉及一次本地調(diào)用來獲取當前時間(盡管這個本地調(diào)用相對其他本地方法調(diào)用要快)。
如果對時間不是特別敏感，這里使用了clone方法來新建一個Date實例。這樣相對直接new要高效一些。

正確的寫法：

 
 
 
    
  
  
  
  1. Date d = new Date();  
    2. 
  
  
  
  2. for (E entity : entities) {  
    3. 
  
  
  
  3. entity.doSomething();  
    4. 
  
  
  
  4. entity.setUpdated((Date) d.clone());  
    5. 
  
  
  
  5. } 
    6.

如果循環(huán)操作耗時較長(超過幾ms)，那么可以采用下面的方法，立即創(chuàng)建一個Timer，然后定期根據(jù)當前時間更新時間戳，在我的系統(tǒng)上比直接new一個時間對象快200倍：

 
 
 
    
  
  
  
  1. private volatile long time;  
    2. 
  
  
  
  2. Timer timer = new Timer(true);  
    3. 
  
  
  
  3. try {  
    4. 
  
  
  
  4. time = System.currentTimeMillis();  
    5. 
  
  
  
  5. timer.scheduleAtFixedRate(new TimerTask() {  
    6. 
  
  
  
  6. public void run() {  
    7. 
  
  
  
  7. time = System.currentTimeMillis();  
    8. 
  
  
  
  8. }  
    9. 
  
  
  
  9. }, 0L, 10L); // granularity 10ms  
    10. 
  
  
  
  10. for (E entity : entities) {  
    11. 
  
  
  
  11. entity.doSomething();  
    12. 
  
  
  
  12. entity.setUpdated(new Date(time));  
    13. 
  
  
  
  13. }  
    14. 
  
  
  
  14. } finally {  
    15. 
  
  
  
  15. timer.cancel();  
    16. 
  
  
  
  16. } 
    17.

捕獲所有的異常

錯誤的寫法：

 
 
 
    
  
  
  
  1. Query q = ...  
    2. 
  
  
  
  2. Person p;  
    3. 
  
  
  
  3. try {  
    4. 
  
  
  
  4. p = (Person) q.getSingleResult();  
    5. 
  
  
  
  5. } catch(Exception e) {  
    6. 
  
  
  
  6. p = null;  
    7. 
  
  
  
  7. } 
    8.

這是EJB3的一個查詢操作，可能出現(xiàn)異常的原因是：結(jié)果不唯一；沒有結(jié)果；數(shù)據(jù)庫無法訪問，而捕獲所有的異常，設(shè)置為null將掩蓋各種異常情況。

正確的寫法：

 
 
 
    
  
  
  
  1. Query q = ...  
    2. 
  
  
  
  2. Person p;  
    3. 
  
  
  
  3. try {  
    4. 
  
  
  
  4. p = (Person) q.getSingleResult();  
    5. 
  
  
  
  5. } catch(NoResultException e) {  
    6. 
  
  
  
  6. p = null;  
    7. 
  
  
  
  7. } 
    8.

忽略所有異常

錯誤的寫法：

 
 
 
    
  
  
  
  1. try {  
    2. 
  
  
  
  2. doStuff();  
    3. 
  
  
  
  3. } catch(Exception e) {  
    4. 
  
  
  
  4. log.fatal("Could not do stuff");  
    5. 
  
  
  
  5. }  
    6. 
  
  
  
  6. doMoreStuff(); 
    7.

這個代碼有兩個問題, 一個是沒有告訴調(diào)用者, 系統(tǒng)調(diào)用出錯了. 第二個是日志沒有出錯原因, 很難跟蹤定位問題。

正確的寫法：

 
 
 
    
  
  
  
  1. try {  
    2. 
  
  
  
  2. doStuff();  
    3. 
  
  
  
  3. } catch(Exception e) {  
    4. 
  
  
  
  4. throw new MyRuntimeException("Could not do stuff because: "+ e.getMessage, e);  
    5. 
  
  
  
  5. } 
    6.

重復包裝RuntimeException

錯誤的寫法：

 
 
 
    
  
  
  
  1. try {  
    2. 
  
  
  
  2. doStuff();  
    3. 
  
  
  
  3. } catch(Exception e) {  
    4. 
  
  
  
  4. throw new RuntimeException(e);  
    5. 
  
  
  
  5. } 
    6.

正確的寫法：

 
 
 
    
  
  
  
  1. try {  
    2. 
  
  
  
  2. doStuff();  
    3. 
  
  
  
  3. } catch(RuntimeException e) {  
    4. 
  
  
  
  4. throw e;  
    5. 
  
  
  
  5. } catch(Exception e) {  
    6. 
  
  
  
  6. throw new RuntimeException(e.getMessage(), e);  
    7. 
  
  
  
  7. }  
    8. 
  
  
  
  8. try {  
    9. 
  
  
  
  9. doStuff();  
    10. 
  
  
  
  10. } catch(IOException e) {  
    11. 
  
  
  
  11. throw new RuntimeException(e.getMessage(), e);  
    12. 
  
  
  
  12. } catch(NamingException e) {  
    13. 
  
  
  
  13. throw new RuntimeException(e.getMessage(), e);  
    14. 
  
  
  
  14. } 
    15.

不正確的傳播異常

錯誤的寫法：

 
 
 
    
  
  
  
  1. try {  
    2. 
  
  
  
  2. } catch(ParseException e) {  
    3. 
  
  
  
  3. throw new RuntimeException();  
    4. 
  
  
  
  4. throw new RuntimeException(e.toString());  
    5. 
  
  
  
  5. throw new RuntimeException(e.getMessage());  
    6. 
  
  
  
  6. throw new RuntimeException(e);  
    7. 
  
  
  
  7. } 
    8.

主要是沒有正確的將內(nèi)部的錯誤信息傳遞給調(diào)用者. 第一個完全丟掉了內(nèi)部錯誤信息, 第二個錯誤信息依賴toString方法, 如果沒有包含最終的嵌套錯誤信息, 也會出現(xiàn)丟失, 而且可讀性差. 第三個稍微好一些, 第四個跟第二個一樣。

正確的寫法：

 
 
 
    
  
  
  
  1. try {  
    2. 
  
  
  
  2. } catch(ParseException e) {  
    3. 
  
  
  
  3. throw new RuntimeException(e.getMessage(), e);  
    4. 
  
  
  
  4. } 
    5.

用日志記錄異常

錯誤的寫法：

 
 
 
    
  
  
  
  1. try {  
    2. 
  
  
  
  2. ...  
    3. 
  
  
  
  3. } catch(ExceptionA e) {  
    4. 
  
  
  
  4. log.error(e.getMessage(), e);  
    5. 
  
  
  
  5. throw e;  
    6. 
  
  
  
  6. } catch(ExceptionB e) {  
    7. 
  
  
  
  7. log.error(e.getMessage(), e);  
    8. 
  
  
  
  8. throw e;  
    9. 
  
  
  
  9. } 
    10.

一般情況下在日志中記錄異常是不必要的, 除非調(diào)用方?jīng)]有記錄日志。

異常處理不徹底

錯誤的寫法：

 
 
 
    
  
  
  
  1. try {  
    2. 
  
  
  
  2. is = new FileInputStream(inFile);  
    3. 
  
  
  
  3. os = new FileOutputStream(outFile);  
    4. 
  
  
  
  4. } finally {  
    5. 
  
  
  
  5. try {  
    6. 
  
  
  
  6. is.close();  
    7. 
  
  
  
  7. os.close();  
    8. 
  
  
  
  8. } catch(IOException e) {  
    9. 
  
  
  
  9. /* we can't do anything */  
    10. 
  
  
  
  10. }  
    11. 
  
  
  
  11. } 
    12.

is可能close失敗, 導致os沒有close

正確的寫法：

 
 
 
    
  
  
  
  1. try {  
    2. 
  
  
  
  2. is = new FileInputStream(inFile);  
    3. 
  
  
  
  3. os = new FileOutputStream(outFile);  
    4. 
  
  
  
  4. } finally {  
    5. 
  
  
  
  5. try { if (is != null) is.close(); } catch(IOException e) {/* we can't do anything */}  
    6. 
  
  
  
  6. try { if (os != null) os.close(); } catch(IOException e) {/* we can't do anything */}  
    7. 
  
  
  
  7. } 
    8.

捕獲不可能出現(xiàn)的異常

錯誤的寫法：

 
 
 
    
  
  
  
  1. try {  
    2. 
  
  
  
  2. ... do risky stuff ...  
    3. 
  
  
  
  3. } catch(SomeException e) {  
    4. 
  
  
  
  4. // never happens  
    5. 
  
  
  
  5. }  
    6. 
  
  
  
  6. ... do some more ... 
    7.

正確的寫法：

 
 
 
    
  
  
  
  1. try {  
    2. 
  
  
  
  2. ... do risky stuff ...  
    3. 
  
  
  
  3. } catch(SomeException e) {  
    4. 
  
  
  
  4. // never happens hopefully  
    5. 
  
  
  
  5. throw new IllegalStateException(e.getMessage(), e); // crash early, passing all information  
    6. 
  
  
  
  6. }  
    7. 
  
  
  
  7. ... do some more ... 
    8.

transient的誤用

錯誤的寫法：

 
 
 
    
  
  
  
  1. public class A implements Serializable {  
    2. 
  
  
  
  2. private String someState;  
    3. 
  
  
  
  3. private transient Log log = LogFactory.getLog(getClass());  
    4. 
  
  
  
  4. 
  
  
  
  5. public void f() {  
    6. 
  
  
  
  6. log.debug("enter f");  
    7. 
  
  
  
  7. ...  
    8. 
  
  
  
  8. }  
    9. 
  
  
  
  9. } 
    10.

這里的本意是不希望Log對象被序列化. 不過這里在反序列化時, 會因為log未初始化, 導致f()方法拋空指針, 正確的做法是將log定義為靜態(tài)變量或者定位為具備變量。

正確的寫法：

 
 
 
    
  
  
  
  1. public class A implements Serializable {  
    2. 
  
  
  
  2. private String someState;  
    3. 
  
  
  
  3. private static final Log log = LogFactory.getLog(A.class);  
    4. 
  
  
  
  4. 
  
  
  
  5. public void f() {  
    6. 
  
  
  
  6. log.debug("enter f");  
    7. 
  
  
  
  7. ...  
    8. 
  
  
  
  8. }  
    9. 
  
  
  
  9. }  
    10. 
  
  
  
  10. public class A implements Serializable {  
    11. 
  
  
  
  11. private String someState;  
    12. 
  
  
  
  12. 
  
  
  
  13. public void f() {  
    14. 
  
  
  
  14. Log log = LogFactory.getLog(getClass());  
    15. 
  
  
  
  15. log.debug("enter f");  
    16. 
  
  
  
  16. ...  
    17. 
  
  
  
  17. }  
    18. 
  
  
  
  18. } 
    19.

不必要的初始化

錯誤的寫法：

 
 
 
    
  
  
  
  1. public class B {  
    2. 
  
  
  
  2. private int count = 0;  
    3. 
  
  
  
  3. private String name = null;  
    4. 
  
  
  
  4. private boolean important = false;  
    5. 
  
  
  
  5. } 
    6.

這里的變量會在初始化時使用默認值:0, null, false, 因此上面的寫法有些多此一舉。

正確的寫法：

 
 
 
    
  
  
  
  1. public class B {  
    2. 
  
  
  
  2. private int count;  
    3. 
  
  
  
  3. private String name;  
    4. 
  
  
  
  4. private boolean important;  
    5. 
  
  
  
  5. } 
    6.

最好用靜態(tài)final定義Log變量

 
 
 
    
  
  
  
  1. private static final Log log = LogFactory.getLog(MyClass.class); 
    2.

這樣做的好處有三：

  • 可以保證線程安全
  • 靜態(tài)或非靜態(tài)代碼都可用
  • 不會影響對象序列化

選擇錯誤的類加載器

錯誤的代碼：

 
 
 
    
  
  
  
  1. Class clazz = Class.forName(name);  
    2. 
  
  
  
  2. Class clazz = getClass().getClassLoader().loadClass(name); 
    3.

這里本意是希望用當前類來加載希望的對象, 但是這里的getClass()可能拋出異常, 特別在一些受管理的環(huán)境中, 比如應(yīng)用服務(wù)器, web容器, Java WebStart環(huán)境中, 最好的做法是使用當前應(yīng)用上下文的類加載器來加載。

正確的寫法：

 
 
 
    
  
  
  
  1. ClassLoader cl = Thread.currentThread().getContextClassLoader();  
    2. 
  
  
  
  2. if (cl == null) cl = MyClass.class.getClassLoader(); // fallback  
    3. 
  
  
  
  3. Class clazz = cl.loadClass(name); 
    4.

反射使用不當

錯誤的寫法：

 
 
 
    
  
  
  
  1. Class beanClass = ...  
    2. 
  
  
  
  2. if (beanClass.newInstance() instanceof TestBean) ... 
    3.

這里的本意是檢查beanClass是否是TestBean或是其子類, 但是創(chuàng)建一個類實例可能沒那么簡單, 首先實例化一個對象會帶來一定的消耗, 另外有可能類沒有定義默認構(gòu)造函數(shù). 正確的做法是用Class.isAssignableFrom(Class) 方法。

正確的寫法：

 
 
 
    
  
  
  
  1. Class beanClass = ...  
    2. 
  
  
  
  2. if (TestBean.class.isAssignableFrom(beanClass)) ... 
    3.

不必要的同步

錯誤的寫法：

 
 
 
    
  
  
  
  1. Collection l = new Vector();  
    2. 
  
  
  
  2. for (...) {  
    3. 
  
  
  
  3. l.add(object);  
    4. 
  
  
  
  4. } 
    5.

Vector是ArrayList同步版本。

正確的寫法：

 
 
 
    
  
  
  
  1. Collection l = new ArrayList();  
    2. 
  
  
  
  2. for (...) {  
    3. 
  
  
  
  3. l.add(object);  
    4. 
  
  
  
  4. } 
    5.

錯誤的選擇List類型

根據(jù)下面的表格數(shù)據(jù)來進行選擇

  ArrayList LinkedList
add (append) O(1) or ~O(log(n)) if growing O(1)
insert (middle) O(n) or ~O(n*log(n)) if growing O(n)
remove (middle) O(n) (always performs complete copy) O(n)
iterate O(n) O(n)
get by index O(1) O(n)

 HashMap size陷阱

錯誤的寫法：

 
 
 
    
  
  
  
  1. Map map = new HashMap(collection.size()); 
    2. 
  
  
  
  2. for (Object o : collection) { 
    3. 
  
  
  
  3.   map.put(o.key, o.value); 
    4. 
  
  
  
  4. }
    5.

這里可以參考guava的Maps.newHashMapWithExpectedSize的實現(xiàn). 用戶的本意是希望給HashMap設(shè)置初始值, 避免擴容(resize)的開銷. 但是沒有考慮當添加的元素數(shù)量達到HashMap容量的75%時將出現(xiàn)resize。

正確的寫法：

 
 
 
    
  
  
  
  1. Map map = new HashMap(1 + (int) (collection.size() / 0.75));
    2.

對Hashtable, HashMap 和 HashSet了解不夠

這里主要需要了解HashMap和Hashtable的內(nèi)部實現(xiàn)上, 它們都使用Entry包裝來封裝key/value, Entry內(nèi)部除了要保存Key/Value的引用, 還需要保存hash桶中next Entry的應(yīng)用, 因此對內(nèi)存會有不小的開銷, 而HashSet內(nèi)部實現(xiàn)其實就是一個HashMap. 有時候IdentityHashMap可以作為一個不錯的替代方案. 它在內(nèi)存使用上更有效(沒有用Entry封裝, 內(nèi)部采用Object[]). 不過需要小心使用. 它的實現(xiàn)違背了Map接口的定義. 有時候也可以用ArrayList來替換HashSet.

這一切的根源都是由于JDK內(nèi)部沒有提供一套高效的Map和Set實現(xiàn)。

對List的誤用

建議下列場景用Array來替代List:

  • list長度固定，比如一周中的每一天
  • 對list頻繁的遍歷，比如超過1w次
  • 需要對數(shù)字進行包裝(主要JDK沒有提供基本類型的List)

比如下面的代碼。

錯誤的寫法：

 
 
 
    
  
  
  
  1. List codes = new ArrayList(); 
    2. 
  
  
  
  2. codes.add(Integer.valueOf(10)); 
    3. 
  
  
  
  3. codes.add(Integer.valueOf(20)); 
    4. 
  
  
  
  4. codes.add(Integer.valueOf(30)); 
    5. 
  
  
  
  5. codes.add(Integer.valueOf(40));
    6.

正確的寫法：

 
 
 
    
  
  
  
  1. int[] codes = { 10, 20, 30, 40 };
    2.

 錯誤的寫法：

 
 
 
    
  
  
  
  1. // horribly slow and a memory waster if l has a few thousand elements (try it yourself!) 
    2. 
  
  
  
  2. List l = ...; 
    3. 
  
  
  
  3. for (int i=0; i < l.size()-1; i++) { 
    4. 
  
  
  
  4.     Mergeable one = l.get(i); 
    5. 
  
  
  
  5.     Iterator j = l.iterator(i+1); // memory allocation! 
    6. 
  
  
  
  6.     while (j.hasNext()) { 
    7. 
  
  
  
  7.         Mergeable other = l.next(); 
    8. 
  
  
  
  8.         if (one.canMergeWith(other)) { 
    9. 
  
  
  
  9.             one.merge(other); 
    10. 
  
  
  
  10.             other.remove(); 
    11. 
  
  
  
  11.         } 
    12. 
  
  
  
  12.     } 
    13. 
  
  
  
  13. }
    14.

正確的寫法：

 
 
 
    
  
  
  
  1. // quite fast and no memory allocation 
    2. 
  
  
  
  2. Mergeable[] l = ...; 
    3. 
  
  
  
  3. for (int i=0; i < l.length-1; i++) { 
    4. 
  
  
  
  4.     Mergeable one = l[i]; 
    5. 
  
  
  
  5.     for (int j=i+1; j < l.length; j++) { 
    6. 
  
  
  
  6.         Mergeable other = l[j]; 
    7. 
  
  
  
  7.         if (one.canMergeWith(other)) { 
    8. 
  
  
  
  8.             one.merge(other); 
    9. 
  
  
  
  9.             l[j] = null; 
    10. 
  
  
  
  10.         } 
    11. 
  
  
  
  11.     } 
    12. 
  
  
  
  12. }
    13.

實際上Sun也意識到這一點, 因此在JDK中, Collections.sort()就是將一個List拷貝到一個數(shù)組中然后調(diào)用Arrays.sort方法來執(zhí)行排序。

用數(shù)組來描述一個結(jié)構(gòu)

錯誤用法：

 
 
 
    
  
  
  
  1. /**  
    2. 
  
  
  
  2. * @returns [1]: Location, [2]: Customer, [3]: Incident  
    3. 
  
  
  
  3. */  
    4. 
  
  
  
  4. Object[] getDetails(int id) {... 
    5.

這里用數(shù)組+文檔的方式來描述一個方法的返回值. 雖然很簡單, 但是很容易誤用, 正確的做法應(yīng)該是定義個類。

正確的寫法：

 
 
 
    
  
  
  
  1. Details getDetails(int id) {...}  
    2. 
  
  
  
  2. private class Details {  
    3. 
  
  
  
  3. public Location location;  
    4. 
  
  
  
  4. public Customer customer;  
    5. 
  
  
  
  5. public Incident incident;  
    6. 
  
  
  
  6. } 
    7.

對方法過度限制

錯誤用法：

 
 
 
    
  
  
  
  1. public void notify(Person p) {  
    2. 
  
  
  
  2. ...  
    3. 
  
  
  
  3. sendMail(p.getName(), p.getFirstName(), p.getEmail());  
    4. 
  
  
  
  4. ...  
    5. 
  
  
  
  5. }  
    6. 
  
  
  
  6. class PhoneBook {  
    7. 
  
  
  
  7. String lookup(String employeeId) {  
    8. 
  
  
  
  8. Employee emp = ...  
    9. 
  
  
  
  9. return emp.getPhone();  
    10. 
  
  
  
  10. }  
    11. 
  
  
  
  11. } 
    12.

第一個例子是對方法參數(shù)做了過多的限制, 第二個例子對方法的返回值做了太多的限制。

正確的寫法：

 
 
 
    
  
  
  
  1. public void notify(Person p) {  
    2. 
  
  
  
  2. ...  
    3. 
  
  
  
  3. sendMail(p);  
    4. 
  
  
  
  4. ...  
    5. 
  
  
  
  5. }  
    6. 
  
  
  
  6. class EmployeeDirectory {  
    7. 
  
  
  
  7. Employee lookup(String employeeId) {  
    8. 
  
  
  
  8. Employee emp = ...  
    9. 
  
  
  
  9. return emp;  
    10. 
  
  
  
  10. }  
    11. 
  
  
  
  11. }
    12.

對POJO的setter方法畫蛇添足

錯誤的寫法：

 
 
 
    
  
  
  
  1. private String name;  
    2. 
  
  
  
  2. public void setName(String name) {  
    3. 
  
  
  
  3. this.name = name.trim();  
    4. 
  
  
  
  4. }  
    5. 
  
  
  
  5. public void String getName() {  
    6. 
  
  
  
  6. return this.name;  
    7. 
  
  
  
  7. } 
    8.

有時候我們很討厭字符串首尾出現(xiàn)空格, 所以在setter方法中進行了trim處理, 但是這樣做的結(jié)果帶來的副作用會使getter方法的返回值和setter方法不一致, 如果只是將JavaBean當做一個數(shù)據(jù)容器, 那么最好不要包含任何業(yè)務(wù)邏輯. 而將業(yè)務(wù)邏輯放到專門的業(yè)務(wù)層或者控制層中處理。

正確的做法：

 
 
 
    
  
  
  
  1. person.setName(textInput.getText().trim()); 
    2.

日歷對象(Calendar)誤用

錯誤的寫法：

 
 
 
    
  
  
  
  1. Calendar cal = new GregorianCalender(TimeZone.getTimeZone("Europe/Zurich"));  
    2. 
  
  
  
  2. cal.setTime(date);  
    3. 
  
  
  
  3. cal.add(Calendar.HOUR_OF_DAY, 8);  
    4. 
  
  
  
  4. date = cal.getTime(); 
    5.

這里主要是對date, time, calendar和time zone不了解導致. 而在一個時間上增加8小時, 跟time zone沒有任何關(guān)系, 所以沒有必要使用Calendar, 直接用Date對象即可, 而如果是增加天數(shù)的話, 則需要使用Calendar, 因為采用不同的時令制可能一天的小時數(shù)是不同的(比如有些DST是23或者25個小時)

正確的寫法：

 
 
 
    
  
  
  
  1. date = new Date(date.getTime() + 8L * 3600L * 1000L); // add 8 hrs 
    2.

TimeZone的誤用

錯誤的寫法：

 
 
 
    
  
  
  
  1. Calendar cal = new GregorianCalendar();  
    2. 
  
  
  
  2. cal.setTime(date);  
    3. 
  
  
  
  3. cal.set(Calendar.HOUR_OF_DAY, 0);  
    4. 
  
  
  
  4. cal.set(Calendar.MINUTE, 0);  
    5. 
  
  
  
  5. cal.set(Calendar.SECOND, 0);  
    6. 
  
  
  
  6. Date startOfDay = cal.getTime(); 
    7.

這里有兩個錯誤, 一個是沒有沒有將毫秒歸零, 不過最大的錯誤是沒有指定TimeZone, 不過一般的桌面應(yīng)用沒有問題, 但是如果是服務(wù)器端應(yīng)用則會有一些問題, 比如同一時刻在上海和倫敦就不一樣, 因此需要指定的TimeZone.

正確的寫法：

 
 
 
    
  
  
  
  1. Calendar cal = new GregorianCalendar(user.getTimeZone());  
    2. 
  
  
  
  2. cal.setTime(date);  
    3. 
  
  
  
  3. cal.set(Calendar.HOUR_OF_DAY, 0);  
    4. 
  
  
  
  4. cal.set(Calendar.MINUTE, 0);  
    5. 
  
  
  
  5. cal.set(Calendar.SECOND, 0);  
    6. 
  
  
  
  6. cal.set(Calendar.MILLISECOND, 0);  
    7. 
  
  
  
  7. Date startOfDay = cal.getTime(); 
    8.

時區(qū)(Time Zone)調(diào)整的誤用

錯誤的寫法：

 
 
 
    
  
  
  
  1. public static Date convertTz(Date date, TimeZone tz) {  
    2. 
  
  
  
  2. Calendar cal = Calendar.getInstance();  
    3. 
  
  
  
  3. cal.setTimeZone(TimeZone.getTimeZone("UTC"));  
    4. 
  
  
  
  4. cal.setTime(date);  
    5. 
  
  
  
  5. cal.setTimeZone(tz);  
    6. 
  
  
  
  6. return cal.getTime();  
    7. 
  
  
  
  7. } 
    8.

這個方法實際上沒有改變時間, 輸入和輸出是一樣的. 關(guān)于時間的問題可以參考這篇文章: http://www.odi.ch/prog/design/datetime.php 這里主要的問題是Date對象并不包含Time Zone信息. 它總是使用UTC(世界統(tǒng)一時間). 而調(diào)用Calendar的getTime/setTime方法會自動在當前時區(qū)和UTC之間做轉(zhuǎn)換。

Calendar.getInstance()的誤用

錯誤的寫法：

 
 
 
    
  
  
  
  1. Calendar c = Calendar.getInstance();  
    2. 
  
  
  
  2. c.set(2009, Calendar.JANUARY, 15); 
    3.

Calendar.getInstance()依賴local來選擇一個Calendar實現(xiàn), 不同實現(xiàn)的2009年是不同的, 比如有些Calendar實現(xiàn)就沒有January月份。

正確的寫法：

 
 
 
    
  
  
  
  1. Calendar c = new GregorianCalendar(timeZone);  
    2. 
  
  
  
  2. c.set(2009, Calendar.JANUARY, 15); 
    3.

Date.setTime()的誤用

錯誤的寫法：

 
 
 
    
  
  
  
  1. account.changePassword(oldPass, newPass);  
    2. 
  
  
  
  2. Date lastmod = account.getLastModified();  
    3. 
  
  
  
  3. lastmod.setTime(System.currentTimeMillis()); 
    4.

在更新密碼之后, 修改一下最后更新時間, 這里的用法沒有錯,但是有更好的做法: 直接傳Date對象. 因為Date是Value Object, 不可變的. 如果更新了Date的值, 實際上是生成一個新的Date實例. 這樣其他地方用到的實際上不在是原來的對象, 這樣可能出現(xiàn)不可預(yù)知的異常. 當然這里又涉及到另外一個OO設(shè)計的問題, 對外暴露Date實例本身就是不好的做法(一般的做法是在setter方法中設(shè)置Date引用參數(shù)的clone對象). 另外一種比較好的做法就是直接保存long類型的毫秒數(shù)。

正確的做法：

 
 
 
    
  
  
  
  1. account.changePassword(oldPass, newPass);  
    2. 
  
  
  
  2. account.setLastModified(new Date()); 
    3.

SimpleDateFormat非線程安全誤用

錯誤的寫法：

 
 
 
    
  
  
  
  1. public class Constants {  
    2. 
  
  
  
  2. public static final SimpleDateFormat date = new SimpleDateFormat("dd.MM.yyyy");  
    3. 
  
  
  
  3. } 
    4.

SimpleDateFormat不是線程安全的. 在多線程并行處理的情況下, 會得到非預(yù)期的值. 這個錯誤非常普遍! 如果真要在多線程環(huán)境下公用同一個SimpleDateFormat, 那么做好做好同步(cache flush, lock contention), 但是這樣會搞得更復雜, 還不如直接new一個實在。

使用全局參數(shù)配置常量類/接口

 
 
 
    
  
  
  
  1. public interface Constants {  
    2. 
  
  
  
  2. String version = "1.0";  
    3. 
  
  
  
  3. String dateFormat = "dd.MM.yyyy";  
    4. 
  
  
  
  4. String configFile = ".apprc";  
    5. 
  
  
  
  5. int maxNameLength = 32;  
    6. 
  
  
  
  6. String someQuery = "SELECT * FROM ...";  
    7. 
  
  
  
  7. } 
    8.

很多應(yīng)用都會定義這樣一個全局常量類或接口, 但是為什么這種做法不推薦? 因為這些常量之間基本沒有任何關(guān)聯(lián), 只是因為公用才定義在一起. 但是如果其他組件需要使用這些全局變量, 則必須對該常量類產(chǎn)生依賴, 特別是存在server和遠程client調(diào)用的場景。

比較好的做法是將這些常量定義在組件內(nèi)部. 或者局限在一個類庫內(nèi)部。

忽略造型溢出(cast overflow)

錯誤的寫法：

 
 
 
    
  
  
  
  1. public int getFileSize(File f) {  
    2. 
  
  
  
  2. long l = f.length();  
    3. 
  
  
  
  3. return (int) l;  
    4. 
  
  
  
  4. } 
    5.

這個方法的本意是不支持傳遞超過2GB的文件. 最好的做法是對長度進行檢查, 溢出時拋出異常。

正確的寫法：

 
 
 
    
  
  
  
  1. public int getFileSize(File f) {  
    2. 
  
  
  
  2. long l = f.length();  
    3. 
  
  
  
  3. if (l > Integer.MAX_VALUE) throw new IllegalStateException("int overflow");  
    4. 
  
  
  
  4. return (int) l;  
    5. 
  
  
  
  5. } 
    6.

另一個溢出bug是cast的對象不對, 比如下面第一個println. 正確的應(yīng)該是下面的那個。

 
 
 
    
  
  
  
  1. long a = System.currentTimeMillis();  
    2. 
  
  
  
  2. long b = a + 100;  
    3. 
  
  
  
  3. System.out.println((int) b-a);  
    4. 
  
  
  
  4. System.out.println((int) (b-a)); 
    5.

對float和double使用==操作

錯誤的寫法：

 
 
 
    
  
  
  
  1. for (float f = 10f; f!=0; f-=0.1) {  
    2. 
  
  
  
  2. System.out.println(f);  
    3. 
  
  
  
  3. } 
    4.

上面的浮點數(shù)遞減只會無限接近0而不會等于0, 這樣會導致上面的for進入死循環(huán). 通常絕不要對float和double使用==操作. 而采用大于和小于操作. 如果java編譯器能針對這種情況給出警告. 或者在java語言規(guī)范中不支持浮點數(shù)類型的==操作就最好了。

正確的寫法：

 
 
 
    
  
  
  
  1. for (float f = 10f; f>0; f-=0.1) {  
    2. 
  
  
  
  2. System.out.println(f);  
    3. 
  
  
  
  3. } 
    4.

用浮點數(shù)來保存money

錯誤的寫法：

 
 
 
    
  
  
  
  1. float total = 0.0f;  
    2. 
  
  
  
  2. for (OrderLine line : lines) {  
    3. 
  
  
  
  3. total += line.price * line.count;  
    4. 
  
  
  
  4. }  
    5. 
  
  
  
  5. double a = 1.14 * 75; // 85.5 將表示為 85.4999...  
    6. 
  
  
  
  6. System.out.println(Math.round(a)); // 輸出值為85  
    7. 
  
  
  
  7. BigDecimal d = new BigDecimal(1.14); //造成精度丟失 
    8.

這個也是一個老生常談的錯誤. 比如計算100筆訂單, 每筆0.3元, 最終的計算結(jié)果是29.9999971. 如果將float類型改為double類型, 得到的結(jié)果將是30.000001192092896. 出現(xiàn)這種情況的原因是, 人類和計算的計數(shù)方式不同. 人類采用的是十進制, 而計算機是二進制.二進制對于計算機來說非常好使, 但是對于涉及到精確計算的場景就會帶來誤差. 比如銀行金融中的應(yīng)用。

因此絕不要用浮點類型來保存money數(shù)據(jù). 采用浮點數(shù)得到的計算結(jié)果是不精確的. 即使與int類型做乘法運算也會產(chǎn)生一個不精確的結(jié)果.那是因為在用二進制存儲一個浮點數(shù)時已經(jīng)出現(xiàn)了精度丟失. 最好的做法就是用一個string或者固定點數(shù)來表示. 為了精確, 這種表示方式需要指定相應(yīng)的精度值.
BigDecimal就滿足了上面所說的需求. 如果在計算的過程中精度的丟失超出了給定的范圍, 將拋出runtime exception.

正確的寫法：

 
 
 
    
  
  
  
  1. BigDecimal total = BigDecimal.ZERO;  
    2. 
  
  
  
  2. for (OrderLine line : lines) {  
    3. 
  
  
  
  3. BigDecimal price = new BigDecimal(line.price);  
    4. 
  
  
  
  4. BigDecimal count = new BigDecimal(line.count);  
    5. 
  
  
  
  5. total = total.add(price.multiply(count)); // BigDecimal is immutable!  
    6. 
  
  
  
  6. }  
    7. 
  
  
  
  7. total = total.setScale(2, RoundingMode.HALF_UP);  
    8. 
  
  
  
  8. BigDecimal a = (new BigDecimal("1.14")).multiply(new BigDecimal(75)); // 85.5 exact  
    9. 
  
  
  
  9. a = a.setScale(0, RoundingMode.HALF_UP); // 86  
    10. 
  
  
  
  10. System.out.println(a); // correct output: 86  
    11. 
  
  
  
  11. BigDecimal a = new BigDecimal("1.14"); 
    12.

不使用finally塊釋放資源

錯誤的寫法：

 
 
 
    
  
  
  
  1. public void save(File f) throws IOException {  
    2. 
  
  
  
  2. OutputStream out = new BufferedOutputStream(new FileOutputStream(f));  
    3. 
  
  
  
  3. out.write(...);  
    4. 
  
  
  
  4. out.close();  
    5. 
  
  
  
  5. }  
    6. 
  
  
  
  6. public void load(File f) throws IOException {  
    7. 
  
  
  
  7. InputStream in = new BufferedInputStream(new FileInputStream(f));  
    8. 
  
  
  
  8. in.read(...);  
    9. 
  
  
  
  9. in.close();  
    10. 
  
  
  
  10. } 
    11.

上面的代碼打開一個文件輸出流, 操作系統(tǒng)為其分配一個文件句柄, 但是文件句柄是一種非常稀缺的資源, 必須通過調(diào)用相應(yīng)的close方法來被正確的釋放回收. 而為了保證在異常情況下資源依然能被正確回收, 必須將其放在finally block中. 上面的代碼中使用了BufferedInputStream將file stream包裝成了一個buffer stream, 這樣將導致在調(diào)用close方法時才會將buffer stream寫入磁盤. 如果在close的時候失敗, 將導致寫入數(shù)據(jù)不完全. 而對于FileInputStream在finally block的close操作這里將直接忽略。

如果BufferedOutputStream.close()方法執(zhí)行順利則萬事大吉, 如果失敗這里有一個潛在的bug(http://bugs.sun.com/view_bug.do?bug_id=6335274): 在close方法內(nèi)部調(diào)用flush操作的時候, 如果出現(xiàn)異常, 將直接忽略. 因此為了盡量減少數(shù)據(jù)丟失, 在執(zhí)行close之前顯式的調(diào)用flush操作。

下面的代碼有一個小小的瑕疵: 如果分配file stream成功, 但是分配buffer stream失敗(OOM這種場景), 將導致文件句柄未被正確
新聞名稱：Java編程：常見問題匯總
文章起源：http://www.dlmjj.cn/article/dhssogc.html