Java习惯用法总结

时间：2015-04-07 17:38:18 阅读：240 评论：0 收藏：0 [点我收藏+]

标签：

本文由 ImportNew - 进林翻译自 nayuki。欢迎加入翻译小组。转载请见文末要求。

在Java编程中，有些知识并不能仅通过语言规范或者标准API文档就能学到的。在本文中，我会尽量收集一些最常用的习惯用法，特别是很难猜到的用法。（Joshua Bloch的《Effective Java》对这个话题给出了更详尽的论述，可以从这本书里学习更多的用法。）

我把本文的所有代码都放在公共场所里。你可以根据自己的喜好去复制和修改任意的代码片段，不需要任何的凭证。

实现equals()

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()

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()

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()

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

//
 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。

生成一个范围内的随机整数

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()

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()。

返转字符串

String
 reverse(String s) {

  return

new 
StringBuilder(s).reverse().toString();

}

这个方法可能应该加入Java标准库。
参考：java.lang.StringBuilder.reverse()。

启动一条线程

下面的三个例子使用了不同的方式完成了同样的事情。

实现Runnnable的方式：

void

startAThread0() {

  new

Thread(new

MyRunnable()).start();

}

class

MyRunnable implements

Runnable {

  public

void 
run() {

    ...

  }

}

继承Thread的方式：

void

startAThread1() {

  new

MyThread().start();

}

class

MyThread extends

Thread {

  public

void 
run() {

    ...

  }

}

匿名继承Thread的方式：

void

startAThread2() {

  new

Thread() {

    public

void 
run() {

      ...

    }

  }.start();

}

不要直接调用run()方法。总是调用Thread.start()方法，这个方法会创建一条新的线程并使新建的线程调用run()。
参考：java.lang.Thread, java.lang.Runnable。

使用try-finally

I/O流例子：

void

writeStuff() throws

IOException {

  OutputStream
 out = new

FileOutputStream(...);

  try

{

    out.write(...);

  }
finally

{

    out.close();

  }

}

锁例子：

void

doWithLock(Lock lock) {

  lock.acquire();

  try

{

    ...

  }
finally

{

    lock.release();

  }

}

如果try之前的语句运行失败并且抛出异常，那么finally语句块就不会执行。但无论怎样，在这个例子里不用担心资源的释放。
如果try语句块里面的语句抛出异常，那么程序的运行就会跳到finally语句块里执行尽可能多的语句，然后跳出这个方法（除非这个方法还有另一个外围的finally语句块）。

从输入流里读取字节数据

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()。

从输入流里读取块数据

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)。

从文件里读取文本

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。

向文件里写文本

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）数值

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);

}

不要认为输入的数值都是正数、足够小的数等等。要显式地检测这些条件。
一个设计良好的函数应该对所有可能性的输入值都能够正确地执行。要确保所有的情况都考虑到了并且不会产生错误的输出（比如溢出）。

预防性检测对象

int

findIndex(List<String> list, String target) {

  if

(list == null

|| target == null)

    throw

new 
NullPointerException();

  ...

}

不要认为对象参数不会为空（null）。要显式地检测这个条件。

预防性检测数组索引

void

frob(byte[]
 b, int

index) {

  if

(b == null)

    throw

new 
NullPointerException();

  if

(index < 0

|| index >= b.length)

    throw

new 
IndexOutOfBoundsException();

  ...

}

不要认为所以给的数组索引不会越界。要显式地检测它。

预防性检测数组区间

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个元素）是不会越界。要显式地检测它。

填充数组元素

使用循环：

//
 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)。

复制一个范围内的数组元素

使用循环：

//
 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];

（优先）使用标准库的方法：

System.arraycopy(a, 3, b, 6, 8);

参考：java.lang.System.arraycopy(Object, int, Object, int, int)。

调整数组大小

使用循环（扩大规模）：

//
 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;

使用循环（减小规模）：

// 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;

（优先）使用标准库的方法：

a
 = Arrays.copyOf(a, newLen);

参考：java.util.Arrays.copyOf(T[], int)。
参考：java.util.Arrays.copyOfRange(T[], int, int)。

把4个字节包装（packing）成一个int

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个字节

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），不要使用算术右移操作符（>>）。

原文链接： nayuki 翻译： ImportNew.com - 进林
译文链接： http://www.importnew.com/15605.html
[ 转载请保留原文出处、译者和译文链接。]

Java习惯用法总结

标签：

原文地址：http://blog.csdn.net/g__hk/article/details/44922733

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行

Java习惯用法总结

目录

实现equals()

实现hashCode()

实现compareTo()

实现clone()

使用StringBuilder或StringBuffer

生成一个范围内的随机整数

使用Iterator.remove()

返转字符串

启动一条线程

使用try-finally

从输入流里读取字节数据

从输入流里读取块数据

从文件里读取文本

向文件里写文本

预防性检测（Defensive checking）数值

预防性检测对象

预防性检测数组索引

预防性检测数组区间

填充数组元素

复制一个范围内的数组元素

调整数组大小

把4个字节包装（packing）成一个int

把int分解（Unpacking）成4个字节