There are a few tweaks which could give significant improvement in the speed of a swing gui application.

1. Multithreading – Proper use of threads can significantly improve the applications speed and also its “perceived speed” or responsiveness.

Time consuming tasks should not be done inside an event handler since this will effect the appearance of the gui component whose event handler this is. If a lengthy task for example is done inside the event handler of a menu then the menu may stay until the task is complete or if its a button then if may freeze i.e. stay pressed until the task is complete. This results into reduced usability.

Various solutions include SwingWorker , Threads , invokeLater. E.g.Time-consuming tasks like I/O operatings , Database operations or creation of some kind of object or child window should be put in a thread. Lengthy tasks inside an event handler should be moved into a SwingWorker Thread or invokeLater so that the handler can return immediately keeping the GUI component responsive.

A Thread :

new Thread () {
    public void run () {
        //Lengthy Code
    }
}.start ();

A SwingWorker :

invokeLater :

Multithreaded applications when properly designed give even better results on multicore processors. In any case threads will definitely increase the responsiveness or perceived speed of the gui in particular.

2. JVM Switches – jvm switches can be used to modify parameters like minimum and maximum memory that a java app can use. For a complete list of jvm options look here.
Example :

java -jar -Xverify:none -Xms32m -XX:PermSize=32m -Dsun.java2d.noddraw=true application.jar

3. Creating objects before they are actually needed – Object creation is a process that takes time. For example creation of a window frame object . So a window object can be created beforehand and kept hidden. When needed it can be simply displayed by calling the show() method. This increases the speed of the application.

4. Reusing Objects – Reusing objects prevents creating them again and again and slowing down the app. This totally depends on the logic of the application how objects can be kept in memory and reused when necessary.

5. StringBuffer versus String – Strings are immutable means they cannot be changed once they are created. Hence any operation like concatenation done on a string results in creation of more string objects.
StringBuffer on the other hand is an object which can be changed and hence any operation like concatenation results into the same object being changed instead of creation of a new one.

Hence StringBuffer is faster than String. If the application uses too many Strings and string operations then StringBuffer should be used to gain speed.

Apart from these other techniques for speed gain include using native functions , AOT (Ahead of Time compilers) , JIT (Just in Time compilers) etc.

If hardware acceleration is enabled then using opengl can improve GUI speed and can be enabled using the switch :
-Dsun.java2d.opengl=true

1. tomcat5.5
2. tomcat5.5-webapps
3. sun-java6-jdk

They can be installed from command line using the command sudo apt-get

After synaptic finishes installing them open /etc/default/tomcat5.5 and edit it as follows :

Find :
#JAVA_HOME=/usr/lib/jvm/java-6-sun

Change : Remove the # so that it is uncommented.
JAVA_HOME=/usr/lib/jvm/java-6-sun

It points to the java home which can be java-6-sun or any other java .

Then restart tomcat5.5 from command line like this :

enlightened@enlightened-desktop:~$ sudo /etc/init.d/tomcat5.5 restart
* Stopping Tomcat servlet engine tomcat5.5 [ OK ]
* Starting Tomcat servlet engine tomcat5.5 [ OK ]

Now open in your browser the url :

http://localhost:8180/

And the welcome page of Apache Tomcat should appear.

The file
/usr/share/tomcat5.5/conf/tomcat-users.xml
has the default username and password listed which is username : tomcat and password : tomcat.

On the tomcat welcome page Tomcat Administration link is on the left :
http://localhost:8180/admin

Opening this page might show the error message :
HTTP Status 403 – Access to the requested resource has been denied

To fix the above issue open the file
/usr/share/tomcat5.5/conf/tomcat-users.xml

sudo gedit /usr/share/tomcat5.5/conf/tomcat-users.xml

and add a role called admin and user called admin with that role :

<role rolename=”admin”/>
<user username=”admin” password=”tomcat” roles=”tomcat,admin”/>

Restart tomcat from command line as shown above.

Now log in to the administration panel :
http://localhost:8180/admin

with username : admin and password : tomcat.
The login should take you to the admin panel without any error.

To the left is another link of Tomcat Manager :
http://localhost:8180/manager/html

which might still show the error of Access denied.

To fix this issue simply login to the admin panel and create a role called manager (if it doesnt exist) and assign this role to a non-admin user like tomcat or create a new user.

Then log in to the Tomcat Manager page and it should open fine without any errors.

Now /usr/share/tomcat-webapps is the folder that contains the jsp files/webapps which are accessible from localhost:8180 url.

To change the directory of webapps to say one in /home/username/tomcat

Open : /usr/share/tomcat5.5-webapps/ROOT.xml

Look for :
Context path=”/” docBase=”/usr/share/tomcat5.5-webapps/ROOT”
and change the docBase value to the folder where the tomcat webapps would be.
e.g.

Context path=”/” docBase=”/home/enlightened/tomcat”
or
Context path=”/” docBase=”/var/www/tomcat”

Save the file and restart tomcat.

One more thing you can do is copy the contents of the /usr/share/tomcat5.5-webapps/ROOT directory to this new directory and then open the url localhost:8180 to check that everything is working fine. The admin and manager pages on the left and the jsp examples also should all open fine as previously.

Reading a sql file and putting all of it in a string variable and feeding to the execute command would result in an exception. All instructions must be executed individually. A proper sql script should have all instructions starting on a newline and all comments on a newline. Start with an empty string. Start reading the lines ; if a line has a – as the first character then continue else add it to the query string. Now if the last character of the query string is a ; then a command is complete so execute the query and make the query string empty and loop up. Thats it

Executing an sql script in jdbc with the following code should work …

//Now read line bye line
String thisLine, sqlQuery;
try {
    sqlQuery = "";
    while ((thisLine = d.readLine()) != null)
    {
        //Skip comments and empty lines
        if(thisLine.length() > 0 && thisLine.charAt(0) == '-' || thisLine.length() == 0 )
            continue;
        sqlQuery = sqlQuery + " " + thisLine;
        //If one command complete
        if(sqlQuery.charAt(sqlQuery.length() - 1) == ';') {
            sqlQuery = sqlQuery.replace(';' , ' '); //Remove the ; since jdbc complains
            try {
                stmt.execute(sqlQuery);
            }
            catch(SQLException ex) {
                JOptionPane.showMessageDialog(null, "Error Creating the SQL Database : " + ex.getMessage());
            }
            catch(Exception ex) {
                JOptionPane.showMessageDialog(null, "Error Creating the SQL Database : " + ex.getMessage());
            }
            sqlQuery = "";
        }
    }
}
catch(IOException ex) {
}
catch(Exception ex) {
    JOptionPane.showMessageDialog(null, "Error Creating the SQL Database : " + ex.getMessage());
}

where d could be BufferedReader and c could be a Statement object.

In Java reading and writing to a configuration is pretty simple and straight forward.

A configuration file can store data in many ways. One simple technique is :

key=value

Apart from this XML can also be used to save parameters.

The following two methods should serve the purpose of reading and saving configurations :

//Writing and Saving Configurations
private void setPreference(String Key, String Value) {
    Properties configFile = new Properties();
    try {
        InputStream f = new FileInputStream("configuration.xml");
        configFile.loadFromXML(f);
        f.close();
    }
    catch(IOException e) {
    }
    catch(Exception e) {
        JOptionPane.showMessageDialog(null, e.getMessage());
    }
    configFile.setProperty(Key, Value);
    try {
        OutputStream f = new FileOutputStream("configuration.xml");
        configFile.storeToXML(f,"Configuration file for the Profit System");
    }
    catch(Exception e) {
    }
}
//Reading Configurations
private static String getPreference(String Key) {
    Properties configFile = new Properties();
    try {
        InputStream f = new FileInputStream("configuration.xml");
        configFile.loadFromXML(f);
        f.close();
    }
    catch(IOException e) {
    }
    catch(Exception e) {
        JOptionPane.showMessageDialog(null , e.getMessage());
    }
    return (configFile.getProperty(Key));
}

Instead the storeFromXML and loadFromXML store and load methods can be used to simply store the data in the key=value format instead of xml format.