BufferedImage img = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
for (y,h) ... img.setRGB(x,y,pixel);

int rgb = img.getRGB(x,y);
// 分離 R,G,B 通道

public class BmpImage {
    int width, height;
    short bitCount;           // 8 或 24
    int[][] pixels24;         // [row][col] 每像素 0x00RRGGBB
    byte[][] pixels8;         // [row][col] 調(diào)色板索引
    int[] palette;            // 8 位調(diào)色板，length = colorsUsed
}

// ===================================================
// 文件：src/main/java/com/example/bmp/BmpImage.java
// ===================================================
package com.example.bmp;
 
import java.awt.image.BufferedImage;
 
/**
 * BMP 圖像數(shù)據(jù)模型
 */
public class BmpImage {
    public int width;
    public int height;
    public short bitCount;       // 8 或 24
    public int[][] pixels24;     // 每像素 0x00RRGGBB
    public byte[][] pixels8;     // 每像素調(diào)色板索引
    public int[] palette;        // 調(diào)色板，length = colorsUsed
 
    /** 轉(zhuǎn)換為 BufferedImage */
    public BufferedImage toBufferedImage() {
        BufferedImage img = new BufferedImage(width, Math.abs(height),
            bitCount == 24 ? BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_BYTE_INDEXED);
        if (bitCount == 24) {
            for (int y = 0; y < Math.abs(height); y++) {
                for (int x = 0; x < width; x++) {
                    img.setRGB(x, y, pixels24[y][x]);
                }
            }
        } else {
            // 8 位，需創(chuàng)建 IndexColorModel（此處略）
            // 簡(jiǎn)單填充為灰度圖
            for (int y = 0; y < Math.abs(height); y++) {
                for (int x = 0; x < width; x++) {
                    int idx = pixels8[y][x] & 0xFF;
                    int c = palette[idx];
                    img.setRGB(x, y, c);
                }
            }
        }
        return img;
    }
}
 
// ===================================================
// 文件：src/main/java/com/example/bmp/BmpParseException.java
// ===================================================
package com.example.bmp;
 
/** BMP 解析異常 */
public class BmpParseException extends Exception {
    public BmpParseException(String msg) { super(msg); }
}
 
// ===================================================
// 文件：src/main/java/com/example/bmp/BmpReader.java
// ===================================================
package com.example.bmp;
 
import java.io.*;
import java.nio.ByteOrder;
 
/**
 * BMP 文件讀取器
 */
public class BmpReader {
    public static BmpImage read(File file) throws IOException, BmpParseException {
        try (DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream(file)))) {
            // 1. 讀取文件頭
            int bfType = readUnsignedShortLE(dis);
            if (bfType != 0x4D42) throw new BmpParseException("非 BMP 文件");
            int bfSize = readIntLE(dis);
            dis.skipBytes(4); // reserved
            int bfOffBits = readIntLE(dis);
 
            // 2. 讀取 DIB 頭
            int dibSize = readIntLE(dis);
            if (dibSize != 40) throw new BmpParseException("不支持的 DIB 頭大小: " + dibSize);
            int width = readIntLE(dis);
            int height = readIntLE(dis);
            short planes = readShortLE(dis);
            short bitCount = readShortLE(dis);
            int compression = readIntLE(dis);
            if (compression != 0) throw new BmpParseException("不支持壓縮: " + compression);
            int imageSize = readIntLE(dis);
            dis.skipBytes(16); // 跳過分辨率與顏色信息
            int colorsUsed = readIntLE(dis);
            if (colorsUsed == 0 && bitCount <= 8) {
                colorsUsed = 1 << bitCount;
            }
 
            // 構(gòu)造 BmpImage
            BmpImage img = new BmpImage();
            img.width = width;
            img.height = height;
            img.bitCount = bitCount;
 
            // 3. 讀取調(diào)色板（8 位）
            if (bitCount == 8) {
                img.palette = new int[colorsUsed];
                for (int i = 0; i < colorsUsed; i++) {
                    int b = dis.readUnsignedByte();
                    int g = dis.readUnsignedByte();
                    int r = dis.readUnsignedByte();
                    dis.readUnsignedByte(); // 保留
                    img.palette[i] = (r << 16) | (g << 8) | b;
                }
                img.pixels8 = new byte[Math.abs(height)][width];
            } else if (bitCount == 24) {
                img.pixels24 = new int[Math.abs(height)][width];
            } else {
                throw new BmpParseException("僅支持 8 位和 24 位 BMP");
            }
 
            // 4. 跳轉(zhuǎn)到像素?cái)?shù)據(jù)偏移
            long skipped = dis.skip(bfOffBits - 14 - dibSize - (bitCount==8 ? colorsUsed*4 : 0));
            // 5. 計(jì)算行長(zhǎng)度（字節(jié)）對(duì)齊到 4 字節(jié)
            int rowBytes = ((width * bitCount + 31) / 32) * 4;
 
            // 6. 讀取像素?cái)?shù)據(jù)
            boolean bottomUp = height > 0;
            int absHeight = Math.abs(height);
            for (int row = 0; row < absHeight; row++) {
                int y = bottomUp ? absHeight - 1 - row : row;
                byte[] rowData = new byte[rowBytes];
                dis.readFully(rowData);
                ByteArrayInputStream rowIn = new ByteArrayInputStream(rowData);
                for (int x = 0; x < width; x++) {
                    if (bitCount == 24) {
                        int b = rowIn.read();
                        int g = rowIn.read();
                        int r = rowIn.read();
                        img.pixels24[y][x] = (r << 16) | (g << 8) | b;
                    } else {
                        int idx = rowIn.read();
                        img.pixels8[y][x] = (byte) idx;
                    }
                }
            }
            return img;
        }
    }
 
    // 小端讀取輔助
    private static int readUnsignedShortLE(DataInputStream dis) throws IOException {
        int b1 = dis.readUnsignedByte();
        int b2 = dis.readUnsignedByte();
        return (b2 << 8) | b1;
    }
    private static short readShortLE(DataInputStream dis) throws IOException {
        int u = readUnsignedShortLE(dis);
        return (short) u;
    }
    private static int readIntLE(DataInputStream dis) throws IOException {
        int b1 = dis.readUnsignedByte();
        int b2 = dis.readUnsignedByte();
        int b3 = dis.readUnsignedByte();
        int b4 = dis.readUnsignedByte();
        return (b4 << 24) | (b3 << 16) | (b2 << 8) | b1;
    }
}
 
// ===================================================
// 文件：src/main/java/com/example/bmp/BmpWriter.java
// ===================================================
package com.example.bmp;
 
import java.io.*;
 
/**
 * BMP 文件寫入器
 */
public class BmpWriter {
    public static void write(BmpImage img, File file) throws IOException {
        try (DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)))) {
            int width = img.width;
            int absHeight = Math.abs(img.height);
            int bitCount = img.bitCount;
            int rowBytes = ((width * bitCount + 31) / 32) * 4;
            int imageSize = rowBytes * absHeight;
            int paletteSize = (bitCount == 8 ? img.palette.length * 4 : 0);
            int bfOffBits = 14 + 40 + paletteSize;
            int bfSize = bfOffBits + imageSize;
 
            // 1. 寫文件頭
            writeShortLE(dos, 0x4D42); // "BM"
            writeIntLE(dos, bfSize);
            writeShortLE(dos, 0);
            writeShortLE(dos, 0);
            writeIntLE(dos, bfOffBits);
 
            // 2. 寫 DIB 頭（BITMAPINFOHEADER）
            writeIntLE(dos, 40);
            writeIntLE(dos, width);
            writeIntLE(dos, img.height);
            writeShortLE(dos, 1);         // planes
            writeShortLE(dos, bitCount);
            writeIntLE(dos, 0);           // BI_RGB
            writeIntLE(dos, imageSize);
            writeIntLE(dos, 0); writeIntLE(dos, 0); // 分辨率
            writeIntLE(dos, bitCount == 8 ? img.palette.length : 0);
            writeIntLE(dos, 0);
 
            // 3. 寫調(diào)色板
            if (bitCount == 8) {
                for (int c : img.palette) {
                    int r = (c >> 16) & 0xFF;
                    int g = (c >> 8) & 0xFF;
                    int b = c & 0xFF;
                    dos.writeByte(b);
                    dos.writeByte(g);
                    dos.writeByte(r);
                    dos.writeByte(0);
                }
            }
 
            // 4. 寫像素?cái)?shù)據(jù)
            byte[] pad = new byte[rowBytes - (width * bitCount / 8)];
            for (int row = absHeight - 1; row >= 0; row--) {
                if (bitCount == 24) {
                    for (int x = 0; x < width; x++) {
                        int rgb = img.pixels24[row][x];
                        dos.writeByte(rgb & 0xFF);          // B
                        dos.writeByte((rgb >> 8) & 0xFF);   // G
                        dos.writeByte((rgb >> 16) & 0xFF);  // R
                    }
                } else {
                    for (int x = 0; x < width; x++) {
                        dos.writeByte(img.pixels8[row][x]);
                    }
                }
                dos.write(pad);
            }
        }
    }
 
    // 小端寫入輔助
    private static void writeShortLE(DataOutputStream dos, int v) throws IOException {
        dos.writeByte(v & 0xFF);
        dos.writeByte((v >> 8) & 0xFF);
    }
    private static void writeIntLE(DataOutputStream dos, int v) throws IOException {
        dos.writeByte(v & 0xFF);
        dos.writeByte((v >> 8) & 0xFF);
        dos.writeByte((v >> 16) & 0xFF);
        dos.writeByte((v >> 24) & 0xFF);
    }
}
 
// 文件：src/main/java/com/example/bmp/Main.java
package com.example.bmp;
 
import java.io.File;
 
public class Main {
    public static void main(String[] args) throws Exception {
        // 讀取 BMP
        BmpImage img = BmpReader.read(new File("input.bmp"));
        System.out.println("讀取完成: " + img.width + "x" + Math.abs(img.height) + " 位深=" + img.bitCount);
        // 轉(zhuǎn)換為 BufferedImage 并另存為 PNG（示例）
        // ImageIO.write(img.toBufferedImage(), "png", new File("out.png"));
 
        // 修改像素：反轉(zhuǎn)顏色示例
        if (img.bitCount == 24) {
            for (int y = 0; y < Math.abs(img.height); y++) {
                for (int x = 0; x < img.width; x++) {
                    int rgb = img.pixels24[y][x];
                    int r = 255 - ((rgb >> 16) & 0xFF);
                    int g = 255 - ((rgb >> 8) & 0xFF);
                    int b = 255 - (rgb & 0xFF);
                    img.pixels24[y][x] = (r << 16) | (g << 8) | b;
                }
            }
        }
 
        // 寫入 BMP
        BmpWriter.write(img, new File("output.bmp"));
        System.out.println("寫入完成");
    }
}