difference between connection.close() and connection= null - jdbc

Question

If I explicitly close the connection by calling close() on connection object, i have set connection object to null. What is difference in close() and null on connection object?
If i close connection ,still connection object maintained in connection pool?
for e.g.
Connection dbConnection=null;
PreparedStatement preparedStatement = null;
ResultSet rs;
try {
Connection dbConnection= DriverManager.getConnection("jdbc:hsqldb:file:test5","sa", "");
...........
...........
dbConnection.close();
dbConnection=null;
} catch (Exception e) {
LOGGER.error("Exception Occured while fetching All record:Item details start method "
+ e.getMessage());
} finally {
try
{
if (rs!=null)
{
rs.close();
rs=null;
}
}
catch(SQLException e)
{
LOGGER.error(RESULTSETCLOSEEXCEPTION
+ e.getMessage());
}
try {
if (preparedStatement != null) {
preparedStatement.close();
preparedStatement=null;
}
} catch (SQLException e) {
LOGGER.error(STATEMENTCLOSEEXCEPTION
+ e.getMessage());
}
try {
if (dbConnection != null) {
dbConnection.close();
dbConnection=null;
}
} catch (SQLException e) {
LOGGER.error(CONNECTIONCLOSEEXCEPTION
+ e.getMessage());
}
}
Is above code is correct way to close connection, prepared statement and resultset?

Answer 1

From the documentation.
close()
Releases this Connection object's database and JDBC resources immediately instead of
waiting for them to be automatically released.

Answer 2

One closes the connection, one sets the connection reference to null.
If you don't close the connection, you can have a connection leak. It is important to close the connection in a finally block.
The close() operation closes the connection--it doesn't do anything to the connection reference. You might not be able to do anything with the connection, but it's not null. Once it's closed it can be released back into a collection pool, but that's something different yet again.
Conclusion::
*connection.close()*
it close the conection with the database and release all the resources.
***con = null*** - the reference to connection object is deleted in that case if the connection is open then it is still open i.e. resources are not free.
Let me correct if i am getting wrong.

Answer 3

by using Connection.close() we can close the resource and we can reuse the connection, because it is go back and stored into the connection pool
and
by making Connection connection = null it sense we are free up the connection resource, by this there is no leakage in the memory management, but we can't reuse it.