1.
Try, catch block should not be in loop (unless specifically
required).
2. All Collection API Classes should be specifically
reinitialized to null (since JVM has to specifically do it & GC spends much
time in doing these functions).
3.
Release JDBC resources when done with tasks.
4.
Use inner join instead of multiple queries.
5.
Optimize SQL queries.
6.
Always use Dynamic SQL (Prepare Statement) rather than the
static SQL like Statement.
7.
Try to avoid repeated DB calls to retrieve the same data.
Instead of that retrieve the data from the table and keep the data in Java
objects and use that in the subsequent call. (make Model class for that and use
getter, setter methods)
8.
Avoid Select * instead give the names of fields to be
selected in query (e.g. Select id,name from Student).
9.
Using getXX(int ColumnIndex) instead of getXX(String
columnName): Depending upon the no of columns in your resultSet, a getXX field
operation using column Index is two times as fast as than using Column Name.
10.
Do not use Vectors, instead of that use Collection classes
like ArrayList.
11.
Avoid using method call as loop termination test. E.g. Don’t
use list.size(), instead use store that in a temporary variable and then use
the temporary variable for testing loop termination test.
12.
Avoid throwing Exception in normal flow of execution since
try-catch-finally block is costly.
13.
Build proper WHERE clause in SQL SELECT for database
indexing. (In left of Join select table with less no of records).
14.
Try using java Collection classes instead of array.
15.
String Concatenation: Check that For String concatenation
use StringBuilder (JDK 1.5 has StringBuilder over StringBuffer) instead of
String ‘+’ operator.
16.
Debugging Statements: Do not use System.out.println or
printstackTrace(). Use log4j.debug() for debugging. In catch blocks add
log4.error() wherever applicable.
17.
Prepare Statement: Use prepared statement for retrieving
data when we have parameterized queries(insert, update, delete) else use
statements.
18.
Avoid object instantiation inside Loop. If possible create
object outside loop and reuse the same object inside the loop.
19.
Minimize object lifetimes. Keep the lifetimes of your data
as short as possible. Place the declaration in the most nested block that first
uses the data. If operator new is used, do the new just before the first use,
and the set the reference to null just after the last use.
20.
Minimum use of Session variables in the code instead set variables
in Request. Set session variables as null after use.
21.
The constants are not static we can make it final for better
performance(e.g. if we have fix value for variable than make it final private
void testMethod(final int id){}).
22.
Apply Transactions wherever necessary.
23.
Apply Query Caching if is required as per functionality.
24.
Minimize data conversions or Castings
25.
Try to use primitive java objects instead Wrapper classes as
like Wrapper classes (i.e. Integer) allocate large data amounts in memory.
26.
Replace a long if-else-if chain by a switch if possible;
this is much faster.
27.
Declaring a method as private, final, or static makes calls
to it faster. Of course, you should only do this when it makes sense in the
application.
28.
Do not add JavaScript directly in the JSP Code; instead
include JS File and include in Jsp (e.g <script
src=”include/common.js”></script>).
29.
Use STRUTS, JSTL specific UI Tag Library in JSP pages.
30.
Exceptions are taken care in the code and highest levels of
Exceptions are routed to Error Page; others are properly logged using logger.
