Java（J2ME）将图像转换为字节[]，然后返回到图像

我试图将一个图像对象转换为字节数组，然后再转换回一个图像（这样我就可以将图像存储在ApacheDerby数据库中的blob对象中）

我可以将图像转换为字节数组（下面的代码），但无法将字节转换回图像。更复杂的是，我使用的是J2ME，所以我不能使用javax.image.*。 你能帮忙吗

谢谢

package six.util;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver; 
import java.awt.Component; 
import java.awt.MediaTracker;
import java.awt.Graphics;
import java.awt.image.DataBufferByte;
import java.awt.image.WritableRaster;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.image.PixelGrabber;
import java.util.ArrayList;

public class ImageConverter extends Component
{

private MediaTracker mediaTracker;
private Image image;

private ImageConverter(Image image)
{
    super();
    this.mediaTracker = new MediaTracker(this);
    this.mediaTracker.addImage(image, 0);
    this.image = image;
}

private BufferedImage convert()
{
    /*
     * Have to wait for image to load.
     */
    try
    {
        this.mediaTracker.waitForID(0);
    }catch(InterruptedException e)
    {

    }
    System.out.println("-1");

    GraphicsConfiguration graphicsConfig = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
    BufferedImage bimage = graphicsConfig.createCompatibleImage(this.image.getWidth(null),this.image.getHeight(null));
    System.out.println("-2");
    Graphics g = bimage.getGraphics();
    g.drawImage(image, 0, 0, null);
    return bimage;
}

private static byte[] convertIntToByteArray(int integer)
{
    byte[] bytes = new byte[4];
    bytes[0] =(byte)( integer >> 24 );
    bytes[1] =(byte)( (integer << 8) >> 24 );
    bytes[2] =(byte)( (integer << 16) >> 24 );
    bytes[3] =(byte)( (integer << 24) >> 24 );
    return bytes;
}

private static int convertByteArrayToInt(byte[] bytes)
{
    return (bytes[0] << 32) | (bytes[1] << 24) | (bytes[2] << 16) | (bytes[3] << 8) | bytes[4];
}

private static byte[] convertIntArrayToByteArray(int[] integers)
{
    byte[] bytes = new byte[integers.length*4];
    for (int index = 0; index < integers.length; index++)
    {
        byte[] integerBytes = convertIntToByteArray(integers[index]);
        bytes[index*4] =        integerBytes[0];
        bytes[1 + (index*4)] = integerBytes[1];
        bytes[2 + (index*4)] = integerBytes[2];
        bytes[3 + (index*4)] = integerBytes[3];
    }
    return bytes;
}

private static int[] convertByteArrayToIntArray(byte[] bytes)
{
    ArrayList integers = new ArrayList();
    for (int index = 0; index < bytes.length; index += 4)
    {
        byte[] fourBytes = new byte[4];
        fourBytes[0] = bytes[index];
        fourBytes[1] = bytes[index+1];
        fourBytes[2] = bytes[index+2];
        fourBytes[3] = bytes[index+3];
        int integer = convertByteArrayToInt(fourBytes);
        integers.add(new Integer(integer));
    }
    int[] ints = new int[bytes.length/4];
    for (int index = 0; index < integers.size() ; index++)
    {
        ints[index] = ((Integer)integers.get(index)).intValue();
    }
    return ints;
}

public static byte[] convertToBytes(Image image)
{
    System.out.println("A");
    ImageConverter converter = new ImageConverter(image);
    System.out.println("B");
    BufferedImage bufferedImage = converter.convert();
    System.out.println("C");
    PixelGrabber pixelGrabber = new PixelGrabber(image,0,0,bufferedImage.getWidth(),bufferedImage.getHeight(),true);
    System.out.println("D");
    try
    {
        if(pixelGrabber.grabPixels())
        {
            Object pixels = pixelGrabber.getPixels();
            if (pixels instanceof byte[])
            {   
                return (byte[])pixels;
            }
            return convertIntArrayToByteArray((int[])pixels);
        }
    }catch(InterruptedException e)
    {
    }
    return null;
}


 }

package six.util；
导入java.awt.Image；
导入java.awt.image.buffereImage；
导入java.awt.image.ImageObserver；
导入java.awt.Component；
导入java.awt.MediaTracker；
导入java.awt.Graphics；
导入java.awt.image.DataBufferByte；
导入java.awt.image.WritableRaster；
导入java.awt.GraphicsConfiguration；
导入java.awt.GraphicsDevice；
导入java.awt.GraphicsEnvironment；
导入java.awt.image.PixelGrabber；
导入java.util.ArrayList；
公共类ImageConverter扩展组件
{
私有媒体跟踪器；
私有图像；
专用图像转换器（图像）
{
超级（）；
this.mediaTracker=新的mediaTracker（this）；
this.mediaTracker.addImage（图像，0）；
这个图像=图像；
}
专用缓冲区映像转换（）
{
/*
*必须等待图像加载。
*/
尝试
{
this.mediaTracker.waitForID（0）；
}捕捉（中断异常e）
{
}
系统输出打印项次（“-1”）；
GraphicsConfiguration graphicsConfig=GraphicsEnvironment.getLocalGraphicsEnvironment（）.getDefaultScreenDevice（）.getDefaultConfiguration（）；
BuffereImage bimage=graphicsConfig.createCompatibleImage（this.image.getWidth（null）、this.image.getHeight（null））；
System.out.println（“-2”）；
Graphics g=bimage.getGraphics（）；
g、 drawImage（image，0，0，null）；
返回双图像；
}
专用静态字节[]convertIntToByteArray（整数）
{
字节[]字节=新字节[4]；
字节[0]=（字节）（整数>>24）；
字节[1]=（字节）（（整数>24）；
字节[2]=（字节）（（整数>24）；
字节[3]=（字节）（（整数>24）；
返回字节；
}
专用静态整型convertByteArrayToInt（字节[]字节）
{
return（bytes[0]要重新创建图像，您可以使用image类（）中的createRGBImage方法，但请注意，图像中的每个像素使用4个字节。宽度为200 x 200像素的图像将总共有40000个像素，这将占用移动设备中160KB的内存

我以前在J2ME中使用过图像，但只将图像从服务器发送到客户端。在这种情况下，您可以在服务器上更改图像的分辨率（在服务器上，您可以使用代码和原始功能进行更改），将其编码为JPEG，然后将其发送到客户端。方法image.createImage（…）可以以运行应用程序的J2ME引擎支持的任何编码格式创建图像。我相信JPEG将始终被接受

即使您需要这些图像以备将来使用，您也可以将服务器返回的字节[]缓冲区保存在记录存储中，然后使用它。
我不知道javame，但这不管用吗

javax.microedition.lcdui.Image.createImage(new ByteArrayInputStream(byte[]))