Optimizing Java for speed ...

Question

I have created a GUI program, that relies heavily on Swing components. I use a JDesktop with multiple JInternalFrames with JToolBars in both the desktop and the frames. Everything is working fine...
however, loading the application (creating a new instance) takes 35 secs!!
It's getting quite big (27 classes), but besides loading a couple of images of a (local) webserver, I don't see how it should take this amount of time to set up.
Any hints on general optimalization techniques? (links? articles?)
Beforehand thanks to anyone answering!!

Answer 1

OK, here's some optimization tricks.
1. Build your dialog boxes (or at least the dialog boxes that you use most often) ahead of time during the splash screen.
2. Instead of killing your dialog boxes when you close them just use setVisible(false). This keeps them in memory so the next time you want to view that dialog box just do setVisible(true).
3. Using a Singleton design pattern will help you with both of the above issues.
public class MyDialog extends JDialog {
   private static MyDialog theOnlyOne = null;
   // The constructor is private.  Build your Dialog box's GUI
   // here.  Because it's private nothing outside this class can call it.
   private MyDialog(){
   public static MyDialog getInstance() {
      if(theOnlyOne == null) {
         theOnlyOne = new MyDialog();
      return theOnlyOne;
}By looking at this code you can see that instead of creating an instance of MyDialog you instead use the static method getInstance() The first time getInstance is called it will construct the dialog box. The 2nd and all subsequent times getInstance is called it will return the already constructed instance of MyDialog. This will allow you to simply use setVisible with true or false to turn the dialog box on or off. This means you spend the time to construct the dialog box only once.
Also never mix AWT components (Button, Checkbox, Frame) with Swing components (JButton, JCheckbox, JFrame) Always use Swing. They're "lighter weight" and the look better.
Another technique is to call the garbage collection explicitly. One of the great things about Java is that it does automatic garbage collection (gc) . The bad thing about that is that the gc runs whenever the JVM decides it needs more memory. If this happens while you're using your app then you get a "hiccup" of slowness.
So, if you're in a part of the code where you know that immediate reaction isn't important at that moment then you can call the garbage collection manually with System.gc();
For example, let's say your program just ran a big database query and returned all that data in a JTable. Let's say that you KNOW that when the user runs that process they always take at least a few seconds to look at the data they just retrieved. That may be a good time to run System.gc(); That way, you make the garbage collector run when it doesn't effect the user.
If you were writing a game then you could run System.gc(); when you load a new level. Essentially, just run it when you know that the user experience won't be effected.
Once Gui components are constructed I've found that they work pretty darn fast. I use Jext, a programming editor written in Java every single day and the only slowness I've found when using it is when the garbage collector kicks in.
Hope it helps.
Greg