(bad)

long startTime = System.currentTimeMillis();
// ...
long elapsedTime = System.currentTimeMillis() - startTime;

The approach is based on an intuitive assumption that the values returned by currentTimeMillis() (in general, the current system time expressed as a number of milliseconds since midnight, January 1, 1970 UTC) grow smoothly and always are greater in the future than in the past. This is not always the case.

A simple example when this assumption fails is adjusting the system clock. On the most of the modern systems, correction of the clock is performed automatically by polling a value from the NTP server in a specific period of time. If this correction happens in the middle of your operation, the measured time interval will be wrong or even negative. Note that the typical computer clocks have an error in tens or even hundreds of milliseconds per hour that means that the correction offset will be up to few seconds if it is performed once a day.

It is safer to use the System.nanoTime() method which does not depend on a system clock, so it’s guaranteed that its value grows smoothly from the past to the future:

(good)

long startTime = System.nanoTime();
// ...
long elapsedTime = (System.nanoTime() - startTime) / 1000000; // ms

And remember that the nanoTime values has nothing to do with any real absolute time, so don’t try to use it for the Date objects, for instance.

See also: Inside the Hotspot VM: Clocks, Timers and Scheduling Events

(submitted by Rand McNeely)

(submitted by Robert J. Walker)

For instance, URL.equals() would consider the URL of this blog (http://javaantipatterns.wordpress.com) to be equal to an URL of any random blog hosted on WordPress – that is obviously not true.

It is recommended to use java.net.URI objects instead.

P.S.
java.net.URL class is an absolute champion in a number of implemented antipatterns of equals() (and hashCode() as well):

• It lies
• It is incostistent
• It is slow and breakable

“For any reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false” [*]

“Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer” [*]

Violating those contracts may cause all kinds of weird and unpredictable behavior.

A known example of this antipattern is equals() and hashCode() in java.net.URL implementation where they are depending on information returned by a domain name server, rather than on actual stored URL data.

See also:

• Using URLs in Collections

Bad:

System.out.println("Author: "+person.getName());

Good:

class Person {
    ...
    public String toString() {
        return this.getName();
    }
}
...
System.out.println("Author: "+person);

It is guaranteed that two Boolean instances and Integers between -128 and 127 to be pre-cached, thus you definitely should not use the constructor to instantiate them.

Bad:

Integer i = new Integer(0);
Boolean b = new Boolean(true);

Good:

Integer i = Integer.valueOf(0);
Boolean b = Boolean.valueOf(true); // or Boolean.TRUE

Bad:

InputStream in = new FileInputStream(f); 
int b; 
while ((b = in.read()) != -1) {    
    ... 
}   

Good:

InputStream in = new BufferedInputStream(new FileInputStream(f));
...

Bad:

class Person {
    ...
    public boolean equals(Object o) {
        return (o instanceof Person) && 
               this.getName().equals(((Person)o).getName());
    }
    ...
}

Good:

class Person {
    ...
    public boolean equals(Object o) {
        return (o != null) && 
               (o instanceof Person) && 
               this.getName().equals(((Person)o).getName());
    }
    ...
}

class Product implements Comparable
    ...
    public int compareTo(Object o) {
        if (o == null)
            throw new NullPointerException();
        if (this.equals(o))
            return 0;
        ...    
    }
}

See also:

• ‘equals()’ is overriden while ‘hashCode()’ is not