Si es un desarrollador de aplicaciones Java que trabaja con Excel desde sus aplicaciones Java, estaría interesado en proporcionar la funcionalidad de manipular los datos de Excel en su aplicación. Excel le permite formatear el estilo de la celda, establecer el tipo de celda en diferentes tipos de datos, llenar una celda con diferentes colores, etc. Apache POI sirve como su puente entre Java y Excel, ofreciendo herramientas para manipular Excel archivos XLSX programáticamente. En esta serie de blogs, presentaremos el arte de la manipulación de Cell Cell utilizando Apache POI en Java. ¡Buciemos y descubramos la sinergia de código y hojas de cálculo!

Tabla de contenido

A lo largo del blog, revisaremos muestras de código y una explicación de las mismas para lo siguiente:

  1. Creación de células en el archivo de Excel
  2. Crear celdas de fecha en Excel
  3. Trabajar con diferentes tipos de células
  4. Apariencia de la celda de ajuste

Trabajar con celdas en el archivo de Excel en Java

Crear celdas en el archivo de Excel

//Create Cells
XSSFWorkbook wb = new XSSFWorkbook();
XSSFCreationHelper createHelper = wb.getCreationHelper();
XSSFSheet sheet = wb.createSheet("new sheet");
// Create a row and put some cells in it. Rows are 0 based.
Row row = sheet.createRow(0);
// Create a cell and put a value in it.
Cell cell = row.createCell(0);
cell.setCellValue(1);
row.createCell(1).setCellValue(1.2);
row.createCell(2).setCellValue(createHelper.createRichTextString("This is a string"));
row.createCell(3).setCellValue(true);
// Write the output to a file
try (FileOutputStream fileOut = new FileOutputStream("workbook.xlsx")) {
    wb.write(fileOut);
}

El fragmento de código Java anterior demuestra el uso de la API de Apache POI para trabajar con las celdas en un libro de trabajo de Excel. El código crea un nuevo libro de trabajo de Excel (\ **xssfworkbook** \), inicializa una hoja dentro del libro de trabajo y luego llena las celdas con varios tipos de datos. Primero, el código crea una nueva hoja llamada " Nueva hoja “. Luego genera una fila en el índice 0 en la hoja y procede a llenar las celdas dentro de esa fila. A la primera celda (índice 0) se le asigna un valor entero de 1 usando el método \ **setCellValue** \. En contraste, la segunda celda (índice 1) se establece en un valor decimal de 1.2 directamente dentro del método \ **createCell** \. La tercera celda (índice 2) contiene un valor de cadena “Esta es una cadena” creada usando la instancia \ **CreaterichTextString** \ de la instancia \ **xssfcreationHelper** \. Por último, la cuarta célula (índice 3) está poblada con el valor booleano “verdadero”. Después de establecer los valores de la celda, el código escribe el libro de trabajo resultante en un archivo de Excel llamado “Workbook.xlsx” utilizando un \ **FileOutputStream** \.

Crear celda de tipo de fecha

XSSFWorkbook wb = new XSSFWorkbook();
//Workbook wb = new XSSFWorkbook();
CreationHelper createHelper = wb.getCreationHelper();
org.apache.poi.ss.usermodel.Sheet sheet = wb.createSheet("new sheet");
// Create a row and put some cells in it. Rows are 0 based.
Row row = sheet.createRow(0);
// Create a cell and put a date value in it.  The first cell is not styled
// as a date.
Cell cell = row.createCell(0);
cell.setCellValue(new Date());
// we style the second cell as a date (and time).  It is important to
// create a new cell style from the workbook otherwise you can end up
// modifying the built in style and effecting not only this cell but other cells.
CellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(
    createHelper.createDataFormat().getFormat("m/d/yy h:mm"));
cell = row.createCell(1);
cell.setCellValue(new Date());
cell.setCellStyle(cellStyle);
//you can also set date as java.util.Calendar
cell = row.createCell(2);
cell.setCellValue(Calendar.getInstance());
cell.setCellStyle(cellStyle);
// Write the output to a file
try (FileOutputStream fileOut = new FileOutputStream("workbook.xlsx")) {
    wb.write(fileOut);
}

Este fragmento de código Java muestra el uso de la API de Apache POI para trabajar con celdas de tipo fecha en un libro de trabajo de Excel. El código comienza creando un nuevo libro de trabajo de Excel (\ **xssfworkbook** \). La primera celda (índice 0) está destinada a mantener un valor de fecha. Un objeto \ **fecha** \ que representa la fecha y hora actuales se establece como el valor de la celda utilizando el método \ **setCellValue** \. Esta celda no tiene un estilo explícitamente como una fecha. Para la segunda celda (índice 1), se crea un nuevo estilo de celda (\ CellStyle \) utilizando el método \ CreateCellStyle \ del libro de trabajo. Este estilo se configura para tener un formato de fecha y hora específicos utilizando el método \ setDataFormat \. El \ creatataFormat (). A la segunda celda se le asigna el valor actual de fecha y hora, y el estilo de celda recién creado se aplica a él utilizando el método \ setCellStyle `. La tercera celda (índice 2) demuestra un método alternativo para llenar celdas de tipo fecha usando \ java.util.calendar \. Similar a la segunda celda, el estilo de celda personalizado también se aplica a esta celda.

Trabajar con diferentes tipos de celdas

XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet sheet = wb.createSheet("new sheet");
Row row = sheet.createRow(2);
row.createCell(0).setCellValue(1.1);
row.createCell(1).setCellValue(new Date());
row.createCell(2).setCellValue(Calendar.getInstance());
row.createCell(3).setCellValue("a string");
row.createCell(4).setCellValue(true);
row.createCell(5).setCellType(CellType.ERROR);		// Write the output to a file
try (FileOutputStream fileOut = new FileOutputStream("workbook.xlsx")) {
    wb.write(fileOut);
}

En esta muestra de código, se aplican diferentes estilos de celdas a las celdas en un archivo de Excel utilizando la API POI Apache como se explica en los siguientes pasos.

  1. Se crea una fila en el índice 2 en la hoja usando \ **Createrow** (2) \. Las celdas se poblan dentro de esta fila con los siguientes datos.
  2. A la primera celda (índice 0) se le asigna un valor decimal de 1.1 utilizando el método \ **setCellValue** \.
  3. En la segunda celda (índice 1), la fecha y hora actuales se insertan utilizando un método \ date \ a través del método \ **setCellValue** \.
  4. La tercera celda (índice 2) contiene la fecha y la hora de una instancia \ calendario \, establecida utilizando el método \ **setCellValue** \.
  5. La cuarta celda (índice 3) contiene el texto “una cadena”.
  6. La quinta célula (índice 4) se designa para un valor booleano “verdadero”.
  7. Avanzando, se asigna un tipo de celda específico a la sexta celda (índice 5) invocando el método \ **setCellType** \. Esta celda se configura como una celda de error utilizando la enumeración \ **CellType.error** \, que indica que mostrará un valor de error. Finalmente, el libro de trabajo modificado se escribe en un archivo llamado “Workbook.xlsx” utilizando un \ **FileOutputStream** \. En resumen, este ejemplo de código demuestra cómo establecer un libro de trabajo de Excel, aplicar diferentes estilos de celdas para acomodar varios tipos de datos y finalmente guardar el libro de trabajo modificado en un archivo. Esta ilustración práctica muestra las capacidades de la Biblioteca Apache POI para trabajar con archivos de Excel en Java.

Apariencia celular de ajuste

XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet sheet = wb.createSheet("new sheet");
// Create a row and put some cells in it. Rows are 0 based.
Row row = sheet.createRow(1);
// Aqua background
CellStyle style = wb.createCellStyle();
style.setFillBackgroundColor(IndexedColors.AQUA.getIndex());
style.setFillPattern(FillPatternType.BIG_SPOTS);
Cell cell = row.createCell(1);
cell.setCellValue("X");
cell.setCellStyle(style);
// Orange "foreground", foreground being the fill foreground not the font color.
style = wb.createCellStyle();
style.setFillForegroundColor(IndexedColors.ORANGE.getIndex());
style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
cell = row.createCell(2);
cell.setCellValue("X");
cell.setCellStyle(style);
// Write the output to a file
try (FileOutputStream fileOut = new FileOutputStream("workbook.xlsx")) {
    wb.write(fileOut);
}
wb.close();

Este fragmento de código demuestra cómo manipular la apariencia de las celdas en un archivo de Excel utilizando la biblioteca Apache POI en Java. Esto se logra utilizando los siguientes pasos.

  1. Se crea una fila en el índice 1 en la hoja usando \ Createrow (1) \. Los siguientes cambios se realizan a las celdas dentro de esta fila.
  2. Para la primera celda (índice 1), se crea un estilo de celda personalizado usando \ wb.createCellStyle () \. Este estilo está configurado con un color de fondo Aqua usando \ setFillBackgroundColor \ y \ indexedColors.aqua.getIndex () \. El patrón para el fondo se establece en “Big Spots” usando \ setFillPattern (FillPatternType.Big_Spots) \. Se crea una celda en esta fila en el índice 1 y se llena con el valor “x”. El estilo creado anteriormente se aplica a esta celda usando \ setCellStyle \.
  3. Para la segunda celda (índice 2), se crea un nuevo estilo de celda. Este estilo está diseñado con un color naranja en primer plano usando \ setfillforegroundcolor \ y \ indexedColors.Orange.getIndex () \. El patrón de relleno se establece en “primer plano sólido” usando \ setFillPattern (rellenoPatternType.solid_foreground) \. Otra celda se crea en el índice 2 en la misma fila y se pobla con el valor “x”. El estilo recién generado se asigna a esta celda usando \ setCellStyle \. Después de configurar las apariciones de celdas, el libro de trabajo modificado se escribe en un archivo llamado “Workbook.xlsx” utilizando un \ fileOutputStream \. En resumen, este ejemplo de código muestra cómo usar la biblioteca Apache POI para manipular las apariencias celulares en un archivo de Excel. Las técnicas demostradas implican la creación de estilos de celdas personalizados para controlar el fondo y los colores de primer plano, así como los patrones de llenado, proporcionando flexibilidad para personalizar visualmente hojas de cálculo de Excel con Java.

Conclusión

En todos los ejemplos de Java anteriores para la Biblioteca Apache POI, hemos demostrado cómo trabajar con el contenido del archivo de Excel desde su aplicación Java. Las muestras de código mostraron cómo crear celdas en un archivo de Excel, establecer la apariencia de estos, establecer un estilo de celda en diferentes tipos de datos, como cadena, numérica, decimal, etc., y cómo establecer el tipo de celda hasta la fecha. Agregaremos más ejemplos para trabajar con archivos de Excel usando Apache POI para Java, así que estad atentos.

Ver también