奇怪，但这似乎是个解决办法。

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.awt.image.WritableRaster;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class ImageTesting2 extends JPanel{
    static  final int dim=20;
    static  int[] pixels = new int[dim*dim*4];
    BufferedImage image;

    public static void main(String[] args){

        ImageTesting2 tester = new ImageTesting2(); 
        tester.fillMatrix();
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setBounds(100, 100, 500, 500);
        frame.setVisible(true);
        frame.add(tester);
    }

     public void fillMatrix(){
            for(int i =0 ; i <pixels.length ; i=i+4){
               pixels[i] =255;     // red component
               pixels[i+1] = 0;    // green component
               pixels[i+2] = 255;  // blue component
               pixels[i+3] = 70;   // alpha component
            }

        image = new BufferedImage(dim, dim, BufferedImage.TYPE_INT_ARGB);          
        WritableRaster raster =  image.getRaster();
        raster.setPixels(0,0,dim,dim,pixels);

   }     

    @Override
    public void paintComponent(Graphics g) {
           Graphics2D g2 = (Graphics2D) g;
           g2.drawImage(image, 50, 50, this);
    }  

}

你的 int[] 应包含以下值 0xFF0000 （红色）， 0x00FF00 （绿色）， 0x0000FF （蓝色）等。。。
这里是一个例子，它将产生一个3x3像素的图像与各种颜色。
根据图像类型的不同，您可能需要添加更多对波段遮罩的支持。

pixelwriterapp

import java.awt.Image;
import java.awt.image.*;
import java.io.*;
import java.nio.file.Paths;
import javax.imageio.ImageIO;

public class PixelWriterApp {
    public static int[] pixelData = {
        0xFF0000,  0xFF7F00,  0xFFFF00,
        0x00FF00,  0x00FF7F,  0x00FFFF,
        0x0000FF,  0x7F00FF,  0xFF00FF
    };

    public static void main(String[] args) {
        int cols = 3;
        int rows = pixelData.length / cols;
        int scaleX = 100;
        int scaleY = 100;
        int width = cols * scaleX;
        int height = rows * scaleY;
        int[] stretched = ArrayUtils.stretch(pixelData, cols, scaleX, scaleY);
        String directory = System.getProperty("user.home");
        String filename = "MyImage.png";
        String filepath = Paths.get(directory, filename).toString();
        int imageType = BufferedImage.TYPE_INT_RGB;
        Image image = PixelWriter.getImageFromArray(stretched, width, height, imageType);

        writeImage(image, filepath, "png");
    }

    public static void writeImage(Image image, String filename, String ext) {
        try {
            ImageIO.write((RenderedImage) image, ext, new File(filename));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

像素书写器

import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferInt;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;
import java.util.Arrays;

public class PixelWriter {
    private static final int[] BAND_COUNT_3 = { 0xFF0000, 0xFF00, 0xFF };
    private static final int[] BAND_COUNT_4 = { 0xFF0000, 0xFF00, 0xFF, 0xFF000000 };

    // See note about ARGB bands http://stackoverflow.com/a/25184537
    protected static int[] lookupBandMask(int imageType) throws IllegalArgumentException {
        switch (imageType) {
            case BufferedImage.TYPE_INT_RGB:
            case BufferedImage.TYPE_INT_BGR:
                return Arrays.copyOf(BAND_COUNT_3, BAND_COUNT_3.length);
            case BufferedImage.TYPE_INT_ARGB:
                return Arrays.copyOf(BAND_COUNT_4, BAND_COUNT_4.length);
        }
        throw new IllegalArgumentException("Unsupported BufferedImage type");
    }

    public static Image getImageFromArray(int[] pixels, int width, int height, int imageType) {
        int[] bandMasks = lookupBandMask(imageType);
        BufferedImage image = new BufferedImage(width, height, imageType);
        DataBufferInt buffer = new DataBufferInt(pixels, pixels.length);
        WritableRaster raster = Raster.createPackedRaster(buffer, width, height, width, bandMasks, null);
        image.setData(raster);
        return image;
    }
}

阵列直到

public class ArrayUtils {
    // Source: http://stackoverflow.com/a/16556564
    public static int[][] stretch(int[][] arr, int cfactor, int rfactor) {
        int rows = arr.length * rfactor;
        int cols = arr[0].length * cfactor;
        int[][] result = new int[rows][cols];
        for (int r = 0; r < rows; r++) {
            for (int c = 0; c < cols; c++) {
                result[r][c] = arr[r / rfactor][c / cfactor];
            }
        }
        return result;
    }

    public static int[] stretch(int[] arr, int cols, int cfactor, int rfactor) {
        int rows = arr.length / cols;
        int width = cols * cfactor;
        int height = rows * rfactor;
        int[] result = new int[width * height];
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                result[(y * height) + x] = arr[((y / rfactor) * rows) + (x / cfactor)];
            }
        }
        return result;
    }
}

结果

以下是文档中的所有缓冲图像类型。
类型_custom=0；
类型\u int \u rgb=1；
类型\u int \u argb=2；
类型\u int \u argb \u pre=3；
类型\u int \u bgr=4；
类型\u 3byte \u bgr=5；
类型4字节\u abgr=6；
类型4 byte\u abgr\u pre=7；
类型\u ushort \u 565 \u rgb=8；
键入\u ushort \u 555 \u rgb=9；
类型\字节\灰色=10；
类型\u ushort \u gray=11；
类型_byte_binary=12；
类型\字节\索引=13；
通过grepcode:jdk/jdk/openjdk/8u40-b25/java.awt.image.bufferedimage

// Image type is not recognized so it must be a customized image. This type is only used as a return value for the getType() method.
public static final int TYPE_CUSTOM = 0;

// Represents an image with 8-bit RGB color components packed into integer pixels. The image has a DirectColorModel without alpha. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded, as described in the java.awt.AlphaComposite documentation.
public static final int TYPE_INT_RGB = 1;

// Represents an image with 8-bit RGBA color components packed into integer pixels. The image has a DirectColorModel with alpha. The color data in this image is considered not to be premultiplied with alpha. When this type is used as the imageType argument to a BufferedImage constructor, the created image is consistent with images created in the JDK1.1 and earlier releases.
public static final int TYPE_INT_ARGB = 2;

// Represents an image with 8-bit RGBA color components packed into integer pixels. The image has a DirectColorModel with alpha. The color data in this image is considered to be premultiplied with alpha.
public static final int TYPE_INT_ARGB_PRE = 3;

// Represents an image with 8-bit RGB color components, corresponding to a Windows- or Solaris- style BGR color model, with the colors Blue, Green, and Red packed into integer pixels. There is no alpha. The image has a DirectColorModel. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded, as described in the java.awt.AlphaComposite documentation.
public static final int TYPE_INT_BGR = 4;

// Represents an image with 8-bit RGB color components, corresponding to a Windows-style BGR color model) with the colors Blue, Green, and Red stored in 3 bytes. There is no alpha. The image has a ComponentColorModel. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded, as described in the java.awt.AlphaComposite documentation.
public static final int TYPE_3BYTE_BGR = 5;

// Represents an image with 8-bit RGBA color components with the colors Blue, Green, and Red stored in 3 bytes and 1 byte of alpha. The image has a ComponentColorModel with alpha. The color data in this image is considered not to be premultiplied with alpha. The byte data is interleaved in a single byte array in the order A, B, G, R from lower to higher byte addresses within each pixel.
public static final int TYPE_4BYTE_ABGR = 6;

// Represents an image with 8-bit RGBA color components with the colors Blue, Green, and Red stored in 3 bytes and 1 byte of alpha. The image has a ComponentColorModel with alpha. The color data in this image is considered to be premultiplied with alpha. The byte data is interleaved in a single byte array in the order A, B, G, R from lower to higher byte addresses within each pixel.
public static final int TYPE_4BYTE_ABGR_PRE = 7;

// Represents an image with 5-6-5 RGB color components (5-bits red, 6-bits green, 5-bits blue) with no alpha. This image has a DirectColorModel. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded, as described in the java.awt.AlphaComposite documentation.
public static final int TYPE_USHORT_565_RGB = 8;

// Represents an image with 5-5-5 RGB color components (5-bits red, 5-bits green, 5-bits blue) with no alpha. This image has a DirectColorModel. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded, as described in the java.awt.AlphaComposite documentation.
public static final int TYPE_USHORT_555_RGB = 9;

// Represents a unsigned byte grayscale image, non-indexed. This image has a ComponentColorModel with a CS_GRAY java.awt.color.ColorSpace. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded, as described in the java.awt.AlphaComposite documentation.
public static final int TYPE_BYTE_GRAY = 10;

// Represents an unsigned short grayscale image, non-indexed). This image has a ComponentColorModel with a CS_GRAY ColorSpace. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded, as described in the java.awt.AlphaComposite documentation.
public static final int TYPE_USHORT_GRAY = 11;

// Represents an opaque byte-packed 1, 2, or 4 bit image. The image has an IndexColorModel without alpha. When this type is used as the imageType argument to the BufferedImage constructor that takes an imageType argument but no ColorModel argument, a 1-bit image is created with an IndexColorModel with two colors in the default sRGB ColorSpace: {0, 0, 0} and {255, 255, 255}. Images with 2 or 4 bits per pixel may be constructed via the BufferedImage constructor that takes a ColorModel argument by supplying a ColorModel with an appropriate map size. Images with 8 bits per pixel should use the image types TYPE_BYTE_INDEXED or TYPE_BYTE_GRAY depending on their ColorModel. When color data is stored in an image of this type, the closest color in the colormap is determined by the IndexColorModel and the resulting index is stored. Approximation and loss of alpha or color components can result, depending on the colors in the IndexColorModel colormap.
public static final int TYPE_BYTE_BINARY = 12;

// Represents an indexed byte image. When this type is used as the imageType argument to the BufferedImage constructor that takes an imageType argument but no ColorModel argument, an IndexColorModel is created with a 256-color 6/6/6 color cube palette with the rest of the colors from 216-255 populated by grayscale values in the default sRGB ColorSpace. When color data is stored in an image of this type, the closest color in the colormap is determined by the IndexColorModel and the resulting index is stored. Approximation and loss of alpha or color components can result, depending on the colors in the IndexColorModel colormap.
public static final int TYPE_BYTE_INDEXED = 13;