Cómo leer archivos Excel en Java (Tutorial)

¿Qué es Excel?

Microsoft Excel Workbook es un software basado en hojas de cálculo que permite a sus usuarios organizar y almacenar datos de forma eficaz. Almacena y organiza los datos en forma tabular, es decir, mediante filas y columnas. La celda de una hoja de cálculo Excel es el cuadro que contiene los datos y puede manipularse con diferentes estilos, formatos y fórmulas.

¿Cómo leer archivos Excel en Java?

La lectura de un archivo Excel puede resultar complicada en ocasiones. La lectura de archivos Excel en Java también es un poco diferente a la lectura de archivos Word en Java debido a las celdas de Excel. El JDK no proporciona una API directa para leer o escribir documentos de Microsoft Excel. En su lugar, tenemos que confiar en la biblioteca de terceros Apache POI.

Biblioteca POI de Apache

POI son las siglas de "Poor Obfuscation Implementation". Apache POI es una biblioteca Java de código abierto diseñada para leer y escribir documentos de Microsoft. Ofrece una forma de crear y manipular varios formatos de archivo basados en Microsoft Office. Usando Apache POI, uno debería ser capaz de realizar operaciones de creación, modificación y visualización/lectura en una gama de formatos de archivo de Microsoft Office.

Descargar e instalar la biblioteca POI de Apache

Para empezar, descargaremos la última versión de los JARs POI. Vaya a http://poi.apache.org/download.html y descargue el último archivo ZIP, que contendrá la API Java para leer un archivo Excel en Java.

Descargar archivos JAR de Apache POI

Cuando descargue el archivo ZIP, deberá descomprimirlo y añadir los siguientes archivos JAR al classpath de su proyecto. Esto se explica en Lectura desde un fichero Excel más abajo.

Añada los ficheros jar de Apache POI al classpath de Java

Nota: Copie también los archivos de lib y ooxml-lib junto con los demás archivos.

Clases e interfaces en PDI

A continuación se indican las clases de archivos XLS y XLSX que pueden utilizarse:

Clases de POI de Apache

La siguiente es una lista de diferentes interfaces Java y clases en POI para leer archivos XLS y XLSX en Java:

La interfaz Workbook está implementada por las clases HSSFWorkbook y XSSFWorkbook.

• HSSFWorkbook: Es una representación de clase del fichero XLS.

• XSSFWorkbook: Es una representación de clase del fichero XLSX.

  Las clases HSSFSheet y XSSFSheet implementan la interfaz Hoja.

• HSSFSheet: Es una clase que representa una hoja de un fichero XLS.

• XSSFSheet: Esta es una clase que representa una hoja en un archivo XLSX.

  La interfaz Row está implementada por las clases HSSFRow y XSSFRow.

• HSSFRow: Es una clase que representa una fila en la hoja de un fichero XLS.

• XSSFRow: Es una clase que representa una fila en la hoja de un fichero XLSX.

  La interfaz Cell está implementada por las clases HSSFCell y XSSFCell.

• HSSFCell: Esta es una clase que representa una celda en una fila de un archivo XLS.
• XSSFCell: Es una clase que representa una celda de una fila de un fichero XLSX.

Lectura de un archivo Excel

Para nuestro ejemplo, leeremos el siguiente archivo Excel en Java:

El archivo Excel que se leerá

Pasos para leer archivos Excel en Java

1. Crea un proyecto Java usando cualquier IDE Java. Vamos a utilizar Netbeans para este proyecto.
2. A continuación, crea una carpeta lib en el proyecto.
3. A continuación, añada los archivos JAR descargados a la carpeta lib creada en el paso anterior.
4. Establezca la Class-Path haciendo clic con el botón derecho en la carpeta Project > Build Path > Add External JARs files > seleccione todos los archivos JAR anteriores > Apply and close.
5. Ahora, vamos a crear un archivo de clase con el nombre ReadExcelFileDemo.

6. Cree un archivo Excel con el nombre "studentdata.xls" y escriba en él los datos anteriores o cualquier otro dato.

   A continuación se muestra un ejemplo de código para leer archivos Excel en Java:

import java.io.File;  
import java.io.FileInputStream;  
import java.io.IOException;  
import org.apache.poi.hssf.usermodel.HSSFSheet;  
import org.apache.poi.hssf.usermodel.HSSFWorkbook;  
import org.apache.poi.ss.usermodel.Cell;  
import org.apache.poi.ss.usermodel.FormulaEvaluator;  
import org.apache.poi.ss.usermodel.Row;  

public class ReadExcelFileDemo  {  
    public static void main(String args []) throws IOException  {  
        //obtención de bytes de entrada de un fichero  
        FileInputStream fis=new FileInputStream(new File("C:\\demo\\studentdata.xls"));  
        //crear una instancia de libro de trabajo que haga referencia a un archivo .xls  
        HSSFWorkbook wb=new HSSFWorkbook(fis);   
        //crear un objeto Hoja para recuperar el objeto  
        HSSFSheet sheet=wb.getSheetAt(0);  
        //evaluar el tipo de célula   
        FormulaEvaluator formulaEvaluator=wb.getCreationHelper().createFormulaEvaluator();  
        for(Row row: sheet) {  
            for(Cell cell: row) {
                switch(formulaEvaluator.evaluateInCell(cell).getCellType()) {  
                    case Cell.CELL_TYPE_NUMERIC: //campo que representa el tipo de celda numérica  
                        //obtener el valor de la celda como un número  
                        System.out.print(cell.getNumericCellValue()+ "\t\t");   
                        break;  
                    case Cell.CELL_TYPE_STRING: //campo que representa el tipo de celda de cadena  
                        //obtener el valor de la celda como cadena  
                        System.out.print(cell.getStringCellValue()+ "\t\t");  
                        break;
                }
            }
            System.out.println();  
        }
    }
}

import java.io.File;  
import java.io.FileInputStream;  
import java.io.IOException;  
import org.apache.poi.hssf.usermodel.HSSFSheet;  
import org.apache.poi.hssf.usermodel.HSSFWorkbook;  
import org.apache.poi.ss.usermodel.Cell;  
import org.apache.poi.ss.usermodel.FormulaEvaluator;  
import org.apache.poi.ss.usermodel.Row;  

public class ReadExcelFileDemo  {  
    public static void main(String args []) throws IOException  {  
        //obtención de bytes de entrada de un fichero  
        FileInputStream fis=new FileInputStream(new File("C:\\demo\\studentdata.xls"));  
        //crear una instancia de libro de trabajo que haga referencia a un archivo .xls  
        HSSFWorkbook wb=new HSSFWorkbook(fis);   
        //crear un objeto Hoja para recuperar el objeto  
        HSSFSheet sheet=wb.getSheetAt(0);  
        //evaluar el tipo de célula   
        FormulaEvaluator formulaEvaluator=wb.getCreationHelper().createFormulaEvaluator();  
        for(Row row: sheet) {  
            for(Cell cell: row) {
                switch(formulaEvaluator.evaluateInCell(cell).getCellType()) {  
                    case Cell.CELL_TYPE_NUMERIC: //campo que representa el tipo de celda numérica  
                        //obtener el valor de la celda como un número  
                        System.out.print(cell.getNumericCellValue()+ "\t\t");   
                        break;  
                    case Cell.CELL_TYPE_STRING: //campo que representa el tipo de celda de cadena  
                        //obtener el valor de la celda como cadena  
                        System.out.print(cell.getStringCellValue()+ "\t\t");  
                        break;
                }
            }
            System.out.println();  
        }
    }
}

Salida:

IdNames
1Zeeshan
2Shoaib
3Umar
4Rizwan
5Ahsan

Los pasos son los mismos para la lectura de archivos xlsx, a excepción de los dos puntos principales siguientes:

• En primer lugar, cambie el formato del archivo a .xlsx. Se puede utilizar el mismo archivo "studentdata", pero con la extensión .xlsx.
• En segundo lugar, hay una diferencia en la forma de importar Java Apache POI. El código es el siguiente:

import java.io.File;  
import java.io.FileInputStream;  
import java.util.Iterator;  
import org.apache.poi.ss.usermodel.Cell;  
import org.apache.poi.ss.usermodel.Row;  
import org.apache.poi.xssf.usermodel.XSSFSheet;  
import org.apache.poi.xssf.usermodel.XSSFWorkbook;  

public class XLSXReaderExample  {

    public static void main(String [] args) {  
        try {  
            File file = new File("C:\\demo\\studentdata.xlsx");  
            FileInputStream fis = new FileInputStream(file);  
            //crear una instancia de Workbook que haga referencia a un archivo .xlsx  
            XSSFWorkbook wb = new XSSFWorkbook(fis);   
            XSSFSheet sheet = wb.getSheetAt(0); 
            Iterator<Row> itr = sheet.iterator();
            while (itr.hasNext()) {  
                Row row = itr.next();  
                Iterator<Cell> cellIterator = row.cellIterator();   //iterando sobre cada columna  
                while (cellIterator.hasNext()) {  
                    Cell cell = cellIterator.next();  
                    switch (cell.getCellType()) {  
                        case Cell.CELL_TYPE_NUMERIC: //campo que representa el tipo de celda numérica  
                            //obtener el valor de la celda como un número  
                            System.out.print(cell.getNumericCellValue() + "\t\t");   
                            break;
                        case Cell.CELL_TYPE_STRING: //campo que representa el tipo de celda de cadena  
                            //obtener el valor de la celda como cadena  
                            System.out.print(cell.getStringCellValue() + "\t\t");  
                            break;
                    }
                }
                System.out.println("");  
            }  
        } catch(Exception e) {  
            e.printStackTrace();  
        }
    }
}

import java.io.File;  
import java.io.FileInputStream;  
import java.util.Iterator;  
import org.apache.poi.ss.usermodel.Cell;  
import org.apache.poi.ss.usermodel.Row;  
import org.apache.poi.xssf.usermodel.XSSFSheet;  
import org.apache.poi.xssf.usermodel.XSSFWorkbook;  

public class XLSXReaderExample  {

    public static void main(String [] args) {  
        try {  
            File file = new File("C:\\demo\\studentdata.xlsx");  
            FileInputStream fis = new FileInputStream(file);  
            //crear una instancia de Workbook que haga referencia a un archivo .xlsx  
            XSSFWorkbook wb = new XSSFWorkbook(fis);   
            XSSFSheet sheet = wb.getSheetAt(0); 
            Iterator<Row> itr = sheet.iterator();
            while (itr.hasNext()) {  
                Row row = itr.next();  
                Iterator<Cell> cellIterator = row.cellIterator();   //iterando sobre cada columna  
                while (cellIterator.hasNext()) {  
                    Cell cell = cellIterator.next();  
                    switch (cell.getCellType()) {  
                        case Cell.CELL_TYPE_NUMERIC: //campo que representa el tipo de celda numérica  
                            //obtener el valor de la celda como un número  
                            System.out.print(cell.getNumericCellValue() + "\t\t");   
                            break;
                        case Cell.CELL_TYPE_STRING: //campo que representa el tipo de celda de cadena  
                            //obtener el valor de la celda como cadena  
                            System.out.print(cell.getStringCellValue() + "\t\t");  
                            break;
                    }
                }
                System.out.println("");  
            }  
        } catch(Exception e) {  
            e.printStackTrace();  
        }
    }
}

Salida:

IdNames
1Zeeshan
2Shoaib
3Umar
4Rizwan
5Ahsan

La biblioteca IronXL C

IronXL es una biblioteca .NET independiente que facilita la lectura y edición de documentos de Microsoft Excel con C#. No requiere que Microsoft Excel esté instalado ni depende de Interop.

Con IronXL, los desarrolladores pueden realizar todos los cálculos relacionados con Excel sin esfuerzo, simplemente escribiendo unas pocas líneas de código y con un rápido rendimiento. Esto podría ser para tareas tales como sumar dos celdas, calcular el total general de una columna, agregar una columna completa a una tabla de Excel, agregar una fila completa a una tabla de Excel, sumas de columnas de una y varias filas, o muchas otras tareas que se facilitan a través de IronXL. funciones útiles.

IronXL es totalmente compatible con .NET Framework, .NET Core, Mobile, Xamarin, Azure Linux y MacOS.

Características de IronXL

• Carga, lee y edita datos de XLS/XLSX/CSV/TSV.
• Guardar y exportar a XLS/XLSX/CSV/TSV/JSON.
• Objetos System.Data - trabaja con hojas de cálculo Excel como objetos System.Data.DataSet y System.Data.DataTable.
• Fórmulas - trabaja con fórmulas de Excel.
• Gamas - ["A1:B10] La sintaxis es fácil de usar.
• Ordenar: ordena filas, columnas y rangos.

• Estilización: estilos visuales, fuente y tamaño de fuente, patrón de fondo, borde, alineación y formatos numéricos.

  A continuación se muestra un ejemplo de código de la lectura de un archivo de Excel en C # usando IronXL:

using IronXL;
using System.Linq;

//Los formatos de hoja de cálculo compatibles para la lectura son: XLSX, XLS, CSV y TSV
WorkBook workbook = WorkBook.Load("test.xlsx");
WorkSheet sheet = workbook.WorkSheets.First();

//Seleccionar celdas fácilmente en notación Excel y devolver el valor calculado
int cellValue = sheet ["A2"].IntValue;

//  Lee desde Rangos de células con elegancia.
foreach (var cell in sheet ["A2:A10"]) {
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

using IronXL;
using System.Linq;

//Los formatos de hoja de cálculo compatibles para la lectura son: XLSX, XLS, CSV y TSV
WorkBook workbook = WorkBook.Load("test.xlsx");
WorkSheet sheet = workbook.WorkSheets.First();

//Seleccionar celdas fácilmente en notación Excel y devolver el valor calculado
int cellValue = sheet ["A2"].IntValue;

//  Lee desde Rangos de células con elegancia.
foreach (var cell in sheet ["A2:A10"]) {
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

Imports IronXL
Imports System.Linq

'Los formatos de hoja de cálculo compatibles para la lectura son: XLSX, XLS, CSV y TSV
Private workbook As WorkBook = WorkBook.Load("test.xlsx")
Private sheet As WorkSheet = workbook.WorkSheets.First()

'Seleccionar celdas fácilmente en notación Excel y devolver el valor calculado
Private cellValue As Integer = sheet ("A2").IntValue

'  Lee desde Rangos de células con elegancia.
For Each cell In sheet ("A2:A10")
	Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text)
Next cell

Trabajar con IronXL facilita mucho el trabajo de los desarrolladores. Su código sencillo y fácil de usar hace que el software sea menos propenso a errores al trabajar con archivos Excel.

Descargar IronXL y utilícelo hoy mismo en sus proyectos.