java 良好的編程習慣

一：良好的編程習慣

1.避免在循環結構中使用複製表達式

int count=list.size();

for(int i=0;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操作。

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-{}-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

int mul2=8 * a; // should be replaced with "a

int temp=a * 3;

}

}

更正：

package opt;

public class smul {

public void calculate(int a) {

int mul=a

int mul2=a

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類來分析字元串則會容易一些，效率也會高一些。

例子：

參考資料：

graig larman, rhett guthrie: "java 2 performance and idiom guide"

prentice hall ptr, isbn: 0-13-0{}-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) { object o; for (int i=0;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-{}-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

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

點擊展開全文

喜歡這篇文章嗎？立刻分享出去讓更多人知道吧！