Hoy en día, las hojas de cálculo se usan mucho para guardar y compartir una gran cantidad de datos tabulares. Además, puede realizar varias operaciones, como aplicar fórmulas, generar tablas y gráficos, ordenar y filtrar datos, etc. La automatización de hojas de cálculo ha supuesto una revolución en diversas industrias. La creación dinámica y la manipulación de las hojas de cálculo han facilitado bastante el manejo de los datos. Para realizar la manipulación de hojas de cálculo mediante programación, este artículo cubre cómo crear archivos Excel XLSX o XLS desde cero en Linux usando Java.
- API de Java para crear archivos de Excel en Linux
- Cree archivos Excel XLSX o XLS en Linux
- Editar archivos de Excel existentes
- Crear gráficos en archivos de Excel
- Crear una tabla dinámica en un XLSX
- Agregar fórmulas para celdas en XLSX
API para crear archivos de Excel en Linux - Descarga gratuita
Para crear y manipular los archivos de Excel, usaremos Aspose.Cells for Java. Es una poderosa API de manipulación de hojas de cálculo para crear, actualizar o convertir archivos de Excel. Puede descargar el JAR de la API o instalarlo dentro de sus aplicaciones basadas en Maven usando las siguientes configuraciones.
<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>21.9</version>
</dependency>
Crear un archivo de Excel en Linux
Los archivos de MS Excel guardan datos en las hojas de cálculo que se componen de varias celdas. Mientras que estas hojas de trabajo están contenidas en un Workbook. Los siguientes son los pasos para crear un archivo Excel XLSX desde cero en Linux.
- Cree una instancia de la clase Workbook.
- Obtenga la referencia de la hoja de trabajo deseada usando el método Workbook.getWorksheets.get().
- Inserte el valor en la celda deseada de la hoja de trabajo usando el identificador de la celda, como A1, B3, etc.
- Guarde el Workbook usando el método Workbook.save().
El siguiente ejemplo de código muestra cómo crear un archivo XLSX de Excel en Linux 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");
El siguiente es el resultado del ejemplo de código anterior.
Editar un archivo XLSX de Excel en Linux
También puede modificar los archivos de Excel existentes sin problemas. Para esto, simplemente puede cargar el archivo, acceder a la hoja de trabajo deseada y actualizar su contenido. Los siguientes son los pasos para editar un archivo Excel XLSX.
- Cargue el archivo de Excel usando la clase Workbook.
- Obtenga la referencia de las hojas de trabajo y las celdas usando las clases Worksheet y Cell, respectivamente.
- Actualizar el contenido de las celdas.
- Guarde el Workbook actualizado usando el método Workbook.save().
El siguiente ejemplo de código muestra cómo editar un archivo de Excel en Linux.
// 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 gráficos en archivos de Excel en Linux
Los gráficos en las hojas de cálculo se utilizan para representar visualmente los datos almacenados en las hojas de cálculo. Aspose.Cells for Java proporciona una amplia gama de gráficos que puede generar dentro de los archivos de Excel. Los siguientes son los pasos para crear un gráfico en un archivo Excel XLSX en la plataforma Linux.
- 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 a la colección usando el método Worksheet.getCharts().add().
- Obtenga la referencia del Chart recién creado de la colección.
- Especifique el rango de celdas para configurar NSeries para el gráfico.
- Finalmente, guarde el archivo de Excel.
El siguiente ejemplo de código muestra cómo crear un gráfico en un archivo XLSX de Excel.
// 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");
La siguiente captura de pantalla muestra el resultado del ejemplo de código anterior.
Crear una tabla dinámica en un archivo de Excel en Linux
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. Puede crear una tabla dinámica en un archivo de Excel siguiendo los pasos a continuación.
- Cree un nuevo archivo de Excel o cargue uno existente usando la clase Workbook.
- 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 usando el método Workbook.save().
El siguiente ejemplo de código muestra cómo crear una tabla dinámica en Excel.
// 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");
La siguiente es la captura de pantalla de la tabla dinámica generada por el ejemplo de código anterior.
Agregar fórmulas para celdas en archivos de Excel
Aspose.Cells for Java también admite trabajar con fórmulas en hojas de cálculo de Excel. Las siguientes secciones describen cómo trabajar con funciones integradas y complementarias.
Aplicar funciones integradas en Excel
Para las funciones integradas, simplemente puede obtener la referencia de la celda deseada en la hoja de trabajo y agregar una fórmula usando el método Cell.setFormula(String). El siguiente ejemplo de código muestra cómo configurar una fórmula integrada en Excel.
// 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
Aspose.Cells for Java también admite funciones definidas por el usuario para las hojas de cálculo de Excel. Para ello, deberá registrar la función de complemento mediante un archivo xlam (complemento habilitado para macros de Excel). Para registrar las funciones complementarias, la API proporciona los métodos registerAddInFunction(int, String) y registerAddInFunction(String, String, boolean). El siguiente ejemplo de código muestra cómo registrar y usar una función de complemento en Excel.
// 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");
Obtenga una licencia gratis
Puede usar Aspose.Cells for Java sin limitaciones de evaluación usando una licencia temporal.
Conclusión
En este artículo, ha aprendido cómo crear archivos de MS Excel desde cero en Linux. Además, ha visto cómo actualizar los archivos de Excel, generar gráficos, crear tablas dinámicas y agregar fórmulas en las hojas de trabajo. Puede obtener más información sobre Aspose.Cells for Java utilizando documentación. En caso de que tenga alguna pregunta, puede hacerla a través de nuestro foro.