實現equals()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class Person { String name; int birthYear; byte [] raw; public boolean equals(Object obj) { if (!obj instanceof Person) return false ; Person other = (Person)obj; return name.equals(other.name) && birthYear == other.birthYear && Arrays.equals(raw, other.raw); } public int hashCode() { ... } } |
參數必須是Object類型,不能是外圍類。
foo.equals(null) 必須返回false,不能拋NullPointerException。(注意,null instanceof 任意類 總是返回false,因此上面的代碼可以運行。)
基本類型域(比如,int)的比較使用 == ,基本類型數組域的比較使用Arrays.equals()。
覆蓋equals()時,記得要相應地覆蓋 hashCode(),與 equals() 保持一致。
參考: java.lang.Object.equals(Object)。
實現hashCode()
1
2
3
4
5
6
7
8
9
10
11
12
|
class Person { String a; Object b; byte c; int [] d; public int hashCode() { return a.hashCode() + b.hashCode() + c + Arrays.hashCode(d); } public boolean equals(Object o) { ... } } |
當x和y兩個對象具有x.equals(y) == true ,你必須要確保x.hashCode() == y.hashCode()。
根據逆反命題,如果x.hashCode() != y.hashCode(),那麼x.equals(y) == false 必定成立。
你不需要保證,當x.equals(y) == false時,x.hashCode() != y.hashCode()。但是,如果你可以儘可能地使它成立的話,這會提高哈希表的性能。
hashCode()最簡單的合法實現就是簡單地return 0;雖然這個實現是正確的,但是這會導致HashMap這些數據結構運行得很慢。
參考:java.lang.Object.hashCode()。
實現compareTo()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class Person implements Comparable<Person> { String firstName; String lastName; int birthdate; // Compare by firstName, break ties by lastName, finally break ties by birthdate public int compareTo(Person other) { if (firstName.compareTo(other.firstName) != 0 ) return firstName.compareTo(other.firstName); else if (lastName.compareTo(other.lastName) != 0 ) return lastName.compareTo(other.lastName); else if (birthdate < other.birthdate) return - 1 ; else if (birthdate > other.birthdate) return 1 ; else return 0 ; } } |
總是實現泛型版本 Comparable 而不是實現原始類型 Comparable 。因爲這樣可以節省代碼量和減少不必要的麻煩。
只關心返回結果的正負號(負/零/正),它們的大小不重要。
Comparator.compare()的實現與這個類似。
參考:java.lang.Comparable。
實現clone()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class Values implements Cloneable { String abc; double foo; int [] bars; Date hired; public Values clone() { try { Values result = (Values) super .clone(); result.bars = result.bars.clone(); result.hired = result.hired.clone(); return result; } catch (CloneNotSupportedException e) { // Impossible throw new AssertionError(e); } } } |
使用 super.clone() 讓Object類負責創建新的對象。
基本類型域都已經被正確地複製了。同樣,我們不需要去克隆String和BigInteger等不可變類型。
手動對所有的非基本類型域(對象和數組)進行深度複製(deep copy)。
實現了Cloneable的類,clone()方法永遠不要拋CloneNotSupportedException。因此,需要捕獲這個異常並忽略它,或者使用不受檢異常(unchecked exception)包裝它。
不使用Object.clone()方法而是手動地實現clone()方法是可以的也是合法的。
參考:java.lang.Object.clone()、java.lang.Cloneable()。
使用StringBuilder或StringBuffer
1
2
3
4
5
6
7
8
9
10
11
|
// join(["a", "b", "c"]) -> "a and b and c" String join(List<String> strs) { StringBuilder sb = new StringBuilder(); boolean first = true ; for (String s : strs) { if (first) first = false ; else sb.append( " and " ); sb.append(s); } return sb.toString(); } |
不要像這樣使用重複的字符串連接:s += item ,因爲它的時間效率是O(n^2)。
使用StringBuilder或者StringBuffer時,可以使用append()方法添加文本和使用toString()方法去獲取連接起來的整個文本。
優先使用StringBuilder,因爲它更快。StringBuffer的所有方法都是同步的,而你通常不需要同步的方法。
參考java.lang.StringBuilder、java.lang.StringBuffer。
生成一個範圍內的隨機整數
1
2
3
4
5
6
|
Random rand = new Random(); // Between 1 and 6, inclusive int diceRoll() { return rand.nextInt( 6 ) + 1 ; } |
總是使用Java API方法去生成一個整數範圍內的隨機數。
不要試圖去使用 Math.abs(rand.nextInt()) % n 這些不確定的用法,因爲它的結果是有偏差的。此外,它的結果值有可能是負數,比如當rand.nextInt() == Integer.MIN_VALUE時就會如此。
參考:java.util.Random.nextInt(int)。
使用Iterator.remove()
1
2
3
4
5
6
7
|
void filter(List<String> list) { for (Iterator<String> iter = list.iterator(); iter.hasNext(); ) { String item = iter.next(); if (...) iter.remove(); } } |
remove()方法作用在next()方法最近返回的條目上。每個條目只能使用一次remove()方法。
參考:java.util.Iterator.remove()。
返轉字符串
1
2
3
|
String reverse(String s) { return new StringBuilder(s).reverse().toString(); } |
這個方法可能應該加入Java標準庫。
參考:java.lang.StringBuilder.reverse()。
啓動一條線程
下面的三個例子使用了不同的方式完成了同樣的事情。
實現Runnnable的方式:
1
2
3
4
5
6
7
8
9
|
void startAThread0() { new Thread( new MyRunnable()).start(); } class MyRunnable implements Runnable { public void run() { ... } } |
繼承Thread的方式:
1
2
3
4
5
6
7
8
9
|
void startAThread1() { new MyThread().start(); } class MyThread extends Thread { public void run() { ... } } |
匿名繼承Thread的方式:
1
2
3
4
5
6
7
|
void startAThread2() { new Thread() { public void run() { ... } }.start(); } |
不要直接調用run()方法。總是調用Thread.start()方法,這個方法會創建一條新的線程並使新建的線程調用run()。
參考:java.lang.Thread, java.lang.Runnable。
使用try-finally
I/O流例子:
1
2
3
4
5
6
7
8
|
void writeStuff() throws IOException { OutputStream out = new FileOutputStream(...); try { out.write(...); } finally { out.close(); } } |
鎖例子:
1
2
3
4
5
6
7
8
|
void doWithLock(Lock lock) { lock.acquire(); try { ... } finally { lock.release(); } } |
如果try之前的語句運行失敗並且拋出異常,那麼finally語句塊就不會執行。但無論怎樣,在這個例子裏不用擔心資源的釋放。
如果try語句塊裏面的語句拋出異常,那麼程序的運行就會跳到finally語句塊裏執行儘可能多的語句,然後跳出這個方法(除非這個方法還有另一個外圍的finally語句塊)。
從輸入流裏讀取字節數據
1
2
3
4
5
6
7
8
9
10
11
|
InputStream in = (...); try { while ( true ) { int b = in.read(); if (b == - 1 ) break ; (... process b ...) } } finally { in.close(); } |
read()方法要麼返回下一次從流裏讀取的字節數(0到255,包括0和255),要麼在達到流的末端時返回-1。
參考:java.io.InputStream.read()。
從輸入流裏讀取塊數據
1
2
3
4
5
6
7
8
9
10
11
12
|
InputStream in = (...); try { byte [] buf = new byte [ 100 ]; while ( true ) { int n = in.read(buf); if (n == - 1 ) break ; (... process buf with offset= 0 and length=n ...) } } finally { in.close(); } |
要記住的是,read()方法不一定會填滿整個buf,所以你必須在處理邏輯中考慮返回的長度。
參考: java.io.InputStream.read(byte[])、java.io.InputStream.read(byte[], int, int)。
從文件裏讀取文本
1
2
3
4
5
6
7
8
9
10
11
12
|
BufferedReader in = new BufferedReader( new InputStreamReader( new FileInputStream(...), "UTF-8" )); try { while ( true ) { String line = in.readLine(); if (line == null ) break ; (... process line ...) } } finally { in.close(); } |
BufferedReader對象的創建顯得很冗長。這是因爲Java把字節和字符當成兩個不同的概念來看待(這與C語言不同)。
你可以使用任何類型的InputStream來代替FileInputStream,比如socket。
當達到流的末端時,BufferedReader.readLine()會返回null。
要一次讀取一個字符,使用Reader.read()方法。
你可以使用其他的字符編碼而不使用UTF-8,但最好不要這樣做。
參考:java.io.BufferedReader、java.io.InputStreamReader。
向文件裏寫文本
1
2
3
4
5
6
7
8
9
|
PrintWriter out = new PrintWriter( new OutputStreamWriter( new FileOutputStream(...), "UTF-8" )); try { out.print( "Hello " ); out.print( 42 ); out.println( " world!" ); } finally { out.close(); } |
Printwriter對象的創建顯得很冗長。這是因爲Java把字節和字符當成兩個不同的概念來看待(這與C語言不同)。
就像System.out,你可以使用print()和println()打印多種類型的值。
你可以使用其他的字符編碼而不使用UTF-8,但最好不要這樣做。
參考:java.io.PrintWriter、java.io.OutputStreamWriter。
預防性檢測(Defensive checking)數值
1
2
3
4
5
6
7
8
9
10
|
int factorial( int n) { if (n < 0 ) throw new IllegalArgumentException( "Undefined" ); else if (n >= 13 ) throw new ArithmeticException( "Result overflow" ); else if (n == 0 ) return 1 ; else return n * factorial(n - 1 ); } |
不要認爲輸入的數值都是正數、足夠小的數等等。要顯式地檢測這些條件。
一個設計良好的函數應該對所有可能性的輸入值都能夠正確地執行。要確保所有的情況都考慮到了並且不會產生錯誤的輸出(比如溢出)。
預防性檢測對象
1
2
3
4
5
|
int findIndex(List<String> list, String target) { if (list == null || target == null ) throw new NullPointerException(); ... } |
不要認爲對象參數不會爲空(null)。要顯式地檢測這個條件。
預防性檢測數組索引
1
2
3
4
5
6
7
|
void frob( byte [] b, int index) { if (b == null ) throw new NullPointerException(); if (index < 0 || index >= b.length) throw new IndexOutOfBoundsException(); ... } |
不要認爲所以給的數組索引不會越界。要顯式地檢測它。
預防性檢測數組區間
1
2
3
4
5
6
7
8
|
void frob( byte [] b, int off, int len) { if (b == null ) throw new NullPointerException(); if (off < 0 || off > b.length || len < 0 || b.length - off < len) throw new IndexOutOfBoundsException(); ... } |
不要認爲所給的數組區間(比如,從off開始,讀取len個元素)是不會越界。要顯式地檢測它。
填充數組元素
使用循環:
1
2
3
4
|
// Fill each element of array 'a' with 123 byte [] a = (...); for ( int i = 0 ; i < a.length; i++) a[i] = 123 ; |
(優先)使用標準庫的方法:
Arrays.fill(a, (byte)123);
參考:java.util.Arrays.fill(T[], T)。
參考:java.util.Arrays.fill(T[], int, int, T)。
複製一個範圍內的數組元素
使用循環:
1
2
3
4
5
6
7
|
// Copy 8 elements from array 'a' starting at offset 3 // to array 'b' starting at offset 6, // assuming 'a' and 'b' are distinct arrays byte [] a = (...); byte [] b = (...); for ( int i = 0 ; i < 8 ; i++) b[ 6 + i] = a[ 3 + i]; |
(優先)使用標準庫的方法:
1
|
System.arraycopy(a, 3 , b, 6 , 8 ); |
參考:java.lang.System.arraycopy(Object, int, Object, int, int)。
調整數組大小
使用循環(擴大規模):
1
2
3
4
5
6
|
// Make array 'a' larger to newLen byte [] a = (...); byte [] b = new byte [newLen]; for ( int i = 0 ; i < a.length; i++) // Goes up to length of A b[i] = a[i]; a = b; |
使用循環(減小規模):
1
2
3
4
5
6
|
// Make array 'a' smaller to newLen byte [] a = (...); byte [] b = new byte [newLen]; for ( int i = 0 ; i < b.length; i++) // Goes up to length of B b[i] = a[i]; a = b; |
(優先)使用標準庫的方法:
1
|
a = Arrays.copyOf(a, newLen); |
參考:java.util.Arrays.copyOf(T[], int)。
參考:java.util.Arrays.copyOfRange(T[], int, int)。
把4個字節包裝(packing)成一個int
1
2
3
4
5
6
7
8
9
10
11
12
13
|
int packBigEndian( byte [] b) { return (b[ 0 ] & 0xFF ) << 24 | (b[ 1 ] & 0xFF ) << 16 | (b[ 2 ] & 0xFF ) << 8 | (b[ 3 ] & 0xFF ) << 0 ; } int packLittleEndian( byte [] b) { return (b[ 0 ] & 0xFF ) << 0 | (b[ 1 ] & 0xFF ) << 8 | (b[ 2 ] & 0xFF ) << 16 | (b[ 3 ] & 0xFF ) << 24 ; } |
把int分解(Unpacking)成4個字節
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
byte [] unpackBigEndian( int x) { return new byte [] { ( byte )(x >>> 24 ), ( byte )(x >>> 16 ), ( byte )(x >>> 8 ), ( byte )(x >>> 0 ) }; } byte [] unpackLittleEndian( int x) { return new byte [] { ( byte )(x >>> 0 ), ( byte )(x >>> 8 ), ( byte )(x >>> 16 ), ( byte )(x >>> 24 ) }; } |
總是使用無符號右移操作符(>>>)對位進行包裝(packing),不要使用算術右移操作符(>>)。