JDK1.3里怎么操作图片

操作图片？指什么操作？修改还是保存还是其它什么的？
BufferedImage、Image、Graphics和Graphics2D，以及java.awt.image.*下的类处理图片
保存用别人提供的图形包或tigeryu所说的com.sun.image.codec.jpeg包下的类保存为jpg格式的提供一个保存为bmp的类：/****************************************
  此类是将图形存成BMP格式的BMPFile类
//***************************************/
import java.io.*;
import java.awt.*;
import java.awt.image.*;
class BMPFile extends Component {

  //--- Private constants
  private final static int BITMAPFILEHEADER_SIZE = 14;
  private final static int BITMAPINFOHEADER_SIZE = 40;

  //--- Private variable declaration

  //--- Bitmap file header
  private byte bitmapFileHeader [] = new byte [14];
  private byte bfType [] = {'B', 'M'};
  private int bfSize = 0;
  private int bfReserved1 = 0;
  private int bfReserved2 = 0;
  private int bfOffBits = BITMAPFILEHEADER_SIZE + BITMAPINFOHEADER_SIZE;

  //--- Bitmap info header
  private byte bitmapInfoHeader [] = new byte [40];
  private int biSize = BITMAPINFOHEADER_SIZE;
  private int biWidth = 0;
  private int biHeight = 0;
  private int biPlanes = 1;
  private int biBitCount = 24;
  private int biCompression = 0;
  private int biSizeImage = 0x030000;
  private int biXPelsPerMeter = 0x0;
  private int biYPelsPerMeter = 0x0;
  private int biClrUsed = 0;
  private int biClrImportant = 0;

  //--- Bitmap raw data
  private int bitmap [];

  //--- File section
  private FileOutputStream fo;

  //--- Default constructor
  public BMPFile() {

  }

  public void saveBitmap (File parFilename, Image parImage, int parWidth, int parHeight)
  {

     try {
        fo = new FileOutputStream (parFilename);
        save (parImage, parWidth, parHeight);
        fo.close ();
     }
     catch (Exception saveEx) {
        saveEx.printStackTrace ();
     }

  }

  /*
   *  The saveMethod is the main method of the process. This method
   *  will call the convertImage method to convert the memory image to
   *  a byte array; method writeBitmapFileHeader creates and writes
   *  the bitmap file header; writeBitmapInfoHeader creates the
   *  information header; and writeBitmap writes the image.
   *
   */
  private void save (Image parImage, int parWidth, int parHeight)
  {
     try {
        convertImage (parImage, parWidth, parHeight);
        writeBitmapFileHeader ();
        writeBitmapInfoHeader ();
        writeBitmap ();
     }
     catch (Exception saveEx) {
        saveEx.printStackTrace ();
     }
  }

  /*
   * convertImage converts the memory image to the bitmap format (BRG).
   * It also computes some information for the bitmap info header.
   *
   */
  private boolean convertImage (Image parImage, int parWidth, int parHeight)
  {
     int pad;
     bitmap = new int [parWidth * parHeight];

     PixelGrabber pg = new PixelGrabber (parImage, 0, 0, parWidth, parHeight,
                                         bitmap, 0, parWidth);

     try {
        pg.grabPixels ();
     }
     catch (InterruptedException e) {
        e.printStackTrace ();
        return (false);
     }
     pad = (parWidth * 3) % 4;
     if (pad != 0)
       pad = (4 - pad) * parHeight;
     biSizeImage = ((parWidth * parHeight) * 3) + pad;
     bfSize = biSizeImage + BITMAPFILEHEADER_SIZE +
              BITMAPINFOHEADER_SIZE;
     biWidth = parWidth;
     biHeight = parHeight;

     return (true);
  }

  /*
   * writeBitmap converts the image returned from the pixel grabber to
   * the format required. Remember: scan lines are inverted in
   * a bitmap file!
   *
   * Each scan line must be padded to an even 4-byte boundary.
   */
  private void writeBitmap () {

     int size;
     int value;
     int j;
     int i;
     int rowCount;
     int rowIndex;
     int lastRowIndex;
     int pad;
     int padCount;
     byte rgb [] = new byte [3];
     // if a scanline is not time of 4, add some bytes
     size = (biWidth * biHeight) - 1;
     pad = ((biWidth * 3) % 4);
     if (pad != 0)
       pad = 4 - pad;
     rowCount = 1;
     padCount = 0;
     rowIndex = size - biWidth;
     lastRowIndex = rowIndex;

     try {
        for (j = 0; j < size; j++) {
           value = bitmap [rowIndex];
           rgb [0] = (byte) (value & 0xFF);
           rgb [1] = (byte) ((value >> 8) & 0xFF);
           rgb [2] = (byte) ((value >> 16) & 0xFF);
           fo.write (rgb);
           if (rowCount == biWidth) {
              padCount += pad;
              for (i = 1; i <= pad; i++)
                 fo.write (0x00);
              rowCount = 1;
              rowIndex = lastRowIndex - biWidth;
              lastRowIndex = rowIndex;
           }
           else
              rowCount++;
              rowIndex++;
        }

        //--- Update the size of the file
        bfSize += padCount - pad;
        biSizeImage += padCount - pad;
     }
     catch (Exception wb) {
        wb.printStackTrace ();
     }

  }

  /*
   * writeBitmapFileHeader writes the bitmap file header to the file.
   *
   */
  private void writeBitmapFileHeader () {

     try {
        fo.write (bfType);
        fo.write (intToDWord (bfSize));
        fo.write (intToWord (bfReserved1));
        fo.write (intToWord (bfReserved2));
        fo.write (intToDWord (bfOffBits));

     }
     catch (Exception wbfh) {
        wbfh.printStackTrace ();
     }

  }

  /*
   *
   * writeBitmapInfoHeader writes the bitmap information header
   * to the file.
   *
   */

  private void writeBitmapInfoHeader () {

     try {
        fo.write (intToDWord (biSize));
        fo.write (intToDWord (biWidth));
        fo.write (intToDWord (biHeight));
        fo.write (intToWord (biPlanes));
        fo.write (intToWord (biBitCount));
        fo.write (intToDWord (biCompression));
        fo.write (intToDWord (biSizeImage));
        fo.write (intToDWord (biXPelsPerMeter));
        fo.write (intToDWord (biYPelsPerMeter));
        fo.write (intToDWord (biClrUsed));
        fo.write (intToDWord (biClrImportant));
     }
     catch (Exception wbih) {
        wbih.printStackTrace ();
     }

  }

  /*
   *
   * intToWord converts an int to a word, where the return
   * value is stored in a 2-byte array.
   *
   */
  private byte [] intToWord (int parValue) {

     byte retValue [] = new byte [2];

     retValue [0] = (byte) (parValue & 0x00FF);
     retValue [1] = (byte) ((parValue >> 8) & 0x00FF);

     return (retValue);

  }

  /*
   *
   * intToDWord converts an int to a double word, where the return
   * value is stored in a 4-byte array.
   *
   */
  private byte [] intToDWord (int parValue) {

     byte retValue [] = new byte [4];

     retValue [0] = (byte) (parValue & 0x00FF);
     retValue [1] = (byte) ((parValue >> 8) & 0x000000FF);
     retValue [2] = (byte) ((parValue >> 16) & 0x000000FF);
     retValue [3] = (byte) ((parValue >> 24) & 0x000000FF);
     return (retValue);
  }
}

Bluecatr(蓝夜猫儿) ，强～！我没用过JDK1.3，学习一下。

hehe好老的冬冬阿,不太记得拉-----java.awt.image.*;
MediaTracker mt = new MediaTracker(this);
mt.addImage(i,1);

jdk1.4里使用javax.imageio.ImageIO总是出错
java.lang.IllegalStateException: 已获取输出流
什么原因

调试易

JDK1.3里怎么操作图片

解决方案 »