Java idioms summary

In Java programming, some knowledge cannot be learned only through language specifications or standard API documentation. In this article, I will try to collect some of the most commonly used idioms, especially those that are difficult to guess. (Joshua Bloch's "Effective Java" gives a more detailed discussion on this topic, and you can learn more usage from this book.)

I have made all the code in this article available in a public place. You can copy and modify any code snippet as you like, no credentials are required.

Implementing 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() { ... }
 }

The parameter must be of type Object and cannot be of a peripheral class.

foo.equals(null) must return false and must not throw a NullPointerException. (Note that null instanceof any class always returns false, so the above code works.)

Primitive type fields (such as int) are compared using ==, and primitive type array fields are compared using Arrays.equals().

When overriding equals(), remember to override hashCode() accordingly to be consistent with equals().

Reference: java.lang.Object.equals(Object).

Implementing 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) { ... }
 }

When two objects x and y have x.equals(y) == true , you must ensure that x.hashCode() == y.hashCode().

By contraposition, if x.hashCode() != y.hashCode(), then x.equals(y) == false must hold.

You don't need to ensure that x.hashCode() != y.hashCode() when x.equals(y) == false. However, if you can make it as close to true as possible, it will improve the performance of your hash table.

The simplest legal implementation of hashCode() is to simply return 0; while this implementation is correct, it will cause data structures such as HashMap to run very slowly.

Reference: java.lang.Object.hashCode().

Implementing 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;
 }
 }

Always implement the generic version of Comparable instead of the original type Comparable, because it can save code and reduce unnecessary trouble.

Only the sign (negative/zero/positive) of the returned result matters, their magnitude is not important.

The implementation of Comparator.compare() is similar to this.

Reference: java.lang.Comparable.

#p#

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

Use super.clone() to let the Object class be responsible for creating new objects.

Primitive fields are correctly copied. Also, we don't need to clone immutable types like String and BigInteger.

Manually deep copy all non-primitive fields (objects and arrays).

For classes that implement Cloneable, the clone() method should never throw CloneNotSupportedException. Therefore, you need to catch this exception and ignore it, or wrap it with an unchecked exception.

It is possible and legal to implement the clone() method manually instead of using Object.clone().

Reference: java.lang.Object.clone(), java.lang.Cloneable().

Using StringBuilder or 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();
 }

Do not use repeated string concatenation like this: s += item , as it is O(n^2) in time efficiency.

When using StringBuilder or StringBuffer, you can use the append() method to add text and the toString() method to get the entire concatenated text.

Prefer StringBuilder because it is faster. All methods of StringBuffer are synchronized, and you usually don't need synchronized methods.

Refer to java.lang.StringBuilder, java.lang.StringBuffer.

Generate a random integer in a range

 Random rand = new Random();
 // Between 1 and 6, inclusive
 int diceRoll() {
 return rand.nextInt(6) + 1;
 }

Always use the Java API methods to generate a random number within an integer range.

Do not try to use Math.abs(rand.nextInt()) % n, as the result is biased. In addition, the result may be negative, such as when rand.nextInt() == Integer.MIN_VALUE.

Reference: java.util.Random.nextInt(int).

Using Iterator.remove()

 void filter(List<String> list) {
  for (Iterator<String> iter = list.iterator(); iter.hasNext(); ) {
    String item = iter.next();
 if (...)
 iter.remove();
 }
 }

The remove() method acts on the entry most recently returned by the next() method. The remove() method can only be used once per entry.

Reference: java.util.Iterator.remove().

Return string

 String reverse(String s) {
  return new StringBuilder(s).reverse().toString();
 }

This method should probably be added to the Java standard library.

Reference: java.lang.StringBuilder.reverse().

Start a thread

The following three examples use different methods to accomplish the same thing.

How to implement Runnnable:

 void startAThread0() {
  new Thread(new MyRunnable()).start();
 }
 class MyRunnable implements Runnable {
 public void run() {
 ...
 }
 }

Inherit Thread method:  

 void startAThread1() {
 new MyThread().start();
 }
 class MyThread extends Thread {
 public void run() {
 ...
 }
 }

Anonymous inheritance of Thread:  

 void startAThread2() {
 new Thread() {
 public void run() {
 ...
 }
 }.start();
 }

Do not call the run() method directly. Always call the Thread.start() method, which creates a new thread and makes the newly created thread call run().

Reference: java.lang.Thread, java.lang.Runnable.

#p#

Using try-finally

I/O stream example:

 void writeStuff() throws IOException {
  OutputStream out = new FileOutputStream(...);
 try {
 out.write(...);
 finally
 out.close();
 }
 }

Lock example:

 void doWithLock(Lock lock) {
 lock.acquire();
 try {
 ...
 finally
 lock.release();
 }
 }

If the statement before the try fails and throws an exception, the finally block will not be executed. But in any case, there is no need to worry about releasing resources in this example.

If the statement in the try block throws an exception, the program will jump to the finally block to execute as many statements as possible, and then jump out of the method (unless the method has another outer finally block).

Read bytes from the input stream

 InputStream in = (...);
 try {
 while (true) {
 int b = in.read();
 if (b == -1)
 break;
 (... process b ...)
 }
 finally
 in.close();
 }

The read() method either returns the next number of bytes to be read from the stream (0 to 255, inclusive), or returns -1 if the end of the stream is reached.

Reference: java.io.InputStream.read().

Read chunks of data from an input stream

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

Keep in mind that the read() method will not necessarily fill the entire buf, so you must account for the returned length in your processing logic.

Reference: java.io.InputStream.read(byte[]), java.io.InputStream.read(byte[], int, int).

Reading text from a file

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

The creation of the BufferedReader object is lengthy because Java treats bytes and characters as two different concepts (which is different from C).

You can use any type of InputStream instead of FileInputStream, such as socket.

When the end of the stream is reached, BufferedReader.readLine() returns null.

To read one character at a time, use the Reader.read() method.

You can use character encodings other than UTF-8, but you should not do so.

Reference: java.io.BufferedReader, java.io.InputStreamReader.

Writing text to a file

 PrintWriter out = new PrintWriter(
    new OutputStreamWriter(new FileOutputStream(...), "UTF-8"));
 try {
 out.print("Hello ");
 out.print(42);
 out.println(" world!");
 finally
 out.close();
 }

The creation of the Printwriter object is lengthy because Java treats bytes and characters as two different concepts (which is different from C).

Just like System.out, you can use print() and println() to print values ​​of many types.

You can use character encodings other than UTF-8, but you should not do so.

Reference: java.io.PrintWriter, java.io.OutputStreamWriter.

Defensive checking value

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

Don't assume that input values ​​are always positive, small enough, etc. Check these conditions explicitly.

A well-designed function should perform correctly for all possible input values. It should ensure that all cases are considered and that no incorrect output (such as overflow) is produced.

Preventive testing targets

 int findIndex(List<String> list, String target) {
  if (list == null || target == null)
    throw new NullPointerException();
 ...
 }

Do not assume that object parameters will not be null. Check for this condition explicitly.

#p#

Preventive detection array index

 void frob(byte[] b, int index) {
 if (b == null)
    throw new NullPointerException();
  if (index < 0 || index >= b.length)
    throw new IndexOutOfBoundsException();
 ...
 }

Don't assume that any given array index will not be out of bounds. Check for it explicitly.

Preventive detection of array intervals

 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();
 ...
 }

Do not assume that a given array range (e.g., starting at off and reading len elements) will not go out of bounds. Check it explicitly.

Filling array elements

Using loops:

 // Fill each element of array 'a' with 123
 byte[] a = (...);
 for (int i = 0; i < a.length; i++)
 a[i] = 123;

(Preferred) Method using the standard library:

 Arrays.fill(a, ( byte ) 123 );

Reference: java.util.Arrays.fill(T[], T).

Reference: java.util.Arrays.fill(T[], int, int, T).

Copies a range of array elements

Using loops:  

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

(Preferred) Method using the standard library:

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

Reference: java.lang.System.arraycopy(Object, int, Object, int, int).

Resizing an Array

Using a loop (scaling up):

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

Using a loop (reduced size):

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

(Preferred) Method using the standard library:

 a = Arrays.copyOf(a, newLen);

Reference: java.util.Arrays.copyOf(T[], int).

Reference: java.util.Arrays.copyOfRange(T[], int, int).

Packing 4 bytes into an 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 ;
 }

Unpacking an int into 4 bytes

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

Always use the unsigned right shift operator (>>>) for packing bits, never the arithmetic right shift operator (>>).

Original link: nayuki Translation: ImportNew.com - Jinlin Translation link: http://www.importnew.com/15605.html