Las hojas de cálculo de MS Excel han facilitado el mantenimiento y el intercambio de una gran cantidad de datos tabulares. No solo esto, puede realizar varias operaciones, como aplicar fórmulas, generar tablas y gráficos, clasificar y filtrar datos, etc. En este artículo, aprenderá a implementar funciones de automatización de Excel desde sus aplicaciones Java. Después de leer este artículo, podrá crear archivos Excel XLSX o XLS desde cero utilizando Java. Además, este artículo cubrirá cómo actualizar un archivo de Excel existente, generar gráficos, aplicar fórmulas y agregar tablas dinámicas en hojas de cálculo de Excel.

API de Java para crear archivos de Excel - Descarga gratuita

Aspose.Cells for Java es una poderosa API de manipulación de hojas de cálculo que le permite crear o modificar archivos de Excel sin MS Office. La API admite agregar tablas, gráficos, fórmulas y realizar otras operaciones de manipulación de hojas de cálculo mediante programación. Puede descargar la API de forma gratuita o instalarla dentro de sus aplicaciones basadas en Maven.

<repository>
    <id>AsposeJavaAPI</id>
    <name>Aspose Java API</name>
    <url>https://repository.aspose.com/repo/</url>
</repository>

<dependency>
    <groupId>com.aspose</groupId>
    <artifactId>aspose-cells</artifactId>
    <version>20.9</version>
</dependency>

Cree Excel XLSX o XLS usando Java

Los archivos de MS Excel se denominan libros de trabajo y cada Workbook se compone de una o más hojas de trabajo. Las hojas de trabajo contienen además las filas y columnas para mantener los datos en forma de celdas. Entonces, comencemos creando un Workbook simple. Los siguientes son los pasos para crear un archivo Excel XLSX desde cero.

  • Cree una instancia de la clase Workbook.
  • Acceda a la hoja de trabajo deseada usando el método Workbook.getWorksheets.get().
  • Coloque el valor en la celda deseada en la hoja de trabajo usando el identificador de la celda, como A1, B3, etc.
  • Guarde el Workbook como un archivo de Excel usando el método Workbook.save().

El siguiente ejemplo de código muestra cómo crear un archivo XLSX de Excel usando Java.

// Crear un nuevo Workbook
Workbook workbook = new Workbook();

// Agregar valor en la celda
workbook.getWorksheets().get(0).getCells().get("A1").putValue("Hello World!");

// Guardar como archivo Excel XLSX
workbook.save("Excel.xlsx");

Edite un archivo XLSX de Excel usando Java

Veamos ahora cómo modificar o insertar datos en un archivo de MS Excel existente. Para esto, simplemente puede cargar el archivo, acceder a la hoja de trabajo deseada y guardar el archivo actualizado. Los siguientes son los pasos para modificar un archivo de Excel existente.

  • Abra el archivo de Excel usando la clase Workbook.
  • Acceda a las hojas de trabajo y celdas usando las clases Worksheet y Cell respectivamente.
  • Guarde el Workbook actualizado como un archivo de Excel .xlsx.

El siguiente ejemplo de código muestra cómo editar un archivo de MS Excel existente usando Java.

// Crear un nuevo Workbook
Workbook workbook = new Workbook("workbook.xls"); 

// Obtenga la referencia de la celda "A1" de las celdas de una hoja de trabajo
Cell cell = workbook.getWorksheets().get(0).getCells().get("A1");

// Configure el "¡Hola mundo!" valor en la celda "A1"
cell.setValue("updated cell value.");

// Escribir el archivo de Excel
workbook.save("Excel.xls", FileFormatType.EXCEL_97_TO_2003);

Crear tablas o gráficos en Excel usando Java

Los gráficos en las hojas de cálculo se utilizan para representar visualmente los datos almacenados en las hojas de cálculo. Facilitan el análisis de una gran cantidad de datos con bastante facilidad. Aspose.Cells for Java proporciona una amplia gama de gráficos que puede crear dentro de los archivos de Excel mediante programación. Los siguientes son los pasos para crear un gráfico en un archivo XLSX de Excel.

  • Cree un nuevo archivo de Excel o cargue uno existente usando la clase Workbook.
  • Agregar datos a la hoja de cálculo (opcional).
  • Obtenga la colección de gráficos de la hoja de cálculo mediante el método Worksheet.getCharts().
  • Agregue un nuevo gráfico usando el método Worksheet.getCharts().add().
  • Obtenga el gráfico recién creado de la colección.
  • Especifique el rango de celdas para configurar NSeries para el gráfico.
  • Guarde el Workbook como un archivo .xlsx de Excel.

El siguiente ejemplo de código muestra cómo crear un gráfico en Excel XLSX usando Java.

// Crear un nuevo Workbook
Workbook workbook = new Workbook("workbook.xlsx"); 

// Obtención de la referencia de la primera hoja de cálculo
WorksheetCollection worksheets = workbook.getWorksheets();
Worksheet sheet = worksheets.get(0);

// Agregar algún valor de muestra a las celdas
Cells cells = sheet.getCells();
Cell cell = cells.get("A1");
cell.setValue(50);
cell = cells.get("A2");
cell.setValue(100);
cell = cells.get("A3");
cell.setValue(150);
cell = cells.get("B1");
cell.setValue(4);
cell = cells.get("B2");
cell.setValue(20);
cell = cells.get("B3");
cell.setValue(50);

// obtener gráficos en la hoja de trabajo
ChartCollection charts = sheet.getCharts();

// Adición de un gráfico a la hoja de cálculo
int chartIndex = charts.add(ChartType.PYRAMID, 5, 0, 15, 5);
Chart chart = charts.get(chartIndex);

// Agregar NSeries (fuente de datos del gráfico) al gráfico que va desde "A1"
// celda a "B3"
SeriesCollection serieses = chart.getNSeries();
serieses.add("A1:B3", true);

// Escribir el archivo de Excel 
workbook.save("Excel_with_Chart.xlsx");
crear un gráfico en excel usando java

Crear una tabla dinámica en Excel XLSX usando Java

Las tablas dinámicas en las hojas de cálculo de Excel tienen varios propósitos, como agregar filtros a los datos, calcular totales, resumir datos, etc. Las tablas dinámicas se pueden crear utilizando el rango de celdas de la hoja de cálculo. Los siguientes son los pasos para crear una tabla dinámica en una hoja de cálculo de Excel.

  • Cree un nuevo Workbook o cargue un archivo existente.
  • Insertar datos en la hoja de cálculo (opcional).
  • Acceda a la colección de tablas dinámicas mediante el método Worksheet.getPivotTables().
  • Agregue una nueva tabla dinámica en la hoja de trabajo usando el método Worksheet.getPivotTables().add().
  • Proporcionar datos a la tabla dinámica.
  • Guarde el Workbook.

El siguiente ejemplo de código muestra cómo crear una tabla dinámica en Excel usando Java.

// Crear un nuevo Workbook
Workbook workbook = new Workbook("workbook.xlsx"); 

// Obtenga la primera hoja de trabajo.
Worksheet sheet = workbook.getWorksheets().get(0);

// Obtención de la colección de celdas de Worksheet
Cells cells = sheet.getCells();

// Establecer el valor de las celdas
Cell cell = cells.get("A1");
cell.setValue("Sport");
cell = cells.get("B1");
cell.setValue("Quarter");
cell = cells.get("C1");
cell.setValue("Sales");

cell = cells.get("A2");
cell.setValue("Golf");
cell = cells.get("A3");
cell.setValue("Golf");
cell = cells.get("A4");
cell.setValue("Tennis");
cell = cells.get("A5");
cell.setValue("Tennis");
cell = cells.get("A6");
cell.setValue("Tennis");
cell = cells.get("A7");
cell.setValue("Tennis");
cell = cells.get("A8");
cell.setValue("Golf");

cell = cells.get("B2");
cell.setValue("Qtr3");
cell = cells.get("B3");
cell.setValue("Qtr4");
cell = cells.get("B4");
cell.setValue("Qtr3");
cell = cells.get("B5");
cell.setValue("Qtr4");
cell = cells.get("B6");
cell.setValue("Qtr3");
cell = cells.get("B7");
cell.setValue("Qtr4");
cell = cells.get("B8");
cell.setValue("Qtr3");

cell = cells.get("C2");
cell.setValue(1500);
cell = cells.get("C3");
cell.setValue(2000);
cell = cells.get("C4");
cell.setValue(600);
cell = cells.get("C5");
cell.setValue(1500);
cell = cells.get("C6");
cell.setValue(4070);
cell = cells.get("C7");
cell.setValue(5000);
cell = cells.get("C8");
cell.setValue(6430);


PivotTableCollection pivotTables = sheet.getPivotTables();

// Agregar una tabla dinámica a la hoja de cálculo
int index = pivotTables.add("=A1:C8", "E3", "PivotTable2");

// Acceso a la instancia de la tabla dinámica recién agregada
PivotTable pivotTable = pivotTables.get(index);

// No mostrar los totales generales de las filas.
pivotTable.setRowGrand(false);

// Arrastrando el primer campo al área de la fila.
pivotTable.addFieldToArea(PivotFieldType.ROW, 0);

// Arrastrando el segundo campo al área de la columna.
pivotTable.addFieldToArea(PivotFieldType.COLUMN, 1);

// Arrastrando el tercer campo al área de datos.
pivotTable.addFieldToArea(PivotFieldType.DATA, 2);

// Escribir el archivo de Excel 
workbook.save("Excel_with_Chart.xlsx");
crear una tabla dinámica en excel usando java

Agregue fórmulas para celdas en un archivo de Excel usando Java

Aspose.Cells for Java también le permite trabajar con fórmulas en las hojas de cálculo de Excel. Puede aplicar las funciones integradas y complementarias a las celdas.

Aplicar funciones integradas en Excel

Para usar las funciones integradas, simplemente puede acceder a la celda deseada en la hoja de trabajo y agregar la fórmula usando el método Cell.setFormula(String). El siguiente ejemplo de código muestra cómo establecer una fórmula integrada mediante Java.

// Crear un nuevo Workbook
Workbook workbook = new Workbook();

// Agregar valor en la celda
workbook.getWorksheets().get(0).getCells().get(0).setFormula("=H7*(1+IF(P7 =$L$3,$M$3, (IF(P7=$L$4,$M$4,0))))");

// Guardar como archivo Excel XLSX
workbook.save("Excel.xlsx");

Agregar funciones de complemento en Excel

Puede haber un caso en el que tenga que usar una función definida por el usuario. Para ello, deberá registrar la función de complemento mediante un archivo .xlam (complemento habilitado para macros de Excel) y luego utilizarlo para las celdas deseadas. Para registrar las funciones complementarias, Aspose.Cells for Java proporciona los métodos registerAddInFunction(int, String) y registerAddInFunction(String, String, boolean). El siguiente ejemplo de código muestra cómo registrar y utilizar una función de complemento mediante Java.

// crear un nuevo Workbook
Workbook workbook = new Workbook();

// Registre el complemento habilitado para macros junto con el nombre de la función
int id = workbook.getWorksheets().registerAddInFunction("TESTUDF.xlam", "TEST_UDF", false);

// Registrar más funciones en el archivo (si las hay)
workbook.getWorksheets().registerAddInFunction(id, "TEST_UDF1"); //in this way you can add more functions that are in the same file

// Acceder a la primera hoja de trabajo
Worksheet worksheet = workbook.getWorksheets().get(0);

// Acceder a la primera celda
Cell cell = worksheet.getCells().get("A1");

// Establecer el nombre de la fórmula presente en el complemento
cell.setFormula("=TEST_UDF()"); 

// Guardar como archivo Excel XLSX
workbook.save("Excel.xlsx");

Conclusión

En este artículo, ha visto cómo crear archivos de MS Excel desde cero usando Java sin MS Office. También aprendió a actualizar libros de trabajo, crear gráficos, agregar tablas y aplicar fórmulas a valores de celda dentro de hojas de cálculo de MS Excel. Puede obtener más información sobre la API de Excel de Java de Aspose utilizando documentación.

Ver también