Optimizing your Java code requires a proper analysis of how it works. There are several factors that affect performance optimization, like garbage collection, OS settings, and virtual machinery.

1. Start With Minimum Heap Allocation

I recommend that you start with minimum memory allocation. Then, you can gradually increase it depending upon the program requirements. You can instruct the JVM to dump the heap on an OutOfMemoryError exception by adding the following argument to the JVM:

-XX:+HeapDumpOnOutOfMemoryError

Proper utilization of the available memory is a great way to optimize for speed.

A heap size of 1GB to 7GB is sufficient to get started. It should depend on an old generation to new generation-object ratio.

2. Make Use of Java Performance Tools

There are several Java performance tools like VisualVM, YourKit, Java Mission Control, etc., which you can use to keep a track of your application performance.

The NetBeans profiler is also a great option. NetBeans IDE supports the development of all Java application types  Java SE (including JavaFX), Java ME, web, EJB, and mobile applications — out of the box.

3. Use a StringBuilder Rather Than the + Operator

The below code could come handy in place of two separate codes of StringBuilder:

StringBuilder x = new StringBuilder("a");
x.append(args.length);
x.append("b");
if (args.length == 1);
x.append(args[0]);

This makes any amendment easy without putting extra pressure on the GC.

4. Avoid Using Iterator

If we use a code like:

for (String value: strings) {
 // Do something useful here
}

Then every time we run this code, a new iterator instance will be created that will consume much of our memory.

Instead, the following code is recommended:

int size = strings.size();
for (int i = 0; i < size; i++) {
 String value: strings.get(i);
 // Do something useful here
}

…or, if your list doesn’t really change, you might even operate on an array version of it:

for (String value: stringArray) {
 // Do something useful here
}

Writing index-based iterations is extremely useful.

5. Have Better Concurrency Control

Concurrency is the ability to run multiple programs in parallel to each other.

For tackling multi-request web flows, it is recommended to use optimistic locking with detached entities or an EXTENDEDPersistence Context.

Moreover, it is essential to understand the inner workings of the relational database management system (RDBMS) and the data access frameworks in order to improve the performance of the data access layer.