Cambiar el tamaño de una imagen en Java

1. Cambiar el tamaño y mostrar una imagen en Java usando BufferedImage.getScaledInstance()
2. Cambiar el tamaño de la imagen y guardarla en el directorio local en Java usando Graphics2D e ImageIO

Java puede realizar varias operaciones de diferentes tipos como leer, escribir o eliminar un archivo. En los siguientes ejemplos, demostraremos cómo puede cambiar el tamaño de una imagen en Java utilizando tres técnicas.

Cambiar el tamaño y mostrar una imagen en Java usando BufferedImage.getScaledInstance()

En el primer ejemplo, cambiamos el tamaño de una imagen y la mostramos dentro de un marco sin guardarla en ningún lugar. Aquí, creamos un objeto bufferImage de la clase BufferedImage. La clase BufferedImage extiende la clase Image que representa las imágenes gráficas como un array de píxeles rectangulares. Para leer la imagen usamos la función ImageIO.read(). Aquí, ImageIO es una clase que contiene métodos estáticos como read y write para realizar operaciones de entrada y salida.

Obtenemos nuestra imagen usando el método new File() que llama al constructor de la clase File y pasa la ubicación de la imagen como un argumento en ella. Una vez que obtenemos el objeto bufferedImage, lo usamos para llamar al método getScaledInstance() que crea una versión escalada de la imagen.

La función getScaledInstance toma tres argumentos: los dos primeros son el ancho y el alto en píxeles que queremos darle a la imagen, y el último argumento es el algoritmo a usar para escalar. Aquí, usamos la función Image.SCALE_DEFAULT, que le dice a la clase que use el algoritmo de muestreo predeterminado.

Una vez hecho esto, creamos una ventana para mostrar la imagen usando el objeto JFrame. Establecemos el diseño del objeto frame como FlowLayout, que organiza los componentes en una línea. Luego, establecemos el tamaño de la ventana; tenga en cuenta que este tamaño debe ser mayor que el alto y el ancho de la imagen para mostrar la imagen por completo.

Finalmente, para mostrar la imagen, creamos un objeto de JLabel y llamamos a la clase sección que establece la imagen como icono. Por último, agregamos el objeto jLabel al objeto frame y establecemos la visibilidad en verdadero.

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

public class ResizeImageExample {
  public static void main(String[] args) throws IOException {
    new ResizeImageExample();
  }

  public ResizeImageExample() throws IOException {
    BufferedImage bufferedImage = ImageIO.read(new File("C:\\Users\\User1\\Pictures\\java.png"));
    Image image = bufferedImage.getScaledInstance(600, 400, Image.SCALE_DEFAULT);

    ImageIcon icon = new ImageIcon(image);
    JFrame frame = new JFrame();
    frame.setLayout(new FlowLayout());
    frame.setSize(800, 600);

    JLabel jLabel = new JLabel();
    jLabel.setIcon(icon);
    frame.add(jLabel);
    frame.setVisible(true);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}

Producción:

Cambiar el tamaño de la imagen y guardarla en el directorio local en Java usando Graphics2D e ImageIO

En el segundo método, usamos la clase Graphics2D para crear gráficos. El primer paso es obtener el archivo de imagen usando el método ImageIo.read() que toma un objeto File como argumento que contiene la ruta de la imagen. El ImageIo.read() devuelve el objeto BufferedImage, bufferImageInput. Creamos otro objeto BufferedImage para usar al escribir la imagen. Toma tres argumentos: la altura, la anchura y el tipo de imagen.

Ahora llamamos al método createGraphics() usando el objeto bufferdImageOutput que devuelve un objeto Graphics2D, g2d. Luego, creamos la imagen con el método drawImage() que toma seis argumentos. El primero es el objeto BufferedImage, el segundo y el tercero son las coordenadas x e y que se escalan según el tamaño si ambos valores son cero. El cuarto y quinto argumento representan la nueva altura y ancho que queremos darle a la imagen, y el último argumento es el ImageObserver que es null en nuestro caso.

Antes de continuar, desechamos todo el contexto y los recursos usados ​​por g2d usando la función g2d.dispose(). Para guardar la imagen redimensionada en el directorio local, usamos la función ImageIo.write() que toma el objeto bufferedImageOutput, el nombre que se le dará al nuevo archivo de imagen y el constructor File con la ruta del archivo.

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

public class ResizeImageExample {
  public static void main(String[] args) throws IOException {
    resizeFile("C:\\Users\\Rupam Saini\\Pictures\\java.png",
        "C:\\Users\\Rupam Saini\\Pictures\\java-resized.png", 500, 500);
  }

  public static void resizeFile(String imagePathToRead, String imagePathToWrite, int resizeWidth,
      int resizeHeight) throws IOException {
    File fileToRead = new File(imagePathToRead);
    BufferedImage bufferedImageInput = ImageIO.read(fileToRead);

    BufferedImage bufferedImageOutput =
        new BufferedImage(resizeWidth, resizeHeight, bufferedImageInput.getType());

    Graphics2D g2d = bufferedImageOutput.createGraphics();
    g2d.drawImage(bufferedImageInput, 0, 0, resizeWidth, resizeHeight, null);
    g2d.dispose();

    String formatName = imagePathToWrite.substring(imagePathToWrite.lastIndexOf(".") + 1);

    ImageIO.write(bufferedImageOutput, formatName, new File(imagePathToWrite));
  }
}

Imagen antes de cambiar el tamaño:

Imagen después de cambiar el tamaño: