In this article, I would like to discuss the Java best practices of important and most commonly used Java topics Strings, Generics, Collections, Exceptions, Enums, and Annotations.

In this article, I have summarized the best practices and there is a separate article to demonstrate each Java best practice with an example.

Let's get started!.

Java String Best Practices

Use StringBuilder or StringBuffer for string concatenations instead of the + operator.
Compare two string by equals() Method instead == operator
Call .equals() method on known string constants rather than unknown variable
Prefer switch( ) statement instead of multiple if-else-if.
Use String.valueOf() instead of toString()
Prefer StringUtility classes from different popular libraries because these utility classes are tested and well-known libraries.
Avoid Duplicate Literals - Code containing duplicate String literals can usually be improved by declaring the String as a constant field.
Using equalsIgnoreCase() is faster than using toUpperCase() or toLowerCase().equals()
Avoid concatenating characters as strings in StringBuffer/StringBuilder.append methods.
Consecutive calls to StringBuffer/StringBuilder.append should be chained, reusing the target object. This can improve the performance by producing a smaller bytecode, reducing overhead and improving inlining.

Each of the above String best practices are demonstrated with examples at Guide to String Best Practices in Java.

Java Collection Framework Best Practices

Choosing the right collection/map
Code for an interface, not for implementation
Use generic type and diamond operator
Prefer isEmpty() over a size()
Return empty collections or arrays, not nulls
Do not use the classic for loop
Favor using forEach() with Lambda expressions
Override equals() and hashCode() properly
Implementing the Comparable interface properly
Using Arrays and Collections utility classes
Prefer concurrent collections over synchronized wrappers
Use EnumSet instead of bit fields
Use EnumMap instead of ordinal indexing
Eliminate unchecked warnings

Each of the above Collections framework best practices are demonstrated with examples at Guide to String Best Practices in Java.

Java Exception Handling Best Practices

Clean up resources in a finally block or use a Try-With-Resource Statement
Throw Specific Exception
Do not catch the Exception class rather catch specific subclasses
Never catch a Throwable class
Always correctly wrap the exceptions in custom exceptions so that stack trace is not lost
Catch the most specific exception first
Don’t ignore exceptions rather log the exceptions
Never throw any exception from finally block
Don’t use printStackTrace() statement or similar methods
Use finally blocks instead of catch blocks if you are not going to handle the exception
Validate user input to catch adverse conditions very early in request processing
Throw exceptions with descriptive messages

Each of the above exception handling best practices demonstrated with examples at Java Collection Framework Best Practices

Java Generics Best Practices

Don’t use raw types
Eliminate unchecked warnings
Prefer Lists to Arrays
Favor Generic Types
Favor generic methods
Use Bounded Wildcards to Increase API Flexibility
Combine Generics and varargs Judiciously
Consider typesafe heterogeneous containers

Each of the above Generics best practices demonstrated with examples at Java Generics Best Practices

Java Enums and Annotations Best Practices

Use enums instead of int constants
Use instance fields instead of ordinals
Use EnumSet instead of bit fields
Use EnumMap instead of ordinal indexing
Emulate extensible enums with interfaces
Prefer annotations to name patterns
Consistently use the Override annotation
Use marker interfaces to define types

Each of the above enums and annotations best practices demonstrated with examples at Java Enums and Annotations Best Practices

Java Serialization Best Practices

Enable serialization compatibility during class evolution
Do not deviate from the proper signatures of serialization methods
Do not serialize unencrypted sensitive data
Do not serialize instances of inner classes
Do not invoke overridable methods from the readObject() method
Avoid memory and resource leaks during serialization
Prevent overwriting of externalizable objects
Prevent deserialization of untrusted data
Declare an explicit serial version UID in every serialization class you write

Each of the above Serialization best practices demonstrated with examples at Java Synchronization Best Practices

Java Standard Naming Conventions

We should follow these Java naming conventions in the day to day project work.

Let's discuss package, class, variable, method, constant, abstract class and exception class naming conventions with examples at Java Standard Naming Conventions