By

文章目录
  1. 1. 使用equals()
  2. 2. 使用hashCode()
  3. 3. 使用compareTo()
  4. 4. 使用clone()
  5. 5. 使用StringBuilder或StringBuffer
  6. 6. 生成一个范围内的随机整数
  7. 7. 使用Iterator.remove()
  8. 8. 返转字符串
  9. 9. 启动一条线程
  10. 10. 继承Thread的方式：
  11. 11. 匿名继承Thread的方式：
  12. 12. 使用try-finally
  13. 13. 从输入流里读取字节数据
  14. 14. 从输入流里读取块数据
  15. 15. 从文件里读取文本
  16. 16. 向文件里写文本
  17. 17. 预防性检测对象
  18. 18. 预防性检测数组索引
  19. 19. 预防性检测数组区间
  20. 20. 填充数组元素
  21. 21. 复制一个范围内的数组元素
  22. 22. 调整数组大小
  23. 23. 把4个字节包装（packing）成一个int
  24. 24. 把int分解（Unpacking）成4个字节

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

           };

}s

总是使用无符号右移操作符（>>>）对位进行包装（packing），不要使用算术右移操作符（>>）。

Java
文章目录
  1. 1. 使用equals()
  2. 2. 使用hashCode()
  3. 3. 使用compareTo()
  4. 4. 使用clone()
  5. 5. 使用StringBuilder或StringBuffer
  6. 6. 生成一个范围内的随机整数
  7. 7. 使用Iterator.remove()
  8. 8. 返转字符串
  9. 9. 启动一条线程
  10. 10. 继承Thread的方式：
  11. 11. 匿名继承Thread的方式：
  12. 12. 使用try-finally
  13. 13. 从输入流里读取字节数据
  14. 14. 从输入流里读取块数据
  15. 15. 从文件里读取文本
  16. 16. 向文件里写文本
  17. 17. 预防性检测对象
  18. 18. 预防性检测数组索引
  19. 19. 预防性检测数组区间
  20. 20. 填充数组元素
  21. 21. 复制一个范围内的数组元素
  22. 22. 调整数组大小
  23. 23. 把4个字节包装（packing）成一个int
  24. 24. 把int分解（Unpacking）成4个字节