2. 程式人生 > >java 良好的程式設計習慣

java 良好的程式設計習慣

阿新 • • 發佈：2019-02-20

一：良好的程式設計習慣

1.避免在迴圈結構中使用複製表示式

int count = list.size();

for(int i=0;i<count;i++)

2.在finally塊中關閉stream 

程式中使用到的資源，應當被釋放，以免資源洩露，這最好在finally 中操作。不管程式執行結果如何，確保資源正確關閉。

3.使用System.arraycopy() 代替迴圈複製陣列。

例子： 

public class irb
{
    void method () {
        int[] array1 = new int [100];
        for (int i = 0; i < array1.length; i++) {
            array1 [i] = i;
        }
        int[] array2 = new int [100];
        for (int i = 0; i < array2.length; i++) {
            array2 [i] = array1 [i];                 // violation
        }
    }
}


更正： 
public class irb
{
    void method () {
        int[] array1 = new int [100];
        for (int i = 0; i < array1.length; i++) {
            array1 [i] = i;
        }
        int[] array2 = new int [100];
        system.arraycopy(array1, 0, array2, 0, 100);
    }
}
4.讓訪問例項內變數的getter/setter 方法變成final 
簡單的gettter/setter 方法應該被設定成final ,這會告訴編譯器，這個方法不會被過載。所以可以變成final
例子： 
class maf {
    public void setsize (int size) {
         _size = size;
    }
    private int _size;
}


更正： 
class daf_fixed {
    final public void setsize (int size) {
         _size = size;
    }
    private int _size;
}
5.避免不必要的instanceof 操作
如果左邊的物件的靜態型別等譯右邊的，instanceof表示式永遠都會放回true

例子：         


public class uiso {
    public uiso () {}
}
class dog extends uiso {
    void method (dog dog, uiso u) {
        dog d = dog;
        if (d instanceof uiso) // always true.
            system.out.println("dog is a uiso");
        uiso uiso = u;
        if (uiso instanceof object) // always true.
            system.out.println("uiso is an object");
    }
}


更正：         
刪掉不需要的instanceof操作。 

class dog extends uiso {
    void method () {
        dog d;
        system.out.println ("dog is an uiso");
        system.out.println ("uiso is an uiso");
    }
}

6.避免不必要的造型操作

所有的類都是直接或間接的繼承自Object ,同樣所有的子類都隱含的等於其父類。那麼子類造型至父類的操作就是不必要的了。

八、如果只是查詢單個字元的話，用charat()代替startswith()

用一個字元作為引數呼叫startswith()也會工作的很好，但從效能角度上來看，呼叫用string api無疑是錯誤的! 

例子： 

public class pcts {
    private void method(string s) {
        if (s.startswith("a")) { // violation
            // ...
        }
    }
}


更正         
將'startswith()' 替換成'charat()'. 
public class pcts {
    private void method(string s) {
        if ('a' == s.charat(0)) {
            // ...
        }
    }
}


參考資料： 
dov bulka, "java performance and scalability volume 1: server-side programming 
techniques"  addison wesley, isbn: 0-201-70429-3 
九、使用移位操作來代替'a / b'操作

"/"是一個很“昂貴”的操作，使用移位操作將會更快更有效。 

例子： 
public class sdiv {
    public static final int num = 16;
    public void calculate(int a) {
        int div = a / 4;            // should be replaced with "a >> 2".
        int div2 = a / 8;         // should be replaced with "a >> 3".
        int temp = a / 3;
    }
}


更正： 
public class sdiv {
    public static final int num = 16;
    public void calculate(int a) {
        int div = a >> 2;  
        int div2 = a >> 3;
        int temp = a / 3;       // 不能轉換成位移操作
    }
}


十、使用移位操作代替'a * b'

同上。 
[i]但我個人認為，除非是在一個非常大的迴圈內，效能非常重要，而且你很清楚你自己在做什麼，方可使用這種方法。否則提高效能所帶來的程式晚讀性的降低將是不合算的。 

例子： 
public class smul {
    public void calculate(int a) {
        int mul = a * 4;            // should be replaced with "a << 2".
        int mul2 = 8 * a;         // should be replaced with "a << 3".
        int temp = a * 3;
    }
}


更正： 
package opt;
public class smul {
    public void calculate(int a) {
        int mul = a << 2;  
        int mul2 = a << 3;
        int temp = a * 3;       // 不能轉換
    }
}


十一、在字串相加的時候，使用 ' ' 代替 " "，如果該字串只有一個字元的話


例子： 
public class str {
    public void method(string s) {
        string string = s + "d"  // violation.
        string = "abc" + "d"      // violation.
    }
}

更正： 
將一個字元的字串替換成' ' 
public class str {
    public void method(string s) {
        string string = s + 'd'
        string = "abc" + 'd'   
    }
}

十二、不要在迴圈中呼叫synchronized(同步)方法

方法的同步需要消耗相當大的資料，在一個迴圈中呼叫它絕對不是一個好主意。 

例子： 
import java.util.vector;
public class syn {
    public synchronized void method (object o) {
    }
    private void test () {
        for (int i = 0; i < vector.size(); i++) {
            method (vector.elementat(i));    // violation
        }
    }
    private vector vector = new vector (5, 5);
}


更正： 
不要在迴圈體中呼叫同步方法，如果必須同步的話，推薦以下方式： 
import java.util.vector;
public class syn {
    public void method (object o) {
    }
private void test () {
    synchronized{//在一個同步塊中執行非同步方法
            for (int i = 0; i < vector.size(); i++) {
                method (vector.elementat(i));   
            }
        }
    }
    private vector vector = new vector (5, 5);
}


十三、將try/catch塊移出迴圈

把try/catch塊放入迴圈體內，會極大的影響效能，如果編譯jit被關閉或者你所使用的是一個不帶jit的jvm，效能會將下降21%之多! 

例子：         
import java.io.fileinputstream;
public class try {
    void method (fileinputstream fis) {
        for (int i = 0; i < size; i++) {
            try {                                      // violation
                _sum += fis.read();
            } catch (exception e) {}
        }
    }
    private int _sum;
}


更正：         
將try/catch塊移出迴圈         
 void method (fileinputstream fis) {
        try {
            for (int i = 0; i < size; i++) {
                _sum += fis.read();
            }
        } catch (exception e) {}
    }


參考資料： 
peter haggar: "practical java - programming language guide". 
addison wesley, 2000, pp.81 – 83 

十四、對於boolean值，避免不必要的等式判斷

將一個boolean值與一個true比較是一個恆等操作(直接返回該boolean變數的值). 移走對於boolean的不必要操作至少會帶來2個好處： 
1)程式碼執行的更快 (生成的位元組碼少了5個位元組)； 
2)程式碼也會更加乾淨 。 

例子： 
public class ueq
{
    boolean method (string string) {
        return string.endswith ("a") == true;   // violation
    }
}


更正： 
class ueq_fixed
{
    boolean method (string string) {
        return string.endswith ("a");
    }
}


十五、對於常量字串，用'string' 代替 'stringbuffer'

常量字串並不需要動態改變長度。 
例子： 
public class usc {
    string method () {
        stringbuffer s = new stringbuffer ("hello");
        string t = s + "world!";
        return t;
    }
}


更正： 
把stringbuffer換成string，如果確定這個string不會再變的話，這將會減少執行開銷提高效能。 

十六、用'stringtokenizer' 代替 'indexof()' 和'substring()'

字串的分析在很多應用中都是常見的。使用indexof()和substring()來分析字串容易導致 stringindexoutofboundsexception。而使用stringtokenizer類來分析字串則會容易一些，效率也會高一些。 

例子： 
public class ust {
    void parsestring(string string) {
        int index = 0;
        while ((index = string.indexof(".", index)) != -1) {
            system.out.println (string.substring(index, string.length()));
        }
    }
}

參考資料： 
graig larman, rhett guthrie: "java 2 performance and idiom guide" 
prentice hall ptr, isbn: 0-13-014260-3 pp. 282 – 283 

十七、使用條件操作符替代"if (cond) return; else return;" 結構

條件操作符更加的簡捷 
例子： 
public class if {
    public int method(boolean isdone) {
        if (isdone) {
            return 0;
        } else {
            return 10;
        }
    }
}


更正： 
public class if {
    public int method(boolean isdone) {
        return (isdone ? 0 : 10);
    }
}

十八、使用條件操作符代替"if (cond) a = b; else a = c;" 結構

例子： 
public class ifas {
    void method(boolean istrue) {
        if (istrue) {
            _value = 0;
        } else {
            _value = 1;
        }
    }
    private int _value = 0;
}


更正： 
public class ifas {
    void method(boolean istrue) {
        _value = (istrue ? 0 : 1);       // compact expression.
    }
    private int _value = 0;
}

十九、不要在迴圈體中例項化變數

在迴圈體中例項化臨時變數將會增加記憶體消耗 

例子：         
import java.util.vector;
public class loop {
    void method (vector v) {
        for (int i=0;i < v.size();i++) {
            object o = new object();
            o = v.elementat(i);
        }
    }
}


更正：         
在迴圈體外定義變數，並反覆使用         
import java.util.vector;
public class loop {
    void method (vector v) {
        object o;
        for (int i=0;i<v.size();i++) {
            o = v.elementat(i);
        }
    }
}


二十、確定 stringbuffer的容量

stringbuffer的構造器會建立一個預設大小(通常是16)的字元陣列。在使用中，如果超出這個大小，就會重新分配記憶體，建立一個更大的陣列，並將原先的陣列複製過來，再丟棄舊的陣列。在大多數情況下，你可以在建立stringbuffer的時候指定大小，這樣就避免了在容量不夠的時候自動增長，以提高效能。 

例子：         
public class rsbc {
    void method () {
        stringbuffer buffer = new stringbuffer(); // violation
        buffer.append ("hello");
    }
}


更正：         
為stringbuffer提供寢大小。         
public class rsbc {
    void method () {
        stringbuffer buffer = new stringbuffer(max);
        buffer.append ("hello");
    }
    private final int max = 100;
}


參考資料： 
dov bulka, "java performance and scalability volume 1: server-side programming 
techniques" addison wesley, isbn: 0-201-70429-3 p.30 – 31 

二十一、儘可能的使用棧變數

如果一個變數需要經常訪問，那麼你就需要考慮這個變數的作用域了。static? local?還是例項變數？訪問靜態變數和例項變數將會比訪問區域性變數多耗費2-3個時鐘週期。 

例子： 
public class usv {
    void getsum (int[] values) {
        for (int i=0; i < value.length; i++) {
            _sum += value[i];           // violation.
        }
    }
    void getsum2 (int[] values) {
        for (int i=0; i < value.length; i++) {
            _staticsum += value[i];
        }
    }
    private int _sum;
    private static int _staticsum;
}


更正：         
如果可能，請使用區域性變數作為你經常訪問的變數。 
你可以按下面的方法來修改getsum()方法：         
void getsum (int[] values) {
    int sum = _sum;  // temporary local variable.
    for (int i=0; i < value.length; i++) {
        sum += value[i];
    }
    _sum = sum;
}


參考資料：         
peter haggar: "practical java - programming language guide". 
addison wesley, 2000, pp.122 – 125 

二十二、不要總是使用取反操作符(!)

取反操作符(!)降低程式的可讀性，所以不要總是使用。 

例子： 
public class dun {
    boolean method (boolean a, boolean b) {
        if (!a)
            return !a;
        else
            return !b;
    }
}


更正： 
如果可能不要使用取反操作符(!) 

二十三、與一個介面 進行instanceof操作

基於介面的設計通常是件好事，因為它允許有不同的實現，而又保持靈活。只要可能，對一個物件進行instanceof操作，以判斷它是否某一介面要比是否某一個類要快。 

例子： 
public class insof {
    private void method (object o) {
        if (o instanceof interfacebase) { }  // better
        if (o instanceof classbase) { }   // worse.
    }
}

class classbase {}
interface interfacebase {}

二．資料庫優化

Hibernate

批量處理其實從效能上考慮，它是很不可取的，浪費了很大的記憶體。

從它的機制上講，

Hibernate

它是先把符合條件的資料查出來，放到記憶體當中，

然後再進行操作。實際使用下來效能非常不理想。解決方案可分為以下四種：

 1

：繞過

Hibernate API 

，直接通過

 JDBC API 

來做，這個方法效能上是比

較好的。也是最快的

. 

2

：運用儲存過程。代價是移植性降低

    3

：快取。對於構建的業務系統，如果有些資料要經常要從資料庫中讀取，

同時，這些資料又不經常變化，這些資料就可以在系統中快取起來，使

用時直接讀取快取，而不用頻繁的訪問資料庫讀取資料。快取工作可以

在系統初始化時一次性讀取資料，特別是一些只讀的資料，當資料更新

時更新資料庫內容，同時更新快取的資料值。

     4

：增加資料庫連線池的大小。

三．

Java

虛擬機器堆和垃圾回收設定

任何

Java

應用的效能調整基礎都涉及到堆的大小和垃圾回收設定。

二．資料庫優化

Hibernate

批量處理其實從效能上考慮，它是很不可取的，浪費了很大的記憶體。

從它的機制上講，

Hibernate

它是先把符合條件的資料查出來，放到記憶體當中，

然後再進行操作。實際使用下來效能非常不理想。解決方案可分為以下四種：

 1

：繞過

Hibernate API 

，直接通過

 JDBC API 

來做，這個方法效能上是比

較好的。也是最快的

. 

2

：運用儲存過程。代價是移植性降低

    3

：快取。對於構建的業務系統，如果有些資料要經常要從資料庫中讀取，

同時，這些資料又不經常變化，這些資料就可以在系統中快取起來，使

用時直接讀取快取，而不用頻繁的訪問資料庫讀取資料。快取工作可以

在系統初始化時一次性讀取資料，特別是一些只讀的資料，當資料更新

時更新資料庫內容，同時更新快取的資料值。

     4

：增加資料庫連線池的大小。

三．

Java

虛擬機器堆和垃圾回收設定

任何

Java

應用的效能調整基礎都涉及到堆的大小和垃圾回收設定。



相關推薦

養成良好程式設計習慣

·寧願名字長，也不要寫讀不懂的函式、變數名 ·每個概念對應一個名稱（controller，manager，driver，有什麼區別？） ·不要新增沒用的語境（字首） 函式 ·儘量短小，只完成一件事！！無副作用 ·函式名：動詞（引數：名詞） ·儘量減少看程式時回去讀函式宣告

C語言的良好程式設計習慣

從程式設計菜鳥一路走來，慢慢對程式設計習慣有了一個新的認識。因為曾經我寫的程式碼的可讀性令自己也感到哭啼皆非，搞得自己暈頭轉向。今天特意來分享一下自己的一些關於程式設計習慣的心得。 很多人以為程式碼一敲完，能得到預期的結果，就萬事ok，其實不然。後面的程式除錯、維護和升級是

養成良好的程式設計習慣（Java, python）

最開始用python 的時候一直覺得自己的程式碼沒有別人的好看，很容易一個迴圈語句寫的很長很長。看起來特別費勁。其原因就是一開始編寫程式碼的時候沒有很好的組織，資料結構不熟悉。常常想著“程式就跑一次，這樣應該差不多了”。最終走了不少彎路。還有很多彎路影響更大了，例如辦公室的

Google Java程式設計風格指南（獻給那些沒有良好編碼習慣的程式設計師們）

前言 這份文件是Google Java程式設計風格規範的完整定義。當且僅當一個Java原始檔符合此文件中的規則， 我們才認為它符合Google的Java程式設計風格。 與其它的程式設計風格指南一樣，這裡所討論的不僅僅是編碼格式美不美觀的問題， 同時也討論一些約定及編碼標準。然而，這份文件主要側重於我們所

java 良好的程式設計習慣

一：良好的程式設計習慣 1.避免在迴圈結構中使用複製表示式 int count = list.size(); for(int i=0;i<count;i++) 2.在finally塊中關閉stream  程式中使用到的資源，應當被釋放，以免資源洩露，這最好在fina

JAVA 如何判斷一個字串是否在一個字串陣列中？（好的程式設計習慣）

String[] str={"數學","語文","英語","物理","化學","生物"};System.out.print("地理");如何判斷“地理”這個字串是否在 str[] 這個陣列中？ p

15個良好的程式設計習慣

學習程式設計是有趣的和容易,但是寫好程式可以被證明是一個艱鉅的任務。在大多數情況下,我們發現自己不斷抓撓試圖瞭解我們寫的義大利麵條式程式碼,或者僅僅因為做很多改變新新增的小功能。 這些結果可以降低我們的信心,但事實上,他們可以通過適當的開發實踐來解決。這裡有1

java程式設計習慣注意

1.列列舉常量，定義常量使用大寫，少用魔鬼數字。 2.少用if括大片程式碼。 3.賦值時（不應寫多次重複程式碼），可使用三目運算子。 4.for迴圈遍歷多次時，可使用方法抽出。 5.使用中文欄位作為實體物件時（載入到jvm時，有可能出現編碼錯誤而不易發覺） 6.當大量if/e

良好的程式設計習慣

關閉資源.close()最好放在finally程式碼塊中，防止try中發生異常資源沒有關閉。 對String物件的.split()的使用地方超過一次，建議就賦值給物件。 字串拼接不建議使用：+，用S

瘦人想增肥，養成良好的習慣是第一步

參加 生活 有助於 如果 最好 日常生活 飲食 條件 不能 大部分瘦人消瘦其實都與日常生活中的不良習慣有關系，因此，想要改變消瘦的體型成功增肥，首先要從日常生活做起，養成好的習慣。 1、調理飲食 瘦人增肥必須調理飲食結構，攝入充足的營養素。因為身體消瘦往往是就是由營養不良

【轉】Java併發程式設計：同步容器

　　為了方便編寫出執行緒安全的程式，Java裡面提供了一些執行緒安全類和併發工具，比如：同步容器、併發容器、阻塞佇列、Synchronizer(比如CountDownLatch)。今天我們就來討論下同步容器。   一、為什麼會出現同步容器？ 　　在Java的集合容器框架中，主要有四大類別：Li

《JAVA併發程式設計實戰》避免活躍性危險

文章目錄 死鎖 鎖順序死鎖 動態的鎖順序死鎖 在協作物件之間發生的死鎖 開放呼叫 資源死鎖 死鎖的避免和診斷 支援定時的鎖 使用執行緒轉儲資訊來分析死鎖 其他活躍性危

《JAVA併發程式設計實戰》取消和關閉

文章目錄 引言 任務取消 中斷 中斷策略 響應中斷 示例：計時執行 通過Future來實現取消 處理不可中斷的阻塞 採用newTaskFor封裝非標準的取消 停止基於執行緒的服務

《JAVA併發程式設計實戰》任務執行

文章目錄 線上程中執行任務 序列執行任務 顯式的為任務建立執行緒 無限制建立執行緒的不足 Executor框架 示例：基於Executor的Web伺服器 執行策略 執行緒池 Exe

《JAVA併發程式設計實戰》基礎構建模組

文章目錄 同步容器類 同步容器類的問題 迭代器和ConcurrentModificationException 隱藏迭代器 併發容器 ConcurrentHashMap 額外的原子Map操作

《JAVA併發程式設計實戰》物件的組合

文章目錄 設計執行緒安全的類 找出構成物件狀態的所有變數 示例 找出約束狀態變數的不變性條件 例項封閉 java監視器模式 示例：車輛追蹤 執行緒安全性的委託

java併發程式設計之利用CAS保證操作的原子性

import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; public class Counter { private AtomicInteger at

java介面程式設計題

1、建立Person介面(即“人”)，它有setData()和getData()方法對“人”屬性name、sex和birthday賦值和獲得這些屬性組成的字串資訊。建立類Student實現Person介面，並對自己的“學生”屬性的成員變數sID、speciality設定值和獲得它們值所組成的字串

Java併發程式設計之CyclicBarrier

CyclicBarrier可以控制這樣的場景： 對多個執行緒，他們執行自己程式碼（執行run方法）的時間不一樣； 比如有3個執行緒，其run方法執行時間分別為1s, 2s, 3s。如果我們想在三個執行緒都完成自己的任務時執行相應的操作，CyclicBarrier就派上用場了。 寫了一

《C程式設計習慣》讀書筆記（1-6章）

最近在看兩本國人寫的書：C程式設計習慣、Linux C程式設計。越看越發現如獲至寶。有時真覺得，看國外的書，都能將晦澀概念深入淺出解釋通透，而國內的書，能切合國人的習慣來解釋和應用知識。以前只青睞國外的書，這兩本國內的電子書本來只想簡單瀏覽一遍鞏固基礎，現在越看越想做讀書筆記，因為實在是很多看似