Basic Objective
   A windows BMP file is a common image format that Java does not handle. While BMP images are used only on windows machines, they are reasonably common. Reading these shows how to read complex structures in Java and
how to alter they byte order from the big endian order used by Java to the little endian order used by the windows and the intel processor.
--------------------------------------------------------
//
//This code was taken and cleaned up from a
//Javaworld tips and tricks column
//

import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.MemoryImageSource;
import java.io.FileInputStream;
import java.io.IOException;

import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;

//
//really just a collection of methods to read a BMP file
//

public class BMPLoader

{

    // build an int from a byte array - convert little to big endian
    public static int constructInt(byte[] in, int offset) {

        int ret = ((int) in[offset + 3] & 0xff);

        ret = (ret << 8) | ((int) in[offset + 2] & 0xff);

        ret = (ret << 8) | ((int) in[offset + 1] & 0xff);

        ret = (ret << 8) | ((int) in[offset + 0] & 0xff);

        return (ret);

    }

    // build an int from a byte array - convert little to big endian
    // set high order bytes to 0xfff
    public static int constructInt3(byte[] in, int offset) {

        int ret = 0xff;

        ret = (ret << 8) | ((int) in[offset + 2] & 0xff);

        ret = (ret << 8) | ((int) in[offset + 1] & 0xff);

        ret = (ret << 8) | ((int) in[offset + 0] & 0xff);

        return (ret);

    }

    // build an int from a byte array - convert little to big endian
    public static long constructLong(byte[] in, int offset) {

        long ret = ((long) in[offset + 7] & 0xff);

        ret |= (ret << 8) | ((long) in[offset + 6] & 0xff);

        ret |= (ret << 8) | ((long) in[offset + 5] & 0xff);

        ret |= (ret << 8) | ((long) in[offset + 4] & 0xff);

        ret |= (ret << 8) | ((long) in[offset + 3] & 0xff);

        ret |= (ret << 8) | ((long) in[offset + 2] & 0xff);

        ret |= (ret << 8) | ((long) in[offset + 1] & 0xff);

        ret |= (ret << 8) | ((long) in[offset + 0] & 0xff);

        return (ret);

    }

    // build an double from a byte array - convert little to big endian
    public static double constructDouble(byte[] in, int offset) {

        long ret = constructLong(in, offset);

        return (Double.longBitsToDouble(ret));

    }

    // build an short from a byte array - convert little to big endian
    public static short constructShort(byte[] in, int offset) {

        short ret = (short) ((short) in[offset + 1] & 0xff);

        ret = (short) ((ret << 8) | (short) ((short) in[offset + 0] & 0xff));

        return (ret);

    }

    // internal class representing a bitmap header structure
    // with code to read it from a file
    static class BitmapHeader {

        public int nsize;

        public int nbisize;

        public int nwidth;

        public int nheight;

        public int nplanes;

        public int nbitcount;

        public int ncompression;

        public int nsizeimage;

        public int nxpm;

        public int nypm;

        public int nclrused;

        public int nclrimp;

        // read in the bitmap header
        public void read(FileInputStream fs) throws IOException

        {

            final int bflen = 14; // 14 byte BITMAPFILEHEADER

            byte bf[] = new byte[bflen];

            fs.read(bf, 0, bflen);

            final int bilen = 40; // 40-byte BITMAPINFOHEADER

            byte bi[] = new byte[bilen];

            fs.read(bi, 0, bilen);

            // Interperet data.
            nsize = constructInt(bf, 2);

            //  System.out.println("File type is :"+(char)bf[0]+(char)bf[1]);
            //  System.out.println("Size of file is :"+nsize);

            nbisize = constructInt(bi, 2);

            //   System.out.println("Size of bitmapinfoheader is :"+nbisize);

            nwidth = constructInt(bi, 4);

            //   System.out.println("Width is :"+nwidth);

            nheight = constructInt(bi, 8);

            //  System.out.println("Height is :"+nheight);

            nplanes = constructShort(bi, 12); //(((int)bi[13]&0xff)<<8) |
            // (int)bi[12]&0xff;

            //  System.out.println("Planes is :"+nplanes);

            nbitcount = constructShort(bi, 14); //(((int)bi[15]&0xff)<<8) |
            // (int)bi[14]&0xff;

            //  System.out.println("BitCount is :"+nbitcount);

            // Look for non-zero values to indicate compression
            ncompression = constructInt(bi, 16);

            //  System.out.println("Compression is :"+ncompression);

            nsizeimage = constructInt(bi, 20);

            //  System.out.println("SizeImage is :"+nsizeimage);

            nxpm = constructInt(bi, 24);

            // System.out.println("X-Pixels per meter is :"+nxpm);

            nypm = constructInt(bi, 28);

            // System.out.println("Y-Pixels per meter is :"+nypm);

            nclrused = constructInt(bi, 32);

            //  System.out.println("Colors used are :"+nclrused);

            nclrimp = constructInt(bi, 36);

            //  System.out.println("Colors important are :"+nclrimp);

        }

    }

    public static Image read(FileInputStream fs)

    {

        try {

            BitmapHeader bh = new BitmapHeader();

            bh.read(fs);

            if (bh.nbitcount == 24)

                return (readMap24(fs, bh));

            if (bh.nbitcount == 32)

                return (readMap32(fs, bh));

            if (bh.nbitcount == 8)

                return (readMap8(fs, bh));

            fs.close();

        } catch (IOException e) {

            // System.out.println("Caught exception in loadbitmap!");
        }

        return (null);

    }

    /**
     *
     * readMap24 internal routine to read the bytes in a 24 bit bitmap
     *
     *
     *
     * Arguments:
     *
     * fs - file stream
     *
     * bh - header struct
     *
     * Returns:
     *
     * Image Object, be sure to check for (Image)null !!!!
     *
     *
     * 
     */
    protected static Image readMap32(FileInputStream fs, BitmapHeader bh)
            throws IOException

    {

        Image image;

        // No Palatte data for 24-bit format but scan lines are

        // padded out to even 4-byte boundaries.

        int xwidth = bh.nsizeimage / bh.nheight;

        int ndata[] = new int[bh.nheight * bh.nwidth];

        byte brgb[] = new byte[bh.nwidth * 4 * bh.nheight];

        fs.read(brgb, 0, bh.nwidth * 4 * bh.nheight);

        int nindex = 0;

        for (int j = 0; j < bh.nheight; j++)

        {

            for (int i = 0; i < bh.nwidth; i++)

            {

                ndata[bh.nwidth * (bh.nheight - j - 1) + i] = constructInt3(
                        brgb, nindex);

                nindex += 4;

            }

        }

        image = Toolkit.getDefaultToolkit().createImage

        (new MemoryImageSource(bh.nwidth, bh.nheight,

        ndata, 0, bh.nwidth));

        fs.close();

        return (image);

    }

    /**
     *
     * readMap24 internal routine to read the bytes in a 24 bit bitmap
     *
     *
     *
     * Arguments:
     *
     * fs - file stream
     *
     * bh - header struct
     *
     * Returns:
     *
     * Image Object, be sure to check for (Image)null !!!!
     *
     *
     * 
     */
    protected static Image readMap24(FileInputStream fs, BitmapHeader bh)
            throws IOException

    {

        Image image;

        // No Palatte data for 24-bit format but scan lines are

        // padded out to even 4-byte boundaries.

        int npad = (bh.nsizeimage / bh.nheight) - bh.nwidth * 3;

        int ndata[] = new int[bh.nheight * bh.nwidth];

        byte brgb[] = new byte[(bh.nwidth + npad) * 3 * bh.nheight];

        fs.read(brgb, 0, (bh.nwidth + npad) * 3 * bh.nheight);

        int nindex = 0;

        for (int j = 0; j < bh.nheight; j++)

        {

            for (int i = 0; i < bh.nwidth; i++)

            {

                ndata[bh.nwidth * (bh.nheight - j - 1) + i] = constructInt3(
                        brgb, nindex);

                nindex += 3;

            }

            nindex += npad;

        }

        image = Toolkit.getDefaultToolkit().createImage

        (new MemoryImageSource(bh.nwidth, bh.nheight,

        ndata, 0, bh.nwidth));

        fs.close();

        return (image);

    }

    /**
     *
     * readMap8 internal routine to read the bytes in a 8 bit bitmap
     *
     *
     *
     * Arguments:
     *
     * fs - file stream
     *
     * bh - header struct
     *
     * Returns:
     *
     * Image Object, be sure to check for (Image)null !!!!
     *
     *
     * 
     */
    protected static Image readMap8(FileInputStream fs, BitmapHeader bh)
            throws IOException

    {

        Image image;

        // Have to determine the number of colors, the clrsused

        // parameter is dominant if it is greater than zero. If

        // zero, calculate colors based on bitsperpixel.

        int nNumColors = 0;

        if (bh.nclrused > 0)

        {

            nNumColors = bh.nclrused;

        }

        else

        {

            nNumColors = (1 & 0xff) << bh.nbitcount;

        }

        //     System.out.println("The number of Colors is"+nNumColors);

        // Some bitmaps do not have the sizeimage field calculated

        // Ferret out these cases and fix ‘em.

        if (bh.nsizeimage == 0)

        {

            bh.nsizeimage = ((((bh.nwidth * bh.nbitcount) + 31) & ~31) >> 3);

            bh.nsizeimage *= bh.nheight;

            //          System.out.println("nsizeimage (backup) is"+nsizeimage);

        }

        // Read the palatte colors.

        int npalette[] = new int[nNumColors];

        byte bpalette[] = new byte[nNumColors * 4];

        fs.read(bpalette, 0, nNumColors * 4);

        int nindex8 = 0;

        for (int n = 0; n < nNumColors; n++)

        {

            npalette[n] = constructInt3(bpalette, nindex8);

            nindex8 += 4;

        }

        // Read the image data (actually indices into the palette)

        // Scan lines are still padded out to even 4-byte

        // boundaries.

        int npad8 = (bh.nsizeimage / bh.nheight) - bh.nwidth;

        //    System.out.println("nPad is:"+npad8);

        int ndata8[] = new int[bh.nwidth * bh.nheight];

        byte bdata[] = new byte[(bh.nwidth + npad8) * bh.nheight];

        fs.read(bdata, 0, (bh.nwidth + npad8) * bh.nheight);

        nindex8 = 0;

        for (int j8 = 0; j8 < bh.nheight; j8++)

        {

            for (int i8 = 0; i8 < bh.nwidth; i8++)

            {

                ndata8[bh.nwidth * (bh.nheight - j8 - 1) + i8] =

                npalette[((int) bdata[nindex8] & 0xff)];

                nindex8++;

            }

            nindex8 += npad8;

        }

        image = Toolkit.getDefaultToolkit().createImage

        (new MemoryImageSource(bh.nwidth, bh.nheight,

        ndata8, 0, bh.nwidth));

        return (image);

    }

    /**
     *
     * load method - see read for details
     *
     *
     *
     * Arguments:
     *
     * sdir and sfile are the result of the FileDialog()
     *
     * getDirectory() and getFile() methods.
     *
     *
     *
     * Returns:
     *
     * Image Object, be sure to check for (Image)null !!!!
     *
     *
     * 
     */
    public static Image load(String sdir, String sfile) {

        return (load(sdir + sfile));

    }

    /**
     *
     * load method - see read for details
     *
     *
     *
     * Arguments:
     *
     * sdir - full path name
     *
     *
     *
     * Returns:
     *
     * Image Object, be sure to check for (Image)null !!!!
     *
     *
     * 
     */
    public static Image load(String sdir)

    {

        try

        {

            FileInputStream fs = new FileInputStream(sdir);

            return (read(fs));

        }

        catch (IOException ex) {

            return (null);

        }

    }

    public static void main(String[] args) throws IOException

    {

        if (args.length == 0) {

            System.out.println("Usage >java BMPLoader ImageFile.bmp");

            System.exit(0);

        }

        FileInputStream in = new FileInputStream(args[0]);

        Image TheImage = read(in);

        JFrame TheFrame = new JFrame(args[0]);

        JLabel TheLabel = new JLabel(new ImageIcon(TheImage));

        TheFrame.getContentPane().add(new JScrollPane(TheLabel));

        TheFrame.setSize(300, 300);

        TheFrame.setVisible(true);

    }
    //end class BMPLoader
}

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=47688