Can you be a little more specific?
Sorry, I was replying on my phone so kept it brief. I thought your comment was confusing to the OP - hadn't twigged you were
Your statement is wrong though, as is this in many ways -
The image data is stored on the GPU
A BufferedImage is always stored in Java memory. It's always rendered to
in Java memory. When the image is drawn to the screen (or another accelerated surface) the data is sent to the graphics card. If you draw an image more than once without changing it
the graphics pipeline will cache a copy
on the graphics card. Every time the image is updated any graphics card copy is disposed of. Therefore, the data is not really stored on the GPU.
If you alter a BufferedImage before each time you draw it (ie. every frame) then a copy will never be cached on the GPU. Therefore, it makes no difference whether it's a managed or unmanaged image
The fastest way to work with BufferedImage pixel data in Java is to grab the data array directly. This makes the image unmanaged, but often this is not an issue for the reason above. Managed images are only useful for image resources that remain unchanged for a period of time.
That you got a lower frame rate using set/getRGB is not a surprise. These involve extra data coercion and copying. They almost certainly don't un-manage an image any more (most articles about this were written Java 1.4 time, and a lot has changed). They will be slower for what you're doing though.
To answer your original post, don't use compatible images for this at all - it can cause a wealth of problems as you don't know what format you're getting, and on some systems (Linux) there was and may still be a bug where you could never
get the data array from a compatible image.
Just create a BufferedImage directly using TYPE_INT_RGB, TYPE_INT_ARGB or TYPE_INT_ARGB_PRE. You'll have a guaranteed format to work with so won't have to do any data coercion in your code - the pipes for drawing these formats to the screen are some of the most optimized, and will almost certainly outperform the pack / unpack code you have to use to work around it.
Use the pre-multiplied image format if you're doing any direct manipulation involving alpha (eg. custom blending) - it will save you a bunch of headaches.
Hope that helps you out. The problem with all this Java2D, managed image stuff, etc. is that a little knowledge is dangerous!