¿Cómo aplicar diferentes estilos a una celda en una hoja de cálculo usando Java?

Posted on by Rudeus Greyrat

Apache POI es una potente API que permite al usuario crear, manipular y mostrar varios formatos de archivo basados ​​en Microsoft Office mediante programas Java. Usando POI, uno debería poder realizar operaciones de creación, modificación y visualización/lectura en los siguientes formatos de archivo. Por ejemplo, Java no proporciona soporte integrado para trabajar con archivos de Excel, por lo que debemos buscar API de código abierto para el trabajo. Es una biblioteca de código abierto desarrollada y distribuida por Apache Software Foundation para diseñar o modificar archivos de Microsoft Office utilizando el programa Java. Contiene clases y métodos para decodificar los datos de entrada del usuario o un archivo en documentos de MS Office. Aquí se pueden aplicar diferentes estilos como fuentes, colores, combinación de celdas, alineaciones, etc. a una celda en Excel usando este concepto en el programa Java.

Arquitectura Apache POI: consta de varios componentes que hacen una arquitectura para formar un sistema de trabajo:

  • POIFS (Sistema de archivo de implementación de ofuscación deficiente): este componente es el factor básico de todos los demás elementos de POI. Se utiliza para leer diferentes archivos de forma explícita.
  • HSSF (formato de hoja de cálculo horrible): se utiliza para leer y escribir archivos en formato xls de MS-Excel.
  • XSSF (formato de hoja de cálculo XML): se utiliza para el formato de archivo xlsx de MS-Excel.
  • HPSF (Horrible Property Set Format): se utiliza para extraer conjuntos de propiedades de los archivos de MS-Office.
  • HWPF (Horrible Word Processor Format): se utiliza para leer y escribir archivos de extensión doc de MS-Word.
  • XWPF (Formato de procesador de textos XML): se utiliza para leer y escribir archivos de extensión Docx de MS-Word.
  • HSLF (Horrible Slide Layout Format): se utiliza para leer, crear y editar presentaciones de PowerPoint.
  • HDGF (Horrible Diagram Format): Contiene clases y métodos para archivos binarios de MS-Visio.
  • HPBF (Horrible Publisher Format): se utiliza para leer y escribir archivos de MS-Publisher.

Un archivo Jar es un archivo Zip que contiene uno o varios archivos de clase Java. Esto hace que el uso de las bibliotecas sea más práctico. Los directorios y los archivos Jar se agregan a la ruta de compilación y están disponibles para ClassLoader en tiempo de ejecución para encontrar clases particulares dentro de él. Generalmente usamos archivos .jar para distribuir aplicaciones o bibliotecas Java, en forma de archivos de clase Java y metadatos y recursos asociados (texto, imágenes, etc.).

 Se puede decir JAR = JavaARchive

Acercarse:

  • Paso 1: Importe los archivos .jar necesarios como HSSF, XML y agréguelos a su ruta de compilación.
  • Paso 2: Crea un libro de trabajo usando “nuevo XSSFWorkbook()” en el que tenemos que crear la hoja de cálculo o el archivo de Excel usando “workbook.createSheet(‘Sheet1’)” en el que vamos a aplicar diferentes estilos.

  • Paso 3: aplique los estilos, aquí combine las celdas usando el comando spreadsheet.addMergedRegion. Tenemos que proporcionar las direcciones de rango de filas y columnas, así como su parámetro.
  • Paso 4 : ahora el siguiente estilo para determinar la alineación de la celda. Para esto, tenemos dos comandos.
    • “style1.setAlignment(XSSFCellStyle.ALIGN_LEFT)” para determinar la alineación y
    • “style1.setVerticalAlignment(XSSFCellStyle.VERTICAL_TOP)” para determinar la alineación vertical
  • Paso 5: para aplicar un borde a una celda, podemos usar «setBorderBottom/Left/Top/Right(XSSFCleeName.BorderName)».
  • Paso 6: cambie el nombre del borde en el parámetro para pasar por diferentes estilos de borde.
  • Paso 7: Para rellenar colores y agregar patrones, primero configure el color de fondo de la celda usando «setFillBackgroundColor (HSSFColor.COLOR_NAME.index)».
  • Paso 8: luego configure el patrón que desee con «setFillPattern (XSSFCellStyle.PATTERN_NAME)».
  • Paso 9: Finalmente, configure la alineación usando ”setAlignment(XSSFCellStyle.ALIGN_TYPE);

Implementación: Realización de los pasos de procedimiento anteriores sobre el archivo de Excel vacío en el directorio local ya creado.

  1. Cree una hoja de cálculo creando un objeto de XSSFSheet
  2. Creando una fila en la XSSFSheet anterior usando el método createRow() .
    • Más tarde, establecer la altura de una fila
  3. Crear un objeto de tipo XSSFCell y encasillarlo encima de la fila creada para él.
  4. Configuración de valores de celda.
  5. Fusionando las celdas.
  6. Alineación de las celdas.
  7. Justificar la alineación.
  8. Bordeando las celdas.
  9. Colores de relleno en las celdas.
  10. Crear un nuevo archivo en el directorio local creando el objeto de FileOutputStream.
  11. Escriba en el libro de trabajo anterior creado en el paso inicial.
  12. Cierra la conexión del archivo.

Ejemplo:

Java

// Java Program to apply different styles
// to a cell in a spreadsheet
 
// Importing java input/output classes
import java.io.File;
import java.io.FileOutputStream;
// Importing Apache POI modules
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
 
// Class- for styling cells
public class GFG {
 
    // Main driver method
    public static void main(String[] args) throws Exception
    {
 
        // Create a Work Book
        XSSFWorkbook workbook = new XSSFWorkbook();
 
        // Step 1: Create a Spread Sheet by
        // creating an object of XSSFSheet
        XSSFSheet spreadsheet
            = workbook.createSheet("Sheet1");
 
        // Step 2(a): Creating a row in above XSSFSheet
        // using createRow() method
        XSSFRow row = spreadsheet.createRow((short)1);
 
        // Step 2(b): Setting height of a row
        row.setHeight((short)800);
 
        // Step 3: Creating an object of type XSSFCell and
        // typecasting above row created to it
        XSSFCell cell = (XSSFCell)row.createCell((short)1);
 
        // Step 4: Setting cell values
        cell.setCellValue("Merged cells");
 
        // Step 5: MERGING CELLS
        // This statement for merging cells
 
        spreadsheet.addMergedRegion(new CellRangeAddress(
            1, // first row (0-based)
            1, // last row (0-based)
            1, // first column (0-based)
            4 // last column (0-based)
            ));
 
        // Step 6: CELL Alignment
        row = spreadsheet.createRow(5);
 
        cell = (XSSFCell)row.createCell(0);
        row.setHeight((short)800);
 
        // 6(a) Top Left alignment
        XSSFCellStyle style1 = workbook.createCellStyle();
 
        spreadsheet.setColumnWidth(0, 8000);
        style1.setAlignment(XSSFCellStyle.ALIGN_LEFT);
        style1.setVerticalAlignment(
            XSSFCellStyle.VERTICAL_TOP);
 
        cell.setCellValue("Hi, I'm top left indent");
        cell.setCellStyle(style1);
        row = spreadsheet.createRow(6);
        cell = (XSSFCell)row.createCell(1);
        row.setHeight((short)800);
 
        // 6(b) Center Align Cell Contents
        XSSFCellStyle style2 = workbook.createCellStyle();
 
        style2.setAlignment(XSSFCellStyle.ALIGN_CENTER);
        style2.setVerticalAlignment(
            XSSFCellStyle.VERTICAL_CENTER);
        cell.setCellValue("I'm Center Aligned indent");
        cell.setCellStyle(style2);
        row = spreadsheet.createRow(7);
        cell = (XSSFCell)row.createCell(2);
        row.setHeight((short)800);
 
        // 6(c) Bottom Right alignment
        XSSFCellStyle style3 = workbook.createCellStyle();
 
        style3.setAlignment(XSSFCellStyle.ALIGN_RIGHT);
        style3.setVerticalAlignment(
            XSSFCellStyle.VERTICAL_BOTTOM);
        cell.setCellValue("I'm Bottom Right indent");
        cell.setCellStyle(style3);
        row = spreadsheet.createRow(8);
        cell = (XSSFCell)row.createCell(3);
 
        // Step 7: Justifying Alignment
        XSSFCellStyle style4 = workbook.createCellStyle();
 
        style4.setAlignment(XSSFCellStyle.ALIGN_JUSTIFY);
        style4.setVerticalAlignment(
            XSSFCellStyle.VERTICAL_JUSTIFY);
        cell.setCellValue(
            "I'm Justify indent nice to meet you");
        cell.setCellStyle(style4);
 
        // Step 8: CELL BORDER
        row = spreadsheet.createRow((short)10);
 
        row.setHeight((short)800);
        cell = (XSSFCell)row.createCell((short)1);
        cell.setCellValue("BORDER");
        XSSFCellStyle style5 = workbook.createCellStyle();
 
        style5.setBorderBottom(XSSFCellStyle.BORDER_THICK);
        style5.setBottomBorderColor(
            IndexedColors.BLUE.getIndex());
        style5.setBorderLeft(XSSFCellStyle.BORDER_DOUBLE);
        style5.setLeftBorderColor(
            IndexedColors.GREEN.getIndex());
        style5.setBorderRight(XSSFCellStyle.BORDER_HAIR);
        style5.setRightBorderColor(
            IndexedColors.RED.getIndex());
        style5.setBorderTop(XSSFCellStyle.BIG_SPOTS);
        style5.setTopBorderColor(
            IndexedColors.Black.getIndex());
        cell.setCellStyle(style5);
 
        // Step 9: Fill Colors
 
        // 9(a) Background color
        row = spreadsheet.createRow((short)10);
 
        cell = (XSSFCell)row.createCell((short)1);
        XSSFCellStyle style6 = workbook.createCellStyle();
 
        style6.setFillBackgroundColor(HSSFColor.BLUE.index);
        style6.setFillPattern(
            XSSFCellStyle.FILL_HORIZONTAL_CROSS_HATCH);
        style6.setAlignment(XSSFCellStyle.ALIGN_FILL);
 
        spreadsheet.setColumnWidth(1, 8000);
        cell.setCellValue("FILL HORIZONTAL CROSS HATCH");
        cell.setCellStyle(style6);
 
        // 9(b) Foreground color
        row = spreadsheet.createRow((short)12);
 
        cell = (XSSFCell)row.createCell((short)1);
        XSSFCellStyle style7 = workbook.createCellStyle();
        style7.setFillForegroundColor(
            HSSFColor.GREEN.index);
        style7.setFillPattern(
            XSSFCellStyle.THIN_VERTICAL_STRIPE);
        style7.setAlignment(XSSFCellStyle.ALIGN_FILL);
 
        cell.setCellValue("THIN VERTICAL STRIPE");
        cell.setCellStyle(style7);
 
        // Step 10: Creating a new file in the local
        // directory by creating object of FileOutputStream
        FileOutputStream out = new FileOutputStream(
            new File("C:/poiexcel/stlingcells.xlsx"));
 
        // Step 11: Write to above workbook created in
        // initial step
        workbook.write(out);
 
        // Step 12: Close the file connection
        out.close();
 
        // Display message for console window when
        // program is successfully executed
        System.out.println("gfg.xlsx success");
    }
}

Producción

Publicación traducida automáticamente

Artículo escrito por mayanktyagi1709 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *