Optimizing Java Bytecode

Here's a few thoughts off the top of my head to get you started, some are simpler to do than others, and you'll need to test them to be sure you get savings as I haven't!

- Firstly pick the right algorithms. Avoid bubblesort, etc. That will make a huge difference.
- Familiarize yourself with javap so you get an idea of what source creates what bytecodes. Compare different ways of doing the same thing like say switch vs if.
- Use an optimizing java compiler "javac -O" is the standard way of turning them on, but you may be able to find a better compiler as the standard one isn't very good at optimizing. Hand optimizations are also a good idea.
- Don't put too many conditional checks in - check to see if doing the test is cheaper than the work it avoids, and that the test avoids that work frequently.
- Make everything static. It's an extra bytecode or two to access if not.
- Function calls are overhead, and last I looked the compiler didn't inline very well. Put all your code in one function if you can.
- Don't use container classes if you don't need them. They will add overhead.
- In fact also avoid all function calls that you can.
- I have a feeling static member variables will also add overhead compared to locals, but test it.
- Some JVMs will execute some standard functions (e.g. Math.min()) without using bytecodes, find those and use them if you know the target JVM.
- The first four numeric variables or arguments in a method are accessed via fewer bytecode instructions.
- Use "a += b;" instead of "a = a + b;" etc.