15 Ways To Improve The Speed of Your Java Application
- February 2, 2023
- Tiempo de lectura . 8 min
- Autor: Yuniel Acosta
1. Avoid Use Of Multiple If-else Statements
Excessive use of conditional statements can negatively impact the performance of our code as the JVM must evaluate each condition every time it is executed. This issue can be compounded if these statements are used within looping structures such as for loops or while loops. To mitigate this, it is recommended to group conditions and use a single boolean result in the if statement. Additionally, switching to a switch statement from multiple if-else statements can improve performance, as switch statements offer better performance compared to if-else statements. However, it is crucial to weigh the impact on readability and maintainability before making a decision.
The sample is provided below as an example to avoid:
Example:
if(condition1){
if (condition2) {
if (condition3 || condition4) { execute ..}
else { execute..}
2. Avoid Using String Objects For Concatenation
Strings are immutable classes; objects created by the String class cannot be reused. Therefore, it is not recommended to use the ’+’ operator to concatenate large strings.
This will lead to multiple objects of type String
being created, resulting in increased usage of heap memory. In this case, we can use either StringBuilder
or StringBuffer
. StringBuilder
is preferable, as it has a performance advantage due to its non-synchronized methods.
The sample is provided below :
String query = str1 + str2 + str3;
3. Avoid Writing Long Methods
Follow the Single Responsibility Principle when writing code. This is beneficial for maintenance and performance, as large methods with too much processing can consume memory and CPU cycles during class loading and method calls. To reduce this, break methods into smaller ones at suitable logical points.
I suggest using PMD, FindBugs, or SonarQube plugins in your IDE. These plugins will alert you when the cognitive complexity of your methods exceeds a certain threshold.
4. Avoid Getting the Size of the Collection in the Loop
When iterating through any collection, get the size of the collection before the loop and never get it during the iteration. The following example should be avoided:
Example:
List<String> empListData = getEmpData();
for (int i = 0; i < empListData.size(); i++){
// execute code ..
}
5. Avoid Using BigInteger And BigDecimal Class
The BigDecimal
class provides accurate precision for decimal values. However, overusing this object can drastically reduce performance, especially when used to calculate values in a loop. BigInteger
and BigDecimal
require a large amount of memory to perform calculations.
If precision is not an issue or if we are certain the range of the calculated value will not exceed long
or double
, we can avoid using BigDecimal
and should use long
or double
with proper casting instead.
6. Use Primitive Types Wherever Possible
Primitive data types are preferable over objects since they are stored in stack memory, which is faster to access than heap memory. Whenever possible, use double
instead of Double
and int
instead of Integer
for faster data access.
7. Use Stored Procedures Instead of Queries
Writing stored procedures instead of complex and big queries is beneficial as they are stored as objects in the database and pre-compiled. This reduces the execution time compared to a query, which is compiled and executed every time it is called through the application.
The stored procedure has an advantage in data transfer and network traffic, as it does not need to transfer the complex query to the database server for execution each time.
8. Avoid Creating Big Objects Often
Certain classes act as data holders within the application, such as DB connection objects or session objects for the user after login. These objects are heavy and their creation should be avoided multiple times, as they use a lot of resources. To improve application performance, we should reuse these objects instead of creating them, as this will reduce memory usage.
We should use the Singleton pattern whenever possible to create a single instance of an object and reuse it when needed, or clone the object instead of creating a new one.
9. Use “contains” with caution in your Java applications
Lists
, ArrayLists
, and Vectors
all have a contains
method that allows programmers to check if a collection already has a similar object. When iterating through a large sample, it is often necessary to find a list of unique objects. The code for this might look like this:
ArrayList al = new ArrayList();
for (int i=0; i < vars.size(); i++) {
String obj = (String) vars.get(i);
if (!al.contains(obj)) {
al.add(obj);
}
}
Functionally, this code is fine. However, from a performance perspective, you are checking if the ArrayList
contains the object on every loop iteration. The contains
method scans the entire ArrayList
each time, so as the ArrayList
grows, the performance penalty increases.
Add all the samples to the ArrayList
first, then conduct a single duplicate check using a collection such as a HashSet
that inherently provides uniqueness. This will reduce the number of contains checks on the ArrayList
from potentially thousands to just one. Finally, create the unique ArrayList
.
ArrayList al = new ArrayList();
…
for (int i=0; i < vars.size(); i++) {
String obj = (String) vars.get(i);
al.add(obj);
}
al = removeDuplicates(al);
…
static ArrayList removeDuplicates(ArrayList list) {
if (list == null || list.size() == 0){
return list;
}
Set set = new HashSet(list);
list.clear();
list.addAll(set);
return list;
}
The table below illustrates the time difference between our original code and the modified code:
List Size | 100 | 1000 | 10000 | 100000 |
---|---|---|---|---|
Original Code | 0 ms | 5 ms | 171 ms | 49820 ms |
Modified Code | 0 ms | 1 ms | 7 ms | 28 ms |
10. Using PreparedStatement instead of Statement
We use JDBC API and classes to execute SQL
queries through the application. PreparedStatement
has an advantage over Statement
for parameterized query execution, as the PreparedStatement
object is compiled once and executed multiple times.
Statement
object on other hand is compiled and executed every time it is called. Also, the prepared statement object is safe to avoid SQL injection attacks .
11. Select Required Columns in a Query
When retrieving data from the database, we should use SELECT
queries to only get the necessary columns for further processing or displaying on the front end. Selecting too many columns can cause a delay in query execution at the database end and increase network traffic from the database to the application, which should be avoided. It is best to avoid using the asterisk (“*”) when selecting data from the database. As an example of what should be avoided, see the sample below:
Example:
select * from employee where emp_id = 100;
12. Use of Unnecessary Log Statements and Incorrect Log Levels
Logging is an essential part of any application and must be implemented efficiently to prevent performance issues caused by incorrect logging and log levels. We should avoid logging large objects into code. Logging should be restricted to specific parameters.
It is recommended to keep the logging level at higher levels such as DEBUG
and ERROR
, rather than INFO
. An example of what should be avoided is provided below:
Example:
Logger.debug("Employee info : " + emp.toString());
Logger.info("Method called for setting employee data:" + emp.getData());
13. Fetch the Data Using Joins
While retrieving data from multiple tables, it is essential to use joins correctly. Incorrect joins or non-normalized tables can cause a delay in query execution, resulting in poor application performance. Rather than using subqueries, it is more efficient to use joins. To improve query execution performance and reduce latency, create an index on columns that are frequently used. When using joins or WHERE clauses, prioritize primary keys.
14. Use EntrySet Rather Than KeySet
Iterating over a map with EntrySet
is more efficient than KeySet
. EntrySet
can run 9000 more operations per second, resulting in better performance.
15. EnumSet Is the Best Option for Enum Values
Working with EnumSet
makes more sense than other methods when dealing with Enum
values. It allows for faster computations than, for example, HashSet
. Additionally, EnumSet
stores values in a predictable order, which is not the case with HashSet
and thus takes longer to produce the same results.