JAVA 图像操作辅助类

 package util;

 import java.awt.Component;
 import java.awt.Image;
 import java.awt.MediaTracker;
 import java.awt.image.CropImageFilter;
 import java.awt.image.FilteredImageSource;
 import java.awt.image.ImageFilter;
 import java.awt.image.ImageProducer;

 /**
  * 图像操作辅助类
  *
  * @author hellokitty燕
  *
  */
 public class ImageUtils {

     private ImageUtils() {
     }

     /**
      * 使用媒体追踪器加载单张图像
      *
      * @param mediaTracker
      *            媒体追踪器
      * @param image
      *            待加载图像
      * @return 加载完毕的图像
      */
     public static Image addImage(MediaTracker mediaTracker, Image image) {
         // 将图片放置到媒体追踪器的图片列表中，准备开始加载工作
         mediaTracker.addImage(image, );
         try {
             // 加载所有图片
             mediaTracker.waitForAll();
         } catch (InterruptedException e) {
             System.err.println(e.getMessage());
         }
         // 官方提供的标准处理代码
         // & -- 按位与运算
         // 如满足条件表达式，则说明图像加载出错
         // statusAll(false) -- 返回媒体跟踪器跟踪的所有媒体状态，如图像未加载，也不会进行加载
         if ((mediaTracker.statusAll(false) & MediaTracker.ERRORED) != ) {
             System.err.println("图片加载出错...");
         }
         return image;
     }

     /**
      * 使用媒体追踪器加载多张图像（一维数组）
      *
      * @param mediaTracker
      *            媒体追踪器
      * @param images
      *            待加载的一维数组中的图像
      * @return 加载完毕的图像
      */
     public static Image[] addImage(MediaTracker mediaTracker, Image[] images) {
         for (int i = ; i < images.length; i++) {
             mediaTracker.addImage(images[i], i);
         }
         try {
             mediaTracker.waitForAll();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         // 官方提供的标准处理代码
         // & -- 按位与运算
         // 如满足条件表达式，则说明图像加载出错
         // statusAll(false) -- 返回媒体跟踪器跟踪的所有媒体状态，如图像未加载，也不会进行加载
         if ((mediaTracker.statusAll(false) & MediaTracker.ERRORED) != ) {
             System.err.println("图片加载出错...");
         }
         return images;
     }

     /**
      * 使用媒体追踪器加载多张图像（二维数组）
      *
      * @param mediaTracker
      *            媒体追踪器
      * @param images
      *            待加载的二维数组中的图像
      * @return 加载完毕的图像
      */
     public static Image[][] addImage(MediaTracker mediaTracker, Image[][] images) {
         for (int i = ; i < images.length; i++) {
             for (int j = ; j < images[i].length; j++) {
                 mediaTracker.addImage(images[i][j], i);
             }
         }
         try {
             mediaTracker.waitForAll();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         // 官方提供的标准处理代码
         // & -- 按位与运算
         // 如满足条件表达式，则说明图像加载出错
         // statusAll(false) -- 返回媒体跟踪器跟踪的所有媒体状态，如图像未加载，也不会进行加载
         if ((mediaTracker.statusAll(false) & MediaTracker.ERRORED) != ) {
             System.err.println("图片加载出错...");
         }
         return images;
     }

     /**
      * 将传入的图片进行裁剪，裁剪后生成图像放入一维数组中保存，再进行图像加载。 通常用于裁剪所有图像在一行中的源图像
      *
      * @param img
      *            待裁剪图像
      * @param count
      *            裁剪后的图像数量
      * @param x
      *            开始裁剪x坐标
      * @param y
      *            开始裁剪y坐标
      * @param width
      *            每次裁剪图像宽度
      * @param height
      *            每次裁剪图像高度
      * @param changeX
      *            每次裁剪需要改变的x坐标值
      * @param mediaTracker
      *            媒体追踪器
      * @param component
      *            用来创建裁剪后的每个图片对象的组件
      * @return 裁剪完并加载到内存后的一维图片数组
      */
     public static Image[] cutAndAddImage(Image img, int count, int x, int y,
             int width, int height, int changeX, MediaTracker mediaTracker,
             Component component) {
         // 创建保存裁剪后图像的一维数组
         Image[] images = new Image[count];
         /* 循环裁剪图像 */
         ImageProducer producer = img.getSource(); // 获取图像源
         for (int i = ; i < count; i++) {
             // 创建用于裁剪的图像过滤器
             ImageFilter cropImageFilter = new CropImageFilter(x + i * changeX,
                     y, width, height);
             // 裁剪源图像，将裁剪后的图像放入数组保存
             images[i] = component.createImage(new FilteredImageSource(producer,
                     cropImageFilter));
         }

         // 调用 使用媒体追踪器加载多张图像（一维数组） 的方法完成图像加载
         return addImage(mediaTracker, images);
     }

     /**
      * 将传入的图片进行裁剪，裁剪后生成图像放入二维数组中保存，再进行图像加载 通常用于裁剪所有图像在多行多列中的源图像
      *
      * @param img
      *            待裁剪图像
      * @param rows
      *            裁剪后的图像行数，即垂直方向上需要裁剪出的图片数量
      * @param columns
      *            裁剪后的图像列数，即水平方向上需要裁剪出的图片数量
      * @param x
      *            开始裁剪x坐标
      * @param y
      *            开始裁剪y坐标
      * @param width
      *            每次裁剪图像宽度
      * @param height
      *            每次裁剪图像高度
      * @param changeX
      *            每次裁剪需要改变的x坐标值
      * @param changeY
      *            每次裁剪需要改变的y坐标值
      * @param mediaTracker
      *            媒体追踪器
      * @param component
      *            用来创建裁剪后的每个图片对象的组件
      * @return 裁剪完并加载到内存后的二维图片数组
      */
     public static Image[][] cutAndAddImage(Image img, int rows, int columns,
             int x, int y, int width, int height, int changeX, int changeY,
             MediaTracker mediaTracker, Component component) {
         // 创建剪裁后图像保存的二维数组
         Image[][] images = new Image[rows][columns];
         // 获取图像源
         ImageProducer producer = img.getSource();
         /* 循环剪裁图像 */
         for (int i = ; i < rows; i++) {
             for (int j = ; j < columns; j++) {
                 // 创建用于剪裁图像的过滤器
                 ImageFilter cropImageFilter = new CropImageFilter(x + j
                         * changeX, y + i * changeY, width, height);
                 // 剪裁源图像，保存剪裁后的图像
                 images[i][j] = component.createImage(new FilteredImageSource(
                         producer, cropImageFilter));

             }
         }
         // 调用 使用媒体追踪器加载多张图像（二维数组） 的方法完成图像加载
         return addImage(mediaTracker, images);
     }
 }