Java操作图片

已于 2024-04-29 13:53:01 修改
阅读量261 收藏
点赞数 2
分类专栏： Java基础 文章标签： java 图片操作
于 2024-04-26 19:50:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39311781/article/details/138228410
版权
该文章介绍了在Java中使用SpringBoot开发的一个图片操作工具类，包括图片格式转换、压缩、裁剪、尺寸调整、灰度处理以及添加文字和图片水印的功能。
摘要由CSDN通过智能技术生成

功能描述

ps: 支持本地生成文件和文件流

  • 图片格式转换
  • 图片压缩
  • 图片裁剪
  • 图片尺寸缩小
  • 图片尺寸放大
  • 图片尺寸重置
  • 图片灰化
  • 添加文字水印
  • 添加图片水印

工具类

package com.qiangesoft.image.utils;

import org.springframework.util.Assert;
import org.springframework.web.multipart.MultipartFile;

import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.stream.ImageOutputStream;
import java.awt.*;
import java.awt.color.ColorSpace;
import java.awt.image.BufferedImage;
import java.awt.image.ColorConvertOp;
import java.io.*;
import java.util.Iterator;

/**
 * 图片操作
 *
 * @author qiangesoft
 * @date 2024-04-26
 */
public class ImageOperateUtil {

    /**
     * 图片格式转换
     *
     * @param sourcePath
     * @param targetPath
     * @throws IOException
     */
    public static void convert(String sourcePath, String targetPath) throws IOException {
        String fileType = targetPath.substring(targetPath.lastIndexOf(".") + 1);
        try (FileInputStream fis = new FileInputStream(sourcePath);
             ImageOutputStream ios = ImageIO.createImageOutputStream(new File(targetPath))) {
            convert(fis, ios, fileType);
        }
    }

    /**
     * 图片格式转换
     *
     * @param file
     * @param outputStream
     * @param fileType
     * @throws IOException
     */
    public static void convert(MultipartFile file, OutputStream outputStream, String fileType) throws IOException {
        try (ImageOutputStream ios = ImageIO.createImageOutputStream(outputStream);
             InputStream inputStream = file.getInputStream()) {
            convert(inputStream, ios, fileType);
        }
    }

    private static void convert(InputStream inputStream, ImageOutputStream outputStream, String fileType) throws IOException {
        // 获取ImageWriter
        Iterator<ImageWriter> writerIterator = ImageIO.getImageWritersByFormatName(fileType);
        Assert.isTrue(writerIterator.hasNext(), "图片文件格式错误");
        ImageWriter writer = writerIterator.next();

        // 写入图片
        writer.setOutput(outputStream);
        BufferedImage image = ImageIO.read(inputStream);
        writer.write(null, new IIOImage(image, null, null), null);
    }

    /**
     * 压缩图片
     *
     * @param sourcePath
     * @param targetPath
     * @param quality
     * @throws IOException
     */
    public static void compress(String sourcePath, String targetPath, float quality) throws IOException {
        String fileType = targetPath.substring(targetPath.lastIndexOf(".") + 1);
        try (FileInputStream fis = new FileInputStream(sourcePath);
             ImageOutputStream ios = ImageIO.createImageOutputStream(new File(targetPath))) {
            compress(fis, ios, fileType, quality);
        }
    }

    /**
     * 压缩图片
     *
     * @param file
     * @param outputStream
     * @param quality
     * @throws IOException
     */
    public static void compress(MultipartFile file, OutputStream outputStream, float quality) throws IOException {
        String originalFilename = file.getOriginalFilename();
        Assert.notNull(originalFilename, "文件非法");
        String fileType = originalFilename.substring(originalFilename.lastIndexOf(".") + 1);
        try (ImageOutputStream ios = ImageIO.createImageOutputStream(outputStream);
             InputStream inputStream = file.getInputStream()) {
            compress(inputStream, ios, fileType, quality);
        }
    }

    private static void compress(InputStream inputStream, ImageOutputStream outputStream, String fileType, float quality) throws IOException {
        // 获取ImageWriter
        Iterator<ImageWriter> writerIterator = ImageIO.getImageWritersByFormatName(fileType);
        Assert.isTrue(writerIterator.hasNext(), "图片文件格式错误");
        ImageWriter writer = writerIterator.next();

        // 设置写入参数
        ImageWriteParam iwp = writer.getDefaultWriteParam();
        iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
        iwp.setCompressionQuality(quality);

        // 写入图片
        writer.setOutput(outputStream);
        BufferedImage image = ImageIO.read(inputStream);
        writer.write(null, new IIOImage(image, null, null), iwp);
    }

    /**
     * 裁剪图片
     *
     * @param sourcePath
     * @param targetPath
     * @param width
     * @param height
     * @throws IOException
     */
    public static void crop(String sourcePath, String targetPath, int width, int height) throws IOException {
        crop(sourcePath, targetPath, 0, 0, width, height);
    }

    public static void crop(String sourcePath, String targetPath, int x, int y, int width, int height) throws IOException {
        String targetType = targetPath.substring(targetPath.lastIndexOf(".") + 1);
        try (FileInputStream fis = new FileInputStream(sourcePath);
             FileOutputStream fos = new FileOutputStream(targetPath)) {
            crop(fis, fos, targetType, x, y, width, height);
        }
    }

    /**
     * 裁剪图片
     *
     * @param file
     * @param outputStream
     * @param width
     * @param height
     * @throws IOException
     */
    public static void crop(MultipartFile file, OutputStream outputStream, int width, int height) throws IOException {
        crop(file, outputStream, 0, 0, width, height);
    }

    public static void crop(MultipartFile file, OutputStream outputStream, int x, int y, int width, int height) throws IOException {
        String originalFilename = file.getOriginalFilename();
        Assert.notNull(originalFilename, "文件非法");
        String sourceType = originalFilename.substring(originalFilename.lastIndexOf(".") + 1);
        try (InputStream inputStream = file.getInputStream()) {
            crop(inputStream, outputStream, sourceType, x, y, width, height);
        }
    }

    private static void crop(InputStream inputStream, OutputStream outputStream, String targetType, int x, int y, int width, int height) throws IOException {
        // 读取图片
        BufferedImage image = ImageIO.read(inputStream);
        int maxWidth = image.getWidth();
        Assert.isTrue(maxWidth > x + width, "图片宽度不足");
        int maxHeight = image.getHeight();
        Assert.isTrue(maxHeight > y + height, "图片高度不足");

        // 裁剪图片
        BufferedImage destImage = image.getSubimage(x, y, width, height);

        // 保存新图片
        ImageIO.write(destImage, targetType, outputStream);
    }

    /**
     * 按倍率缩小图片
     *
     * @param sourcePath
     * @param targetPath
     * @param ratio
     * @throws IOException
     */
    public static void reduceByRatio(String sourcePath, String targetPath, int ratio) throws IOException {
        String fileType = targetPath.substring(targetPath.lastIndexOf(".") + 1);
        try (FileInputStream inputStream = new FileInputStream(sourcePath);
             FileOutputStream outputStream = new FileOutputStream(targetPath)) {
            reduceByRatio(inputStream, outputStream, ratio, fileType);
        }
    }

    /**
     * 按倍率缩小图片
     *
     * @param file
     * @param outputStream
     * @param ratio
     * @throws IOException
     */
    public static void reduceByRatio(MultipartFile file, OutputStream outputStream, int ratio) throws IOException {
        String originalFilename = file.getOriginalFilename();
        Assert.notNull(originalFilename, "文件非法");
        String fileType = originalFilename.substring(originalFilename.lastIndexOf(".") + 1);
        try (InputStream inputStream = file.getInputStream()) {
            reduceByRatio(inputStream, outputStream, ratio, fileType);
        }
    }

    private static void reduceByRatio(InputStream inputStream, OutputStream outputStream, int ratio, String sourceType) throws IOException {
        // 构造Image对象
        BufferedImage sourceImage = ImageIO.read(inputStream);
        int width = sourceImage.getWidth() / ratio;
        int height = sourceImage.getHeight() / ratio;

        resize(sourceImage, outputStream, width, height, sourceType);
    }

    /**
     * 按倍率放大图片
     *
     * @param sourcePath
     * @param targetPath
     * @param ratio
     * @throws IOException
     */
    public static void enlargeByRatio(String sourcePath, String targetPath, int ratio) throws IOException {
        String fileType = targetPath.substring(targetPath.lastIndexOf(".") + 1);
        try (FileInputStream inputStream = new FileInputStream(sourcePath);
             FileOutputStream outputStream = new FileOutputStream(targetPath)) {
            enlargeByRatio(inputStream, outputStream, ratio, fileType);
        }
    }

    /**
     * 按倍率放大图片
     *
     * @param file
     * @param outputStream
     * @param ratio
     * @throws IOException
     */
    public static void enlargeByRatio(MultipartFile file, OutputStream outputStream, int ratio) throws IOException {
        String originalFilename = file.getOriginalFilename();
        Assert.notNull(originalFilename, "文件非法");
        String fileType = originalFilename.substring(originalFilename.lastIndexOf(".") + 1);
        try (InputStream inputStream = file.getInputStream()) {
            enlargeByRatio(inputStream, outputStream, ratio, fileType);
        }
    }

    private static void enlargeByRatio(InputStream inputStream, OutputStream outputStream, int ratio, String fileType) throws IOException {
        // 构造Image对象
        BufferedImage sourceImage = ImageIO.read(inputStream);
        int width = sourceImage.getWidth() * ratio;
        int height = sourceImage.getHeight() * ratio;

        resize(sourceImage, outputStream, width, height, fileType);
    }

    /**
     * 按倍率放大图片
     *
     * @param sourcePath
     * @param targetPath
     * @param width
     * @param height
     * @throws IOException
     */
    public static void resize(String sourcePath, String targetPath, int width, int height) throws IOException {
        String fileType = targetPath.substring(targetPath.lastIndexOf(".") + 1);
        try (FileInputStream inputStream = new FileInputStream(sourcePath);
             FileOutputStream outputStream = new FileOutputStream(targetPath)) {
            // 构造Image对象
            BufferedImage sourceImage = ImageIO.read(inputStream);
            resize(sourceImage, outputStream, width, height, fileType);
        }
    }

    /**
     * 按倍率放大图片
     *
     * @param file
     * @param outputStream
     * @param width
     * @param height
     * @throws IOException
     */
    public static void resize(MultipartFile file, OutputStream outputStream, int width, int height) throws IOException {
        String originalFilename = file.getOriginalFilename();
        Assert.notNull(originalFilename, "文件非法");
        String fileType = originalFilename.substring(originalFilename.lastIndexOf(".") + 1);
        try (InputStream inputStream = file.getInputStream()) {
            // 构造Image对象
            BufferedImage sourceImage = ImageIO.read(inputStream);
            resize(sourceImage, outputStream, width, height, fileType);
        }
    }

    private static void resize(BufferedImage sourceImage, OutputStream outputStream, int width, int height, String fileType) throws IOException {
        // 创建图片
        BufferedImage targetImage = new BufferedImage(width, height, sourceImage.getType());
        Graphics2D g2d = targetImage.createGraphics();

        // 设置宽高
        g2d.drawImage(sourceImage, 0, 0, width, height, null);
        g2d.dispose();

        // 保存新图片
        ImageIO.write(targetImage, fileType, outputStream);
    }

    /**
     * 图片灰化
     *
     * @param sourcePath
     * @param targetPath
     * @throws IOException
     */
    public static void gray(String sourcePath, String targetPath) throws IOException {
        String fileType = targetPath.substring(targetPath.lastIndexOf(".") + 1);
        try (FileInputStream inputStream = new FileInputStream(sourcePath);
             FileOutputStream outputStream = new FileOutputStream(targetPath)) {
            gray(inputStream, outputStream, fileType);
        }
    }

    /**
     * 图片灰化
     *
     * @param file
     * @param outputStream
     * @throws IOException
     */
    public static void gray(MultipartFile file, OutputStream outputStream) throws IOException {
        String originalFilename = file.getOriginalFilename();
        Assert.notNull(originalFilename, "文件非法");
        String fileType = originalFilename.substring(originalFilename.lastIndexOf(".") + 1);
        try (InputStream inputStream = file.getInputStream()) {
            gray(inputStream, outputStream, fileType);
        }
    }

    private static void gray(InputStream inputStream, OutputStream outputStream, String fileType) throws IOException {
        // 读取图片
        BufferedImage bufferedImage = ImageIO.read(inputStream);

        // 灰化
        ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_GRAY);
        ColorConvertOp op = new ColorConvertOp(cs, null);
        BufferedImage newBufferedImage = op.filter(bufferedImage, null);

        // 保存新图片
        ImageIO.write(newBufferedImage, fileType, outputStream);
    }

    /**
     * 图片添加文字水印
     *
     * @param sourcePath
     * @param targetPath
     * @param font
     * @param color
     * @param x
     * @param y
     * @param watermarkText
     * @throws IOException
     */
    public static void watermarkText(String sourcePath, String targetPath, Font font, Color color, int x, int y, String watermarkText) throws IOException {
        String fileType = targetPath.substring(targetPath.lastIndexOf(".") + 1);
        try (FileInputStream inputStream = new FileInputStream(sourcePath);
             FileOutputStream outputStream = new FileOutputStream(targetPath)) {
            watermarkText(inputStream, outputStream, font, color, x, y, watermarkText, fileType);
        }
    }

    /**
     * 图片添加文字水印
     *
     * @param file
     * @param outputStream
     * @param font
     * @param color
     * @param x
     * @param y
     * @param watermarkText
     * @throws IOException
     */
    public static void watermarkText(MultipartFile file, OutputStream outputStream, Font font, Color color, int x, int y, String watermarkText) throws IOException {
        String originalFilename = file.getOriginalFilename();
        Assert.notNull(originalFilename, "文件非法");
        String fileType = originalFilename.substring(originalFilename.lastIndexOf(".") + 1);
        try (InputStream inputStream = file.getInputStream()) {
            watermarkText(inputStream, outputStream, font, color, x, y, watermarkText, fileType);
        }
    }

    private static void watermarkText(InputStream inputStream, OutputStream outputStream, Font font, Color color, int x, int y, String watermarkText, String fileType) throws IOException {
        // 读取图片
        BufferedImage image = ImageIO.read(inputStream);
        Graphics2D g2d = image.createGraphics();

        // 设置文字字体、样式
        g2d.setFont(font);
        g2d.setColor(color);
        g2d.drawString(watermarkText, x, y);
        g2d.dispose();

        // 保存新图片
        ImageIO.write(image, fileType, outputStream);
    }

    /**
     * 图片添加图片水印
     *
     * @param sourcePath
     * @param appendSourcePath
     * @param targetPath
     * @param x
     * @param y
     * @param width
     * @param height
     * @throws IOException
     */
    public static void watermarkImage(String sourcePath, String appendSourcePath, String targetPath, int x, int y, int width, int height) throws IOException {
        String fileType = targetPath.substring(targetPath.lastIndexOf(".") + 1);
        try (FileInputStream inputStream = new FileInputStream(sourcePath);
             FileInputStream appendInputStream = new FileInputStream(appendSourcePath);
             FileOutputStream outputStream = new FileOutputStream(targetPath)) {
            watermarkImage(inputStream, appendInputStream, outputStream, x, y, width, height, fileType);
        }
    }

    /**
     * 图片添加图片水印
     *
     * @param file
     * @param appendFile
     * @param outputStream
     * @param x
     * @param y
     * @param width
     * @param height
     * @throws IOException
     */
    public static void watermarkImage(MultipartFile file, MultipartFile appendFile, OutputStream outputStream, int x, int y, int width, int height) throws IOException {
        String originalFilename = file.getOriginalFilename();
        Assert.notNull(originalFilename, "文件非法");
        String fileType = originalFilename.substring(originalFilename.lastIndexOf(".") + 1);
        try (InputStream inputStream = file.getInputStream();
             InputStream appendInputStream = appendFile.getInputStream()) {
            watermarkImage(inputStream, appendInputStream, outputStream, x, y, width, height, fileType);
        }
    }

    private static void watermarkImage(InputStream inputStream, InputStream appendInputStream, OutputStream outputStream, int x, int y, int width, int height, String fileType) throws IOException {
        // 读取图片
        BufferedImage image = ImageIO.read(inputStream);
        Graphics2D g2d = image.createGraphics();

        // 设置水印图片的起始x/y坐标、宽度、高度
        BufferedImage appendImage = ImageIO.read(appendInputStream);
        g2d.drawImage(appendImage, x, y, width, height, null, null);
        g2d.dispose();

        // 保存新图片
        ImageIO.write(image, fileType, outputStream);
    }

    public static void main(String[] args) throws Exception {
        ImageOperateUtil.convert("C:/Users/16/Desktop/image/mianju.jpg", "C:/Users/16/Desktop/image/mianju0.png");
        ImageOperateUtil.compress("C:/Users/16/Desktop/image/mianju.jpg", "C:/Users/16/Desktop/image/mianju1.jpg", 0.3f);
        ImageOperateUtil.crop("C:/Users/16/Desktop/image/mianju.jpg", "C:/Users/16/Desktop/image/mianju2.jpg", 3000, 2000);
        ImageOperateUtil.crop("C:/Users/16/Desktop/image/mianju.jpg", "C:/Users/16/Desktop/image/mianju3.jpg", 500, 500, 3000, 2000);
        ImageOperateUtil.reduceByRatio("C:/Users/16/Desktop/image/mianju.jpg", "C:/Users/16/Desktop/image/mianju4.jpg", 2);
        ImageOperateUtil.enlargeByRatio("C:/Users/16/Desktop/image/mianju.jpg", "C:/Users/16/Desktop/image/mianju5.jpg", 2);
        ImageOperateUtil.resize("C:/Users/16/Desktop/image/mianju.jpg", "C:/Users/16/Desktop/image/mianju6.jpg", 3000, 2000);
        ImageOperateUtil.gray("C:/Users/16/Desktop/image/mianju.jpg", "C:/Users/16/Desktop/image/mianju7.jpg");
        ImageOperateUtil.watermarkText("C:/Users/16/Desktop/image/mianju.jpg", "C:/Users/16/Desktop/image/mianju8.jpg",
                new Font("宋体", Font.BOLD, 150), new Color(255, 255, 255, 255), 300, 500, "哈哈哈哈");
        ImageOperateUtil.watermarkImage("C:/Users/16/Desktop/image/mianju.jpg", "C:/Users/16/Desktop/image/demo.jpeg",
                "C:/Users/16/Desktop/image/mianju9.jpg", 0, 0, 500, 500);
    }

}

接口调用

package com.qiangesoft.image.controller;

import com.qiangesoft.image.utils.ImageOperateUtil;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestPart;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.awt.*;
import java.io.IOException;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

/**
 * 测试
 *
 * @author qiangesoft
 * @date 2024-04-26
 */
@RequestMapping("/image")
@RestController
public class ImageController {

    @GetMapping("/convert")
    public void convert(@RequestPart MultipartFile file, HttpServletResponse response) throws IOException {
        settingResponse(response, "图片格式转换.png");
        try (ServletOutputStream outputStream = response.getOutputStream()) {
            ImageOperateUtil.convert(file, outputStream, "png");
        }
    }

    @GetMapping("/compress")
    public void compress(@RequestPart MultipartFile file, HttpServletResponse response) throws IOException {
        settingResponse(response, "图片压缩.png");
        try (ServletOutputStream outputStream = response.getOutputStream()) {
            ImageOperateUtil.compress(file, outputStream, 0.4f);
        }
    }

    @GetMapping("/crop")
    public void crop(@RequestPart MultipartFile file, HttpServletResponse response) throws IOException {
        settingResponse(response, "图片裁剪.png");
        try (ServletOutputStream outputStream = response.getOutputStream()) {
            ImageOperateUtil.crop(file, outputStream, 500, 400);
        }
    }

    @GetMapping("/reduceByRatio")
    public void reduceByRatio(@RequestPart MultipartFile file, HttpServletResponse response) throws IOException {
        settingResponse(response, "图片比例缩小.png");
        try (ServletOutputStream outputStream = response.getOutputStream()) {
            ImageOperateUtil.reduceByRatio(file, outputStream, 3);
        }
    }

    @GetMapping("/enlargeByRatio")
    public void enlargeByRatio(@RequestPart MultipartFile file, HttpServletResponse response) throws IOException {
        settingResponse(response, "图片比例放大.png");
        try (ServletOutputStream outputStream = response.getOutputStream()) {
            ImageOperateUtil.enlargeByRatio(file, outputStream, 2);
        }
    }

    @GetMapping("/resize")
    public void resize(@RequestPart MultipartFile file, HttpServletResponse response) throws IOException {
        settingResponse(response, "图片宽高重置.png");
        try (ServletOutputStream outputStream = response.getOutputStream()) {
            ImageOperateUtil.resize(file, outputStream, 1000, 500);
        }
    }

    @GetMapping("/gray")
    public void gray(@RequestPart MultipartFile file, HttpServletResponse response) throws IOException {
        settingResponse(response, "图片灰化.png");
        try (ServletOutputStream outputStream = response.getOutputStream()) {
            ImageOperateUtil.gray(file, outputStream);
        }
    }

    @GetMapping("/watermarkText")
    public void watermarkText(@RequestPart MultipartFile file, HttpServletResponse response) throws IOException {
        settingResponse(response, "图片文字水印.png");
        try (ServletOutputStream outputStream = response.getOutputStream()) {
            ImageOperateUtil.watermarkText(file, outputStream, new Font("宋体", Font.BOLD, 150),
                    new Color(255, 255, 255, 255), 300, 500, "哈哈哈哈");
        }
    }

    @GetMapping("/watermarkImage")
    public void watermarkImage(@RequestPart MultipartFile file, @RequestPart MultipartFile appendFile, HttpServletResponse response) throws IOException {
        settingResponse(response, "图片图片水印.png");
        try (ServletOutputStream outputStream = response.getOutputStream()) {
            ImageOperateUtil.watermarkImage(file, appendFile, outputStream, 0, 0, 300, 500);
        }
    }

    private static void settingResponse(HttpServletResponse response, String fileName) {
        response.setCharacterEncoding("utf-8");
        response.setContentType("application/octet-stream");
        response.setHeader("Content-Disposition", "attachment; filename=" + URLEncoder.encode(fileName, StandardCharsets.UTF_8));
    }

}

在这里插入图片描述

PG_强哥
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
Java图片操作 --- 图片的读取、绘制、缩放、裁剪、保存
谢TS的博客
11-05 6万+
本文链接: http://blog.csdn.net/xietansheng/article/details/78453570 1. 读取图片 方法一: 通过 java.awt.Toolkit 工具类来读取本地、网络 或 内存中 的 图片（支持 GIF、JPEG 或 PNG） Image image = Toolkit.getDefaultToolkit().getImage(Str...
java制作海报工具类，java操作图片贴图，java给图片添加文字，调整字体颜色大小间距
芯蕊的阳光
07-30 1901
工具类 java操作图片，给一个大图片贴小图片，给图片添加文字并调整文字颜色，大小，字体间距，把本地图片或者网络图片加载到缓冲区 主要方法： imageIoRead方法，把图片加载到缓冲区 mergeImage方法，给一张图片贴 图片，并生成新图片 drawTextInImg给图片上写多行文字文字，自动居中，并可以调整字体间距。 package com.img; import java.awt.Color; import java.awt.Font; import java.awt.FontMetri
java图片操作
01-31
java 图片压缩 图片切割
JAVA操作图片
project_shuai的博客
08-05 543
最近做了段时间图片裁剪相关的需求，用到了对图片的处理相关功能，在此总结下 BufferedImage 图片缓存方法 getSubimage（x,y,w,h）根据条件截取图片,x,y是左上角开始的坐标，w,h分别为x,y衍生的像素大小，可以当作图片的宽高 ImageIO 图片Io 方法 write（BufferedImage，“”，file）写入图片文件，讲缓存流转为文件。...
Java对于图片的操作
周世文的博客
06-08 1272
最近工作上用到图片旋转，所以来偏图片旋转的文章。其中碰到不少坑。以下实现了旋转90度的倍数。方便我们了解旋转是怎么做的 ，如果要旋转任意角度，可以用Java自带的thumbnails（文章后面介绍）import org.springframework.util.Base64Utils; import net.coobird.thumbnailator.Thumbnails; /**
java 图片操作_Java对图片的操作
weixin_32589387的博客
02-16 907
有一天我在做一个游戏的时候听说可以把图片翻转过来可以减少自己做图片的时间 所以我就在网上找了一下 发现很多文章写得特别复杂 并且有一些方法都不能在eclipse上面用，所以我就模仿网上的文章写出适合自己的方法；对图片的操作总体来就是：1。新建一个BufferedImage，Graphics2D2.然后用BufferedImage类中的一个createGraphics方法 来返回一个Graphi...
java操作图片的工具类
08-18
java操作图片的工具类，包括图片放大缩小、图片裁剪、打水印（文字水印和图片水印）
java 操作图片，往图片写字，将多图片合并
09-30
根据给定文件的信息，本文将围绕Java操作图片的方法展开，主要涵盖往图片上添加文字以及合并多张图片的功能。这些技术在制作许可证书、安全证书等应用场景中非常实用。 ### Java操作图片概述 #### 一、加载图片 在...
java对图片进行操作.rar_java 图片剪裁_java图片_图片
09-24
本资源“java对图片进行操作.rar”提供了一种用Java进行图像操作的工具类，特别关注于图片的剪裁、重置大小以及按比例缩小等功能。以下是关于这些功能的详细解释和实现方法。 首先，图片剪裁是调整图像大小并提取其...
java实现图片角度旋转并获得图片信息
08-26
在Java中，我们可以使用Java的图像处理库对图片进行旋转操作。具体来说，我们可以使用BufferedImage类来表示图片，然后使用Graphics2D类来进行旋转操作。 在上面的代码中，我们可以看到 rotate 方法，它接受两个...
java实现对图片的各种操作
08-15
java实现对图片裁剪，并把裁剪新图片保存，按倍率缩小、放大图片，重置图形的边长大小，拼接图片等等操作 使用Java进行图像处理的一些基础操作，java实现对图片的各种操作下载
java对图片进行处理
08-15
java对图片进行处理如：获取宽高、缩图、剪图、加文字水印、加图片水印
java中关于图片的操作
cl13_14_520的博客
08-13 424
java中操作图片直接上代码 直接上代码 //写入图片文件 imagein = new FileInputStream(backgroundPath); //将图片写入缓存流中 BufferedImage image = ImageIO.read(imagein); //使用Graphics类进行绘图 Graphics g = image.getGraphics(); //设置字体(Font (字体,字体类型(加粗,斜体等),字体大小(int)注意,字体大小和图片大小的分辨率不是同一单位) g.s
Java操作图片大全
最新发布
7me
11-02 1万+
本文主要使用Java对图片各种操作进行处理。
Java处理图片
代码改变世界
04-27 480
使用一个模板图片，在图片上添加图片或者文字都可以。 依赖 <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.18</version> <optional>true</optional> </dependency> 封
JAVA处理图片
hbwdasd的博客
04-07 4402
一、我们需要获取图片 public int[][] getImagePixArray(String path){ File file = new File (path); java.awt.image.BufferedImage buffimg = null; try { buffimg = ImageIO.read (file); } catch (IOException e) {
java中图片简单操作
bornonew的博客
07-29 1647
最近做网站时，经常会对图片进行操作，用到的基本操作如下： 1.读取图片到 二进制数组中 ByteArrayOutputStream out = null ; BufferedInputStream in = null; File file = new File(relativePath); in = new BufferedI
带logo的二维码生成
zk_1325572803的博客
09-07 575
依赖：core.jar 1、二维码工具类import java.awt.Graphics2D; import java.awt.geom.AffineTransform; import java.awt.image.BufferedImage;import com.google.zxing.LuminanceSource;public final class BufferedImageLumina
JAVA操作图片笔记
飞雨飞羽飞鱼
08-13 4085
将两张图片合并： InputStream imagein = new FileInputStream(bgPicName); InputStream imagein2 = new FileInputStream(signName); BufferedImage image = ImageIO.read(imagein); BufferedImage image2 =
Java实现图片叠加与拼接操作详解
"本文主要探讨了在Java中如何进行图片的叠加与拼接操作，提供了相关的示例代码，适用于学习和工作中对图像处理有需求的读者。内容包括使用BufferedImage类进行图片处理的基本原理和实践方法，以及读取图片文件为...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

PG_强哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值