Well, any image one way or another is made up of pixels. A pixel is simply a bucket of 3 colours. 3 fundamental colours that can represent any colour the eye can see. I.e, Red, Green and Blue. If you put a magnifying glass on your monitor and inspect you can see that each tiny little pixel on your monitor is actually made up of 3 even smaller lights. A Red light, a Green light and a Blue light. By varying how intensely these 3 actual mini light bulbs shine you can make it appear as any colour. Contemporary monitors have such high resolutions (more pixels over area (even smaller pixels)) it might be hard to even see the 3 tiny lights that make up every pixel.
SO. A pixel is simply a bucket of 3 values. 3 values that can each have a value from 0 to 255. ( Also known as a byte ( A byte can have values form 0-255 )). The higher the value, the brighter the light. Black is when all the values are 0 and White is when all the values are 255. Together these 3 values that can have 255 values each can represent (255 * 255 * 255 = 16,581,375 ) ~16 million different colours.
Most of the time, a pixel can be placed in an int. An int is made up of 4 bytes and therefore the 3 bytes that represent a pixel can fit in there fine. There's an extra byte that is unused an int however, and that's where we can put an extra value called the "Alpha". It represents the transparency of the given pixel. (Transparency = how much this pixel blends in with another pixel. )
By default java and the majority of anything else represents pixels as a 4 byte value made up of an Alpha, Red, Green and Blue value (I.e, ARGB). These are also how the bytes are ordered.
So if we have an ARGB pixel and we would like to grab the Red colour of the pixel, we would grab the third byte from the right.
We can do this by using bitwise operators. Here's a few ways: ( 1 byte = 8 bits
byte red = ARGB >> 16;
byte red = ARGB & 0x00FF0000;
Java's BufferedImages are abstractions from all this bit manipulation. Juggling with the pixels yourself or using BufferedImages is all preference. There's no particular significance using one over the other.
The writableRaster you're talking about is a special pixel array that is connected with the BufferedImage it was taken from. Special in the sense that they both (the raster and the bufferedImage) both point into the same pixel array in memory. So a change in either of them is reflected on the other.
You can get a copy of any pixel array from a BufferedImage in java by using the BufferedImage's builtin getRGB() method. This gives you a copy of that array, and changing that array won't alter the BufferedImage it was copied from.
As an example, this applet draws all its tiles with g.drawImage() and does no manual pixel manipulation whatsoever.http://heartpirates.com/hearts/games/isoapplet.html
source code here: http://jonjavaweb.orgfree.com/IsoWorldSource.zip