Java图像处理实战：图片缩放与拉伸技术详解

ImageIO还支持通过来自定义图像写入选项，例如JPEG图像的压缩质量：try {// 获取ImageWriter实例if (!System.out.println("不支持的图像格式");return;// 设置输出流// 自定义写入选项// 设置压缩质量为70%// 执行写入// 关闭资源System.out.println("图像保存成功，压缩质量70%");

微尘-黄含驰

698人浏览 · 2025-09-15 11:19:26

微尘-黄含驰 · 2025-09-15 11:19:26 发布

本文还有配套的精品资源，点击获取

简介：Java提供了强大的图像处理能力，特别是在图片的缩放与拉伸方面。本文围绕Java中 java.awt 和 javax.imageio 包，详细讲解如何使用 AffineTransformOp 和 AffineTransform 类实现图像尺寸的调整。内容涵盖图像加载、均匀与非均匀缩放、图像变换操作以及保存缩放后的图像等关键步骤。通过实际代码示例，帮助开发者掌握在GUI应用或图像处理工具中实现图片缩放的核心技术，并适用于如图像查看器、编辑器等项目场景。
java 图片的缩放与拉伸

1. Java图像处理基础

Java作为一门广泛应用的编程语言，在图像处理领域提供了丰富的类库支持，尤其是AWT（Abstract Window Toolkit）和Swing图形库，为开发者构建图像处理应用奠定了基础。本章将从图像处理的基本概念讲起，逐步介绍Java中图像处理的核心流程，包括图像格式的分类（如PNG、JPEG、GIF等）、AWT与Swing中与图像处理相关的类（如 Image 、 BufferedImage 、 Graphics 等）及其基本用途。通过搭建Java图像处理的开发环境，并初步了解图像加载、显示和处理的流程，读者将建立起对Java图像处理的整体认知，为后续章节深入学习BufferedImage操作、图像变换等技术打下坚实基础。

2. BufferedImage对象的创建与使用

在Java图像处理中， BufferedImage 是核心类之一，它不仅提供了对图像数据的存储和操作能力，还为后续的图像绘制、变换、滤镜等高级操作打下了基础。本章将从 BufferedImage 的基本概念入手，深入讲解其创建方式、像素操作技巧以及与图形上下文（Graphics2D）的交互机制，帮助读者全面掌握该类的使用方法。

2.1 BufferedImage的基本概念

BufferedImage 类是Java 2D API中的关键类之一，位于 java.awt.image 包中，用于表示具有可访问图像数据缓冲区的图像。与 Image 和 BufferedImage 相比，它最大的优势在于可以直接操作图像的像素数据，适合进行图像处理、图像合成、滤镜实现等底层操作。

2.1.1 图像数据的存储方式

BufferedImage 对象由两个核心组件构成： 图像数据模型 （ColorModel）和 图像数据缓冲区 （Raster）。它们共同决定了图像的颜色表示方式和像素的存储格式。

ColorModel ：颜色模型决定了如何将像素值转换为实际的颜色值。常见的颜色模型包括：
DirectColorModel ：用于RGB格式图像，每个通道独立存储。
IndexColorModel ：用于索引图像，像素值是调色板的索引。
Raster ：表示图像的像素数据，包含一个或多个数据缓冲区（DataBuffer），每个缓冲区对应一个图像通道。

下表列出了常用的 BufferedImage 图像类型及其对应的像素存储方式：

图像类型常量	描述	像素格式
`BufferedImage.TYPE_INT_RGB`	3通道RGB，无透明通道	32位整数（RGB）
`BufferedImage.TYPE_INT_ARGB`	4通道RGBA，包含透明度	32位整数（ARGB）
`BufferedImage.TYPE_BYTE_GRAY`	8位灰度图像	8位字节
`BufferedImage.TYPE_USHORT_GRAY`	16位灰度图像	16位无符号短整数
`BufferedImage.TYPE_3BYTE_BGR`	BGR三通道，每个通道8位	24位字节数组
`BufferedImage.TYPE_CUSTOM`	自定义图像类型	根据用户定义的ColorModel和Raster

2.1.2 BufferedImage的图像类型选择

在创建 BufferedImage 对象时，需要根据图像处理需求选择合适的图像类型。例如：

如果需要进行图像滤镜处理，通常选择 TYPE_INT_ARGB 以支持透明度。
如果仅处理灰度图像，选择 TYPE_BYTE_GRAY 可以节省内存。
如果需要与底层图像库（如OpenCV）交互，可能需要使用 TYPE_3BYTE_BGR 等兼容格式。

BufferedImage image = new BufferedImage(800, 600, BufferedImage.TYPE_INT_ARGB);

代码说明：
- 800 和 600 分别表示图像的宽度和高度。
- BufferedImage.TYPE_INT_ARGB 表示图像具有Alpha通道，支持透明度。
- 此方法创建了一个空的ARGB图像，可用于后续绘制或像素操作。

选择合适的图像类型对于图像处理的性能和效果至关重要。例如，在进行图像缩放或旋转操作时，如果源图没有Alpha通道而目标图有，则可能会引入不必要的透明度计算，影响性能。

2.2 BufferedImage的创建方法

创建 BufferedImage 的方式有多种，包括使用构造函数创建空图像、从现有图像复制生成，以及通过图像处理操作生成新图像。以下将分别介绍两种常用方式。

2.2.1 使用构造函数创建空图像

使用 BufferedImage 的构造函数可以创建一个指定大小和类型的空图像对象，常用于图像初始化、图形绘制或像素操作。

BufferedImage emptyImage = new BufferedImage(1024, 768, BufferedImage.TYPE_INT_RGB);

代码说明：
- 创建了一个分辨率为1024x768的RGB图像，不带透明通道。
- 此图像可以作为画布用于后续的图形绘制或图像合成操作。

构造函数创建的图像初始像素值为0，即对于RGB图像为黑色，对于ARGB图像则为完全透明的黑色。为了填充图像内容，可以通过 Graphics2D 对象进行绘制操作。

2.2.2 从现有图像对象复制生成

在处理已有图像时，通常需要基于原图创建副本。可以通过 BufferedImage 的构造函数结合 Graphics2D 对象进行图像复制。

public static BufferedImage copyImage(BufferedImage original) {
    BufferedImage copy = new BufferedImage(
        original.getWidth(),
        original.getHeight(),
        original.getType()
    );
    Graphics2D g2d = copy.createGraphics();
    g2d.drawImage(original, 0, 0, null);
    g2d.dispose();
    return copy;
}

代码逻辑分析：
1. 创建一个与原图大小、类型相同的空图像 copy 。
2. 获取 copy 的 Graphics2D 对象。
3. 使用 drawImage 方法将原图绘制到 copy 上。
4. 释放 Graphics2D 资源，避免内存泄漏。
5. 返回复制后的图像。

这种方式适用于图像处理中的图像缓存、状态保存等场景。

图像复制流程图

graph TD
    A[原始BufferedImage] --> B{创建新BufferedImage}
    B --> C[获取Graphics2D对象]
    C --> D[绘制原图到新图像]
    D --> E[释放Graphics2D资源]
    E --> F[返回复制图像]

2.3 BufferedImage的像素操作

像素操作是图像处理中最底层、最灵活的部分。 BufferedImage 提供了访问像素数据的方法，可以通过 getRGB() 和 setRGB() 直接读写像素值。

2.3.1 获取和设置像素值

获取和设置像素值的常用方法如下：

// 获取指定坐标的像素值
int pixel = image.getRGB(x, y);

// 设置指定坐标的像素值
image.setRGB(x, y, pixel);

参数说明：
- x , y ：像素坐标，从左上角(0,0)开始。
- pixel ：一个int类型值，对于ARGB图像，其高8位为Alpha通道，随后为R、G、B。

对于更精细的像素操作，例如访问每个颜色通道的值，可以使用 Color 类进行解析：

Color color = new Color(image.getRGB(x, y));
int red = color.getRed();
int green = color.getGreen();
int blue = color.getBlue();
int alpha = color.getAlpha();

性能说明：
- getRGB 和 setRGB 适用于小范围像素操作。
- 若需批量处理像素，建议直接操作图像的 Raster 和 DataBuffer 以提高效率。

2.3.2 像素操作的性能优化技巧

对于大规模像素操作（如图像滤镜、边缘检测等），直接使用 getRGB 和 setRGB 会带来较大的性能开销。优化方式如下：

方式一：使用 `getRGB(int startX, int startY, int w, int h, ...)` 批量读取像素

int[] pixels = new int[width * height];
image.getRGB(0, 0, width, height, pixels, 0, width);

参数说明：
- startX , startY ：起始坐标。
- w , h ：读取区域的宽度和高度。
- pixels ：用于存储像素值的数组。
- offset , scansize ：数组偏移量和每行像素数。

方式二：直接操作Raster和DataBuffer

WritableRaster raster = image.getRaster();
DataBufferByte buffer = (DataBufferByte) raster.getDataBuffer();
byte[] data = buffer.getData();

// 假设为灰度图像
for (int i = 0; i < data.length; i++) {
    // 对每个像素进行处理
    data[i] = (byte) (data[i] & 0x0F); // 示例：取低4位
}

适用场景：
- 图像压缩、滤波、直方图均衡等底层图像处理。
- 需要频繁访问像素数据的高性能应用。

2.4 图像绘制与图形上下文

Java图像处理中， Graphics2D 类是图像绘制的核心接口。它不仅可以用于在 BufferedImage 上绘制图形和文本，还可以进行图像合成、抗锯齿、颜色填充等操作。

2.4.1 Graphics2D对象的获取与使用

要获取 BufferedImage 的 Graphics2D 对象，可以使用 createGraphics() 方法：

BufferedImage image = new BufferedImage(800, 600, BufferedImage.TYPE_INT_ARGB);
Graphics2D g2d = image.createGraphics();

注意事项：
- 每次调用 createGraphics() 会创建一个新的 Graphics2D 实例，使用完毕应调用 dispose() 释放资源。
- 可以通过 setRenderingHint() 设置抗锯齿、插值算法等渲染参数。

示例：绘制一个带边框的红色矩形

g2d.setColor(Color.RED);
g2d.setStroke(new BasicStroke(3));
g2d.drawRect(100, 100, 200, 150);
g2d.dispose();

参数说明：
- setColor() ：设置当前绘图颜色。
- setStroke() ：设置线条粗细。
- drawRect() ：绘制矩形框。

2.4.2 在BufferedImage上绘制图形和文本

Graphics2D 支持绘制基本图形（如线段、矩形、椭圆）、路径（Path2D）、图像、文本等。

绘制文本示例：

g2d.setFont(new Font("Arial", Font.BOLD, 36));
g2d.setColor(Color.BLUE);
g2d.drawString("Hello, Java 2D!", 200, 300);

参数说明：
- setFont() ：设置字体样式和大小。
- drawString() ：在指定坐标绘制字符串。

绘制图像示例：

BufferedImage sourceImage = ImageIO.read(new File("source.png"));
g2d.drawImage(sourceImage, 0, 0, 800, 600, null);

参数说明：
- drawImage() ：绘制图像到指定区域。
- null ：表示不使用图像观察器。

图形绘制流程图：

graph TD
    A[创建BufferedImage] --> B[获取Graphics2D对象]
    B --> C{设置绘制属性}
    C --> D[颜色、字体、笔触等]
    D --> E[调用绘制方法]
    E --> F{drawLine, drawRect, drawString等}
    F --> G[释放Graphics2D资源]

本章详细讲解了 BufferedImage 的基本概念、创建方式、像素操作以及图形绘制技术。下一章将介绍如何使用 ImageIO 类进行图像的读取与保存操作，为图像处理流程提供完整的输入输出支持。

3. 使用ImageIO读取和保存图像

Java中的 ImageIO 类是图像处理的重要组成部分，它位于 javax.imageio 包中，提供了一组静态方法用于图像的读取和写入操作。 ImageIO 不仅支持多种图像格式，还通过插件机制实现了良好的可扩展性。本章将深入探讨 ImageIO 类的功能与使用方法，包括图像格式的支持情况、图像的读取与保存流程、以及异常处理策略，帮助开发者掌握图像数据在Java环境中的高效处理方式。

3.1 ImageIO类的基本功能

ImageIO 类是Java图像处理的核心类之一，其设计目标是为开发者提供一种简单而灵活的方式来处理各种图像格式。它通过静态方法提供图像的读取和写入功能，并支持通过插件扩展支持的图像格式。

3.1.1 支持的图像格式列表

ImageIO 默认支持的图像格式包括：JPEG、PNG、GIF、BMP 和 WBMP。开发者可以通过调用 ImageIO.getReaderFormatNames() 或 ImageIO.getWriterFormatNames() 来获取当前环境中支持的图像读取和写入格式。

import javax.imageio.ImageIO;
import java.util.Arrays;

public class ImageFormatChecker {
    public static void main(String[] args) {
        String[] readerFormats = ImageIO.getReaderFormatNames();
        String[] writerFormats = ImageIO.getWriterFormatNames();

        System.out.println("支持的图像读取格式：");
        System.out.println(Arrays.toString(readerFormats));

        System.out.println("\n支持的图像写入格式：");
        System.out.println(Arrays.toString(writerFormats));
    }
}

代码逻辑分析

ImageIO.getReaderFormatNames() ：获取当前JVM中支持的图像读取格式列表。
ImageIO.getWriterFormatNames() ：获取当前JVM中支持的图像写入格式列表。
Arrays.toString() ：将数组转换为字符串形式，便于输出查看。

参数说明

无输入参数，返回字符串数组。

输出结果（示例）

支持的图像读取格式：
[jpeg, jpg, png, gif, bmp, wbmp]

支持的图像写入格式：
[jpeg, jpg, png, gif, bmp]

提示：某些格式（如GIF）可能只支持读取，而不支持写入，具体取决于当前运行环境中的图像插件安装情况。

3.1.2 ImageIO的静态方法与插件机制

ImageIO 类提供了一系列静态方法用于图像的读取和写入：

ImageIO.read(File input) ：从文件中读取图像。
ImageIO.write(RenderedImage im, String formatName, File output) ：将图像写入指定格式的文件。

此外， ImageIO 采用插件机制，允许开发者通过添加第三方插件来扩展支持的图像格式。例如， TwelveMonkeys 插件可以为Java添加对WebP、TIFF等格式的支持。

方法名	功能描述
`ImageIO.read()`	从文件、输入流或URL读取图像
`ImageIO.write()`	将图像写入文件或输出流
`ImageIO.getReaderFormatNames()`	获取支持的图像读取格式
`ImageIO.getWriterFormatNames()`	获取支持的图像写入格式

扩展建议 ：如需支持更多图像格式，推荐使用开源插件库，如 TwelveMonkeys ImageIO 。

3.2 图像的读取操作

图像读取是图像处理的第一步， ImageIO 提供了多种方式来加载图像数据，包括从本地文件系统读取，或从输入流中加载。

3.2.1 从本地文件读取图像

最常见的方式是通过 ImageIO.read(File input) 方法从本地磁盘加载图像。

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class ImageLoader {
    public static void main(String[] args) {
        try {
            File file = new File("input.jpg");
            BufferedImage image = ImageIO.read(file);
            System.out.println("图像宽度：" + image.getWidth());
            System.out.println("图像高度：" + image.getHeight());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码逻辑分析

File file = new File("input.jpg") ：创建一个指向图像文件的 File 对象。
BufferedImage image = ImageIO.read(file) ：使用 ImageIO.read() 方法读取图像并返回 BufferedImage 对象。
image.getWidth() 和 image.getHeight() ：获取图像的宽度和高度。
try-catch 块 ：捕获可能出现的IO异常。

参数说明

input.jpg ：图像文件路径。
BufferedImage ：Java中用于表示图像数据的核心类。

流程图：图像读取过程

graph TD
    A[开始] --> B[创建File对象]
    B --> C[调用ImageIO.read()方法]
    C --> D{文件是否存在？}
    D -->|是| E[读取图像数据]
    D -->|否| F[抛出IOException]
    E --> G[获取图像尺寸]
    G --> H[结束]

3.2.2 从输入流中加载图像数据

有时图像数据可能来自网络或数据库，此时可以通过 InputStream 读取图像：

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.FileInputStream;
import java.io.IOException;

public class InputStreamImageLoader {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.png")) {
            BufferedImage image = ImageIO.read(fis);
            System.out.println("图像类型：" + image.getType());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码逻辑分析

FileInputStream fis = new FileInputStream("input.png") ：创建文件输入流。
ImageIO.read(fis) ：从输入流中读取图像。
image.getType() ：获取图像的类型（如 BufferedImage.TYPE_INT_RGB ）。

参数说明

input.png ：图像文件路径。
FileInputStream ：用于读取文件内容的输入流。

3.3 图像的保存操作

将处理后的图像保存回文件系统是图像处理的重要环节。 ImageIO.write() 方法可以将 BufferedImage 对象写入指定格式的文件。

3.3.1 指定图像格式进行保存

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class ImageSaver {
    public static void main(String[] args) {
        try {
            // 创建一个空白图像
            BufferedImage image = new BufferedImage(800, 600, BufferedImage.TYPE_INT_RGB);
            File file = new File("output.png");

            // 保存为PNG格式
            boolean success = ImageIO.write(image, "png", file);
            if (success) {
                System.out.println("图像保存成功！");
            } else {
                System.out.println("不支持的图像格式");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码逻辑分析

BufferedImage image = new BufferedImage(...) ：创建一个空白图像用于演示。
ImageIO.write(image, "png", file) ：将图像保存为PNG格式。
返回值 success ：如果指定格式支持且写入成功则返回 true 。

参数说明

image ：待保存的图像对象。
"png" ：指定保存格式。
file ：目标文件路径。

3.3.2 自定义图像写入选项

ImageIO 还支持通过 ImageWriteParam 来自定义图像写入选项，例如JPEG图像的压缩质量：

import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.stream.FileImageOutputStream;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Iterator;

public class CustomImageSaver {
    public static void main(String[] args) {
        try {
            BufferedImage image = new BufferedImage(800, 600, BufferedImage.TYPE_INT_RGB);
            File file = new File("output.jpg");

            // 获取ImageWriter实例
            Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("jpg");
            if (!writers.hasNext()) {
                System.out.println("不支持的图像格式");
                return;
            }
            ImageWriter writer = writers.next();

            // 设置输出流
            FileImageOutputStream output = new FileImageOutputStream(file);
            writer.setOutput(output);

            // 自定义写入选项
            ImageWriteParam param = writer.getDefaultWriteParam();
            param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
            param.setCompressionQuality(0.7f); // 设置压缩质量为70%

            // 执行写入
            writer.write(null, new IIOImage(image, null, null), param);

            // 关闭资源
            output.close();
            writer.dispose();
            System.out.println("图像保存成功，压缩质量70%");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码逻辑分析

ImageIO.getImageWritersByFormatName("jpg") ：获取支持JPEG格式的写入器。
ImageWriteParam ：设置压缩模式和压缩质量。
writer.write() ：执行图像写入操作。
资源关闭 ：确保输出流和写入器正确释放。

参数说明

param.setCompressionMode(...) ：设置压缩模式为显式模式。
param.setCompressionQuality(0.7f) ：设置JPEG压缩质量为70%。

3.4 图像读写异常处理

图像读写过程中可能会遇到多种异常，合理处理这些异常是保证程序健壮性的关键。

3.4.1 常见IO异常及应对策略

异常类型	原因	解决方案
`IOException`	文件路径错误、权限不足、文件损坏	检查文件路径、权限、完整性
`IIOException`	图像格式不支持、读写器缺失	使用第三方插件扩展支持
`NoSuchElementException`	没有找到图像读写器	检查图像格式是否受支持

示例代码：统一异常处理

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class ImageExceptionHandler {
    public static void main(String[] args) {
        try {
            File file = new File("input.jpg");
            BufferedImage image = ImageIO.read(file);
            if (image == null) {
                System.out.println("无法识别图像格式");
                return;
            }

            File output = new File("output.png");
            ImageIO.write(image, "png", output);
        } catch (IOException e) {
            System.err.println("图像读写失败：" + e.getMessage());
            e.printStackTrace();
        }
    }
}

3.4.2 图像格式不支持的解决方案

当遇到不支持的图像格式时，可以通过以下方式解决：

检查当前支持的格式 ：使用 ImageIO.getReaderFormatNames() 确认是否支持目标格式。
引入第三方插件 ：如 TwelveMonkeys 支持WebP、TIFF等格式。
格式转换 ：将图像转换为支持的格式再进行读写。

本章总结

本章详细介绍了Java中使用 ImageIO 类进行图像读取和保存的操作流程，包括常见图像格式的支持情况、读写方法的使用方式、自定义写入选项以及异常处理策略。通过具体代码示例和流程图，帮助开发者掌握如何在Java项目中高效地处理图像数据。

4. AffineTransform类详解

在Java图像处理中， AffineTransform 类是实现图像几何变换的核心工具之一。它不仅支持基本的缩放、平移、旋转和倾斜操作，还能够通过矩阵运算实现多种变换的叠加与复合。理解 AffineTransform 的数学原理与实现机制，是掌握Java图像变换能力的关键。本章将从其数学基础入手，逐步讲解其在图像处理中的具体应用。

4.1 AffineTransform的基本原理

4.1.1 仿射变换的数学基础

仿射变换（Affine Transformation）是图像处理中一种基础且强大的几何变换方式，其核心在于利用线性代数中的矩阵运算来实现对图像的平移、旋转、缩放、剪切等操作。仿射变换的本质是将二维空间中的点通过一个矩阵乘法和一个平移向量映射到另一个二维空间中的点。

其数学表达式如下：

\begin{bmatrix}
x’ \
y’ \
1
\end{bmatrix}
=
\begin{bmatrix}
a & b & tx \
c & d & ty \
0 & 0 & 1
\end{bmatrix}
\times
\begin{bmatrix}
x \
y \
1
\end{bmatrix}

其中：

$ x, y $ 是原始坐标；
$ x’, y’ $ 是变换后的坐标；
$ a, b, c, d $ 表示线性变换部分（如缩放、旋转、剪切）；
$ tx, ty $ 表示平移量。

Java中的 AffineTransform 类正是基于这种数学模型实现的。通过设置矩阵中的参数，可以实现各种复杂的图像变换。

4.1.2 Java中AffineTransform的内部矩阵结构

在Java中， AffineTransform 类内部使用了如下矩阵结构：

\begin{bmatrix}
m00 & m01 & m02 \
m10 & m11 & m12
\end{bmatrix}

这个矩阵与前面提到的仿射变换矩阵相对应，其中：

$ m00 = a $，$ m01 = b $，$ m02 = tx $；
$ m10 = c $，$ m11 = d $，$ m12 = ty $。

可以通过 getMatrix(double[] flatmatrix) 方法获取矩阵参数，也可以通过 setTransform(double m00, double m01, double m02, double m10, double m11, double m12) 方法设置矩阵值。

示例代码：获取和设置矩阵参数

import java.awt.geom.AffineTransform;

public class AffineTransformMatrixDemo {
    public static void main(String[] args) {
        // 创建一个单位矩阵变换（无变换）
        AffineTransform transform = new AffineTransform();

        // 设置缩放变换：x方向缩放2倍，y方向缩放1.5倍
        transform.setToScale(2.0, 1.5);

        // 获取矩阵参数
        double[] matrix = new double[6];
        transform.getMatrix(matrix);

        System.out.println("Matrix elements:");
        System.out.println("m00: " + matrix[0]); // a
        System.out.println("m01: " + matrix[1]); // b
        System.out.println("m02: " + matrix[2]); // tx
        System.out.println("m10: " + matrix[3]); // c
        System.out.println("m11: " + matrix[4]); // d
        System.out.println("m12: " + matrix[5]); // ty
    }
}

代码分析：

AffineTransform transform = new AffineTransform();
创建一个默认的单位矩阵变换，表示没有任何变换操作。
transform.setToScale(2.0, 1.5);
设置为缩放变换，x轴缩放2倍，y轴缩放1.5倍。
double[] matrix = new double[6];
定义一个长度为6的数组用于存储矩阵参数。
transform.getMatrix(matrix);
将当前变换矩阵的参数写入数组 matrix 中。
输出矩阵参数
打印出矩阵中的每个参数，可以验证缩放操作是否生效。

输出结果（预期）：

Matrix elements:
m00: 2.0
m01: 0.0
m02: 0.0
m10: 0.0
m11: 1.5
m12: 0.0

这个输出验证了矩阵参数的设置是否符合预期，也展示了Java中 AffineTransform 的矩阵结构是如何与数学模型一一对应的。

4.2 缩放变换的实现机制

4.2.1 均匀缩放与非均匀缩放的数学表达

缩放变换是图像处理中最常见的操作之一，它通过改变图像中像素点的坐标来实现图像的放大或缩小。

均匀缩放（Uniform Scaling） ：x轴和y轴缩放比例相同，即$ s_x = s_y $。例如： transform.setToScale(2.0, 2.0) 。
非均匀缩放（Non-uniform Scaling） ：x轴和y轴缩放比例不同，即$ s_x \neq s_y $。例如： transform.setToScale(2.0, 1.5) 。

示例代码：实现均匀与非均匀缩放

import java.awt.geom.AffineTransform;

public class ScaleDemo {
    public static void main(String[] args) {
        // 创建变换对象
        AffineTransform uniformScale = new AffineTransform();
        AffineTransform nonUniformScale = new AffineTransform();

        // 设置均匀缩放
        uniformScale.setToScale(2.0, 2.0);

        // 设置非均匀缩放
        nonUniformScale.setToScale(2.0, 1.5);

        // 打印矩阵
        printMatrix("Uniform Scale Matrix", uniformScale);
        printMatrix("Non-uniform Scale Matrix", nonUniformScale);
    }

    // 打印矩阵参数
    private static void printMatrix(String title, AffineTransform transform) {
        double[] matrix = new double[6];
        transform.getMatrix(matrix);
        System.out.println(title + ":");
        System.out.println("m00: " + matrix[0] + ", m01: " + matrix[1] + ", m02: " + matrix[2]);
        System.out.println("m10: " + matrix[3] + ", m11: " + matrix[4] + ", m12: " + matrix[5]);
        System.out.println();
    }
}

输出结果：

Uniform Scale Matrix:
m00: 2.0, m01: 0.0, m02: 0.0
m10: 0.0, m11: 2.0, m12: 0.0

Non-uniform Scale Matrix:
m00: 2.0, m01: 0.0, m02: 0.0
m10: 0.0, m11: 1.5, m12: 0.0

可以看到，均匀缩放的x和y轴缩放系数相同，而非均匀缩放则不同。这为图像处理提供了灵活的缩放方式。

4.2.2 缩放中心的选择与变换顺序

在进行图像缩放时，通常需要指定缩放的中心点。如果不指定，缩放默认以原点(0,0)为中心进行，这可能导致图像偏离原位置。

示例代码：设置缩放中心

import java.awt.geom.AffineTransform;

public class ScaleWithCenter {
    public static void main(String[] args) {
        // 创建变换对象
        AffineTransform transform = new AffineTransform();

        // 设置缩放中心为(100, 100)，缩放比例为2.0
        transform.translate(100, 100); // 移动到缩放中心
        transform.scale(2.0, 2.0);     // 缩放
        transform.translate(-100, -100); // 移回原位置

        // 打印矩阵
        printMatrix("Scaled with Center", transform);
    }

    private static void printMatrix(String title, AffineTransform transform) {
        double[] matrix = new double[6];
        transform.getMatrix(matrix);
        System.out.println(title + ":");
        System.out.println("m00: " + matrix[0] + ", m01: " + matrix[1] + ", m02: " + matrix[2]);
        System.out.println("m10: " + matrix[3] + ", m11: " + matrix[4] + ", m12: " + matrix[5]);
        System.out.println();
    }
}

输出结果：

Scaled with Center:
m00: 2.0, m01: 0.0, m02: -100.0
m10: 0.0, m11: 2.0, m12: -100.0

该变换的流程如下图所示：

graph TD
    A[原始图像] --> B[平移到缩放中心]
    B --> C[执行缩放操作]
    C --> D[平移回原位置]
    D --> E[最终缩放图像]

这段代码演示了如何通过先平移再缩放再平移的方式，实现以指定点为中心的缩放操作。

4.3 其他几何变换操作

4.3.1 平移（Translation）

平移变换是指将图像整体沿x轴或y轴移动一定的距离。其矩阵形式如下：

\begin{bmatrix}
1 & 0 & tx \
0 & 1 & ty
\end{bmatrix}

示例代码：图像平移操作

import java.awt.geom.AffineTransform;

public class TranslateDemo {
    public static void main(String[] args) {
        AffineTransform transform = new AffineTransform();
        transform.translate(50, 100); // 沿x轴移动50，y轴移动100

        printMatrix("Translation Matrix", transform);
    }

    private static void printMatrix(String title, AffineTransform transform) {
        double[] matrix = new double[6];
        transform.getMatrix(matrix);
        System.out.println(title + ":");
        System.out.println("m00: " + matrix[0] + ", m01: " + matrix[1] + ", m02: " + matrix[2]);
        System.out.println("m10: " + matrix[3] + ", m11: " + matrix[4] + ", m12: " + matrix[5]);
        System.out.println();
    }
}

输出结果：

Translation Matrix:
m00: 1.0, m01: 0.0, m02: 50.0
m10: 0.0, m11: 1.0, m12: 100.0

4.3.2 旋转（Rotation）

旋转变换用于将图像绕某一点旋转一定角度。其基本矩阵如下（绕原点旋转θ弧度）：

\begin{bmatrix}
\cos\theta & -\sin\theta & 0 \
\sin\theta & \cos\theta & 0
\end{bmatrix}

示例代码：图像旋转操作

import java.awt.geom.AffineTransform;

public class RotateDemo {
    public static void main(String[] args) {
        AffineTransform transform = new AffineTransform();
        transform.rotate(Math.toRadians(45)); // 绕原点旋转45度

        printMatrix("Rotation Matrix", transform);
    }

    private static void printMatrix(String title, AffineTransform transform) {
        double[] matrix = new double[6];
        transform.getMatrix(matrix);
        System.out.println(title + ":");
        System.out.println("m00: " + matrix[0] + ", m01: " + matrix[1] + ", m02: " + matrix[2]);
        System.out.println("m10: " + matrix[3] + ", m11: " + matrix[4] + ", m12: " + matrix[5]);
        System.out.println();
    }
}

输出结果（近似）：

Rotation Matrix:
m00: 0.7071067811865476, m01: -0.7071067811865476, m02: 0.0
m10: 0.7071067811865476, m11: 0.7071067811865476, m12: 0.0

4.3.3 倾斜（Shear）

倾斜变换用于实现图像的“剪切”效果，使图像产生斜向拉伸。其矩阵形式如下：

\begin{bmatrix}
1 & shx & 0 \
shy & 1 & 0
\end{bmatrix}

示例代码：图像倾斜操作

import java.awt.geom.AffineTransform;

public class ShearDemo {
    public static void main(String[] args) {
        AffineTransform transform = new AffineTransform();
        transform.shear(0.5, 0.3); // x轴剪切0.5，y轴剪切0.3

        printMatrix("Shear Matrix", transform);
    }

    private static void printMatrix(String title, AffineTransform transform) {
        double[] matrix = new double[6];
        transform.getMatrix(matrix);
        System.out.println(title + ":");
        System.out.println("m00: " + matrix[0] + ", m01: " + matrix[1] + ", m02: " + matrix[2]);
        System.out.println("m10: " + matrix[3] + ", m11: " + matrix[4] + ", m12: " + matrix[5]);
        System.out.println();
    }
}

输出结果：

Shear Matrix:
m00: 1.0, m01: 0.5, m02: 0.0
m10: 0.3, m11: 1.0, m12: 0.0

4.4 AffineTransform的组合与应用

4.4.1 多个变换的叠加顺序

AffineTransform 支持多个变换的叠加，但叠加顺序非常重要。由于矩阵乘法是不可交换的，因此变换的顺序会影响最终结果。

示例代码：变换顺序的影响

import java.awt.geom.AffineTransform;

public class TransformOrderDemo {
    public static void main(String[] args) {
        AffineTransform t1 = new AffineTransform();
        t1.translate(100, 100);
        t1.scale(2.0, 2.0);

        AffineTransform t2 = new AffineTransform();
        t2.scale(2.0, 2.0);
        t2.translate(100, 100);

        printMatrix("Translate then Scale", t1);
        printMatrix("Scale then Translate", t2);
    }

    private static void printMatrix(String title, AffineTransform transform) {
        double[] matrix = new double[6];
        transform.getMatrix(matrix);
        System.out.println(title + ":");
        System.out.println("m00: " + matrix[0] + ", m01: " + matrix[1] + ", m02: " + matrix[2]);
        System.out.println("m10: " + matrix[3] + ", m11: " + matrix[4] + ", m12: " + matrix[5]);
        System.out.println();
    }
}

输出结果（部分）：

Translate then Scale:
m00: 2.0, m01: 0.0, m02: 200.0
m10: 0.0, m11: 2.0, m12: 200.0

Scale then Translate:
m00: 2.0, m01: 0.0, m02: 100.0
m10: 0.0, m11: 2.0, m12: 100.0

可以看到两种顺序的结果不同，说明变换顺序影响最终图像位置。

4.4.2 变换的逆操作与还原

有时需要对变换进行“撤销”操作，可以通过 createInverse() 方法获取逆变换。

示例代码：逆变换操作

import java.awt.geom.AffineTransform;

public class InverseTransformDemo {
    public static void main(String[] args) throws Exception {
        AffineTransform transform = new AffineTransform();
        transform.translate(100, 100);
        transform.scale(2.0, 2.0);

        AffineTransform inverse = transform.createInverse();

        printMatrix("Original Transform", transform);
        printMatrix("Inverse Transform", inverse);
    }

    private static void printMatrix(String title, AffineTransform transform) {
        double[] matrix = new double[6];
        transform.getMatrix(matrix);
        System.out.println(title + ":");
        System.out.println("m00: " + matrix[0] + ", m01: " + matrix[1] + ", m02: " + matrix[2]);
        System.out.println("m10: " + matrix[3] + ", m11: " + matrix[4] + ", m12: " + matrix[5]);
        System.out.println();
    }
}

该代码演示了如何获取并应用逆变换，以还原原始图像的位置和大小。

以上为 第四章：AffineTransform类详解 的完整内容，涵盖了其数学基础、缩放、平移、旋转、剪切等操作的实现方式，以及变换的叠加与逆操作等高级应用。

5. 均匀缩放与非均匀缩放（拉伸）实现方法

5.1 图像缩放的基本流程

图像缩放是图像处理中的基础操作之一，通常通过Java 2D API中的 AffineTransform 和 AffineTransformOp 类实现。基本流程如下：

加载原始图像 ：使用 ImageIO.read() 从文件或流中读取图像。
创建AffineTransform对象 ：根据缩放比例设置仿射变换矩阵。
创建AffineTransformOp对象 ：指定插值方式（如双线性插值）以提升图像质量。
执行变换操作 ：调用 filter() 方法进行图像缩放。
保存或显示结果图像 。

以下是一个图像缩放的基本实现代码示例：

import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;

public class ImageScaler {
    public static void main(String[] args) throws Exception {
        // 1. 读取原始图像
        BufferedImage originalImage = ImageIO.read(new File("input.jpg"));

        // 2. 设置缩放比例
        double scaleX = 0.5;  // 横向缩放为原图的一半
        double scaleY = 0.5;  // 纵向缩放为原图的一半

        // 3. 创建AffineTransform对象并设置缩放
        AffineTransform transform = AffineTransform.getScaleInstance(scaleX, scaleY);

        // 4. 创建AffineTransformOp对象并设置插值方式
        AffineTransformOp op = new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);

        // 5. 执行缩放操作
        BufferedImage scaledImage = op.filter(originalImage, null);

        // 6. 保存结果图像
        ImageIO.write(scaledImage, "jpg", new File("output_scaled.jpg"));
    }
}

代码说明：

scaleX 和 scaleY 分别表示横向和纵向的缩放比例。
AffineTransform.getScaleInstance() 创建一个用于缩放的变换对象。
AffineTransformOp.TYPE_BILINEAR 是一种常用的插值算法，用于提升缩放后的图像质量。
op.filter() 执行实际的图像变换操作。

5.2 均匀缩放的实践技巧

均匀缩放是指图像在X轴和Y轴上以相同的比例进行缩放，从而保持图像的纵横比不变。这种方式可以避免图像变形，适合用于图像预览、缩略图生成等场景。

5.2.1 按比例缩放图像

以下示例演示如何按指定比例进行均匀缩放：

double scale = 0.75; // 均匀缩放比例
AffineTransform transform = AffineTransform.getScaleInstance(scale, scale);

5.2.2 保持图像质量的缩放策略

为了在缩放过程中保持图像的清晰度，可以采取以下策略：

使用高质量插值方式 ：如 AffineTransformOp.TYPE_BICUBIC ，虽然计算量更大，但效果更佳。
先缩小后放大 ：对于多次缩放操作，建议始终基于原始图像进行变换，避免累积失真。
图像抗锯齿处理 ：在使用 Graphics2D 进行绘制时，开启抗锯齿模式。

示例代码片段：

AffineTransformOp op = new AffineTransformOp(transform, AffineTransformOp.TYPE_BICUBIC);

5.3 非均匀缩放（拉伸）的实现

非均匀缩放是指图像在X轴和Y轴上的缩放比例不同，导致图像发生拉伸。这种技术常用于图像变形、动画效果、特定比例适配等场景。

5.3.1 横向与纵向独立缩放

以下示例演示如何实现非均匀缩放：

double scaleX = 1.5; // 横向放大1.5倍
double scaleY = 0.5; // 纵向缩小为原来的一半

AffineTransform transform = AffineTransform.getScaleInstance(scaleX, scaleY);
AffineTransformOp op = new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);
BufferedImage stretchedImage = op.filter(originalImage, null);

5.3.2 拉伸图像的应用场景与注意事项

应用场景：

UI布局中图像的自适应拉伸
视频播放器中的画面变形适配
动画特效中的形状变化

注意事项：

避免过度拉伸造成图像失真
在拉伸前进行图像质量评估
对用户可接受的变形程度进行测试

5.4 GUI中动态控制图像缩放

在图形界面中实现图像缩放功能，可以提升用户体验。通过滑块控件（如 JSlider ）让用户实时调整缩放比例。

5.4.1 使用滑块控件实现缩放比例调整

以下是一个简单的Swing GUI示例，包含滑块控件和图像显示区域：

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;

public class ImageScalerGUI extends JFrame {
    private BufferedImage originalImage;
    private BufferedImage displayImage;
    private JLabel imageLabel;
    private double scale = 1.0;

    public ImageScalerGUI() throws Exception {
        originalImage = ImageIO.read(new File("input.jpg"));

        // 初始化UI
        setTitle("图像缩放示例");
        setSize(800, 600);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new BorderLayout());

        // 添加滑块
        JSlider slider = new JSlider(JSlider.HORIZONTAL, 50, 200, 100);
        slider.setMajorTickSpacing(50);
        slider.setPaintTicks(true);
        slider.setPaintLabels(true);

        // 添加图像显示区域
        imageLabel = new JLabel(new ImageIcon(originalImage));
        add(imageLabel, BorderLayout.CENTER);
        add(slider, BorderLayout.SOUTH);

        // 添加监听器
        slider.addChangeListener(e -> {
            scale = slider.getValue() / 100.0;
            resizeImage();
        });

        setVisible(true);
    }

    private void resizeImage() {
        AffineTransform transform = AffineTransform.getScaleInstance(scale, scale);
        AffineTransformOp op = new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);
        displayImage = op.filter(originalImage, null);
        imageLabel.setIcon(new ImageIcon(displayImage));
    }

    public static void main(String[] args) throws Exception {
        SwingUtilities.invokeLater(ImageScalerGUI::new);
    }
}

5.4.2 实时渲染与图像重绘机制

在GUI中，图像缩放需要根据用户操作动态重绘图像。Java Swing 中的 JLabel.setIcon() 方法会自动触发组件的重绘机制，从而实现图像的实时更新。

5.4.3 用户交互事件的响应与处理

通过 ChangeListener 和 ActionListener 等事件监听器，可以捕获用户对控件的操作，并动态更新图像内容。在图像处理中，建议将图像变换操作放在非UI线程中执行，避免界面卡顿。

5.5 图像处理项目开发注意事项

在实际开发图像处理项目时，除了实现功能，还需要关注性能、资源管理和兼容性等问题。

5.5.1 内存管理与图像缓存优化

避免频繁创建和销毁图像对象 ：应复用已有的 BufferedImage 。
使用图像缓存机制 ：如 SoftReference 缓存缩略图，减少内存占用。
及时释放资源 ：在图像不再使用时，手动释放相关资源。

5.5.2 多线程处理与图像并发操作

Java图像处理涉及大量计算，建议将耗时操作（如缩放、滤镜处理）放在后台线程中执行：

SwingWorker<Void, Void> worker = new SwingWorker<>() {
    @Override
    protected Void doInBackground() {
        // 图像处理逻辑
        return null;
    }

    @Override
    protected void done() {
        // 更新UI
    }
};
worker.execute();

5.5.3 跨平台兼容性与图像格式支持问题

ImageIO支持的格式可能因平台而异 ：建议使用第三方库如TwelveMonkeys扩展支持格式。
图像格式兼容性测试 ：确保目标平台支持所需格式（如PNG、JPEG、GIF）。
异常处理机制 ：针对图像格式不支持、文件损坏等情况提供友好提示。

小贴士：
使用 ImageIO.getReaderFormatNames() 可以查看当前运行环境中支持的图像读取格式列表。

本文还有配套的精品资源，点击获取

开源鸿蒙跨平台开发者社区

开源鸿蒙跨平台开发社区汇聚开发者与厂商，共建“一次开发，多端部署”的开源生态，致力于降低跨端开发门槛，推动万物智联创新。

更多推荐

ReactNative for OpenHarmony项目鸿蒙化三方库：rn-placeholder — 骨架屏占位组件

开源鸿蒙跨平台开发者社区

【Flutter For OpenHarmony第三方库】Flutter 状态管理方案 Riverpod 的鸿蒙化适配实践

第一，状态类的设计要充分考虑不可变性。每次状态更新都应生成新的状态对象，而非在原对象上修改。这种设计虽然增加了些许代码量，但带来的可追溯性与可测试性提升是值得的。当状态变更出现异常时，不可变设计可以轻松通过打印日志定位问题。此外，不可变状态也天然支持撤销/重做功能的实现。第二，Notifier 内部的逻辑要保持精简。将复杂的计算逻辑分散到派生 Provider 中，可以保持 Notifier 的清

开源鸿蒙跨平台开发者社区

ReactNative for OpenHarmony项目鸿蒙化三方库：react-native-vector-icons — 矢量图标组件

开源鸿蒙跨平台开发者社区

所有评论(0)

查看更多评论

微尘-黄含驰

@weixin_36212459

已为社区贡献8条内容

Java图像处理实战：图片缩放与拉伸技术详解

微尘-黄含驰

1. Java图像处理基础

2. BufferedImage对象的创建与使用

2.1 BufferedImage的基本概念

2.1.1 图像数据的存储方式

2.1.2 BufferedImage的图像类型选择

2.2 BufferedImage的创建方法

2.2.1 使用构造函数创建空图像

2.2.2 从现有图像对象复制生成

图像复制流程图

2.3 BufferedImage的像素操作

2.3.1 获取和设置像素值

2.3.2 像素操作的性能优化技巧

方式一：使用 getRGB(int startX, int startY, int w, int h, ...) 批量读取像素

方式二：直接操作Raster和DataBuffer

2.4 图像绘制与图形上下文

2.4.1 Graphics2D对象的获取与使用

2.4.2 在BufferedImage上绘制图形和文本

绘制文本示例：

绘制图像示例：

图形绘制流程图：

3. 使用ImageIO读取和保存图像

3.1 ImageIO类的基本功能

3.1.1 支持的图像格式列表

代码逻辑分析

参数说明

输出结果（示例）

3.1.2 ImageIO的静态方法与插件机制

3.2 图像的读取操作

3.2.1 从本地文件读取图像

代码逻辑分析

参数说明

流程图：图像读取过程

3.2.2 从输入流中加载图像数据

代码逻辑分析

参数说明

3.3 图像的保存操作

3.3.1 指定图像格式进行保存

代码逻辑分析

参数说明

3.3.2 自定义图像写入选项

代码逻辑分析

参数说明

3.4 图像读写异常处理

3.4.1 常见IO异常及应对策略

示例代码：统一异常处理

3.4.2 图像格式不支持的解决方案

4. AffineTransform类详解

4.1 AffineTransform的基本原理

4.1.1 仿射变换的数学基础

4.1.2 Java中AffineTransform的内部矩阵结构

示例代码：获取和设置矩阵参数

代码分析：

输出结果（预期）：

4.2 缩放变换的实现机制

4.2.1 均匀缩放与非均匀缩放的数学表达

示例代码：实现均匀与非均匀缩放

输出结果：

4.2.2 缩放中心的选择与变换顺序

示例代码：设置缩放中心

输出结果：

4.3 其他几何变换操作

4.3.1 平移（Translation）

示例代码：图像平移操作

输出结果：

4.3.2 旋转（Rotation）

示例代码：图像旋转操作

输出结果（近似）：

4.3.3 倾斜（Shear）

示例代码：图像倾斜操作

输出结果：

4.4 AffineTransform的组合与应用

4.4.1 多个变换的叠加顺序

示例代码：变换顺序的影响

输出结果（部分）：

4.4.2 变换的逆操作与还原

示例代码：逆变换操作

5. 均匀缩放与非均匀缩放（拉伸）实现方法

5.1 图像缩放的基本流程

方式一：使用 `getRGB(int startX, int startY, int w, int h, ...)` 批量读取像素