Las hojas de cálculo son la forma más fácil de representar datos similares a tablas y pueden brindar una representación visual de los datos en formato tabular. En este artículo, veamos cómo extraer el contenido de la hoja de Excel a través de Java. Aquí surgen dos casos donde Maven es considerado en el programa o no. Discutir ambos como requisito previo para una mejor comprensión del programa.
Los conceptos básicos de la API de Apache POI son cruciales antes de seguir adelante, por lo que los dos prefijos principales que se requieren cuando se trabaja con Apache POI son los siguientes:
- HSSF : indica que la API es para trabajar con Excel 2003 y versiones anteriores.
- XSSF : indica que la API es para trabajar con Excel 2007 y versiones posteriores.
Las siguientes 4 interfaces son importantes y esenciales para pasar
- Libro de trabajo: representación de alto nivel de un libro de Excel. HSSFWorkbook y XSSFWorkbook .
- Hoja: representación de alto nivel de una hoja de cálculo de Excel. Las clases de implementación típicas son HSSFSheet y XSSFSheet .
- Fila: Representación de alto nivel de una fila en una hoja de cálculo. HSSFRow y XSSFRow son dos clases concretas.
- Celda: Representación de alto nivel de una celda en una fila. HSSFCell y XSSFCell son las clases de implementación típicas.
Caso 1: proyecto Java de Maven donde las dependencias son las siguientes
- Todos los proyectos de Maven tendrán pom.xml como archivo principal.
- Allí necesitamos agregar las dependencias.
- El contenido del archivo pom.xml Los formatos de Excel difieren un poco, como se muestra a continuación:
- Se recomienda especificar la última versión. (El ejemplo del proyecto Maven utilizado aquí es 3.11)
Para formato Excel 2003
<dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId> <version>VERSION</version> </dependency>
Para formato Excel 2007
<dependency> <groupId>org.apache.poi</groupId> <artifactId>poi-ooxml</artifactId> <version>VERSION</version> </dependency>
Caso 2: proyecto Java no Maven.
Para cumplir con los requisitos, surge la necesidad urgente de agregar los archivos jar en la ruta de compilación para extraer el contenido. Para ello, descargue la última versión de la biblioteca Apache POI.
Para extraer el contenido de
formato excel 2003
poi-VERSION.jar is enough.
Formato Excel 2007:
poi-ooxml-VERSION.jar poi-ooxml-schemas-VERSION.jar xmlbeans-VERSION.jar
Procedimiento: Lectura de un archivo de Excel usando Apache POI con ejemplos. El objetivo es leer el contenido del archivo de Excel dado y mostrar el contenido del archivo de Excel en la ventana de «salida».
Paso 1: aquí estamos usando la clase POJO que tiene el mismo número de campos que se indica en el archivo de Excel adjunto. El archivo de Excel tiene 3 columnas y, por lo tanto, hay 3 campos en la clase POJO. El contenido del archivo de muestra de Excel se muestra a continuación. Siempre es mejor tener una clase POJO (objeto Java simple) para este tipo de operaciones. Como hay 3 valores de columna y los detalles están relacionados con un empleado, tengamos una clase de empleado.
Imagen de entrada de muestra:
Empname, EmpDesignation, Salary son las columnas
Ejemplo:
Java
// Java Program in which a Class is declared and
// its methods are defined
// Class
class Employee {
// Member variable of Employee Class
// Name, Designation and Salary
private String employeeName;
private String employeeDesignation;
private double salary;
// Constructor of Employee class
public Employee() {}
// Method 1
public String toString()
{
return String.format("%s - %s - %f", employeeName,
employeeDesignation, salary);
}
// method 2
// To get name of an employee
public String getEmployeeName()
{
// Return the name of the employee
return employeeName;
}
// Method - 3
// To set employee name
public void setEmployeeName(String employeeName)
{
// This keyword refer to the current
// method or constructor itself
// Hence, same employee name can be set
// through this method
this.employeeName = employeeName;
}
// Method - 4
// To get already assigned designation of
// the employee over which method is invoked
public String getEmployeeDesignation()
{
// Return the designation of the employee
// over which the function is called
return employeeDesignation;
}
// Method - 5
// To assign a designation to an employee
public void
setEmployeeDesignation(String employeeDesignation)
{
// This keyword refer to the current
// method or constructor itself
this.employeeDesignation = employeeDesignation;
}
// Method - 6
// To get salary of an employee
public double getSalary()
{
// Return the salary of the employee for which
// the function is invoked
return salary;
}
// Method - 7
// To set salary of the existing employee with
// assigned name and designation
public void setSalary(double salary)
{
this.salary = salary;
}
}
Paso 2: depende de diferentes tipos de datos como string, número (se ajusta a enteros, dobles, flotantes, etc.), booleanos, necesitamos tener un método para obtener los valores de celda de Excel
Ejemplo:
Java
// Java Program to get the cell value
// of the corresponding cells
// Method
// To get the cell value
private Object getCellValue(Cell cell)
{
// Now either do-while or switch can be used
// to display menu/user's choice
// Switch case is used here for illustration
// Switch case to get the users choice
switch (cell.getCellType()) {
// Case 1
// If cell contents are string
case Cell.CELL_TYPE_STRING:
return cell.getStringCellValue();
// Case 2
// If cell contents are Boolean
case Cell.CELL_TYPE_BOOLEAN:
return cell.getBooleanCellValue();
// Case 3
// If cell contents are Numeric which includes
// int, float , double etc
case Cell.CELL_TYPE_NUMERIC:
return cell.getNumericCellValue();
}
// Case 4
// Default case
// If cell contents are neither
// string nor Boolean nor Numeric,
// simply nothing is returned
return null;
}
Paso 3: Método para extraer el contenido del archivo de Excel. Necesitamos especificar la ubicación del archivo correctamente. de lo contrario , terminará con IOException
Ejemplo:
Java
// Java Program to get the Excel file name
// as an argument
public List<Employee>
readDataFromExcelFile(String excelFilePath)
throws IOException
{
// Creating an List object of Employee type
// Note: User defined type
List<Employee> listEmployees
= new ArrayList<Employee>();
FileInputStream inputStream
= new FileInputStream(new File(excelFilePath));
// As used 'xlsx' file is used so XSSFWorkbook will be
// used
Workbook workbook = new XSSFWorkbook(inputStream);
// Read the first sheet and if the contents are in
// different sheets specifying the correct index
Sheet firstSheet = workbook.getSheetAt(0);
// Iterators to traverse over
Iterator<Row> iterator = firstSheet.iterator();
// Condition check using hasNext() method which holds
// true till there is single element remaining in List
while (iterator.hasNext()) {
// Get a row in sheet
Row nextRow = iterator.next();
// This is for a Row's cells
Iterator<Cell> cellIterator
= nextRow.cellIterator();
// We are taking Employee as reference.
Employee emp = new Employee();
// Iterate over the cells
while (cellIterator.hasNext()) {
Cell nextCell = cellIterator.next();
// Switch case variable to
// get the columnIndex
int columnIndex = nextCell.getColumnIndex();
// Depends upon the cell contents we need to
// typecast
// Switch-case
switch (columnIndex) {
// Case 1
case 0:
// First column is alpha and hence
// it is typecasted to String
emp.setEmployeeName(
(String)getCellValue(nextCell));
// Break keyword to directly terminate
// if this case is hit
break;
// Case 2
case 1:
// Second column is alpha and hence
// it is typecasted to String
emp.setEmployeeDesignation(
(String)getCellValue(nextCell));
// Break keyword to directly terminate
// if this case is hit
break;
// Case 3
case 2:
// Third column is double value and
// hence it is typecasted to Double
emp.setSalary(
(Double)getCellValue(nextCell));
break;
// Note: If additional cells are present
// then
// they should be specified further down,
// and POJO class should accommodate those
// cell values
}
}
// Adding up to the list
listEmployees.add(emp);
}
// Closing the workbook and inputstream
// as it free up the space in memory
workbook.close();
inputStream.close();
// Return all the employees present in List
// object of Employee type
return listEmployees;
}
Paso 4: Integración de los conceptos del Paso 1 al Paso 3 en el programa Principal
Java
// Main driver method
public static void main(String[] args)
{
// Detecting the file type
GetContentFromExcelSheets getContentFromExcelSheets
= new GetContentFromExcelSheets();
// Creating an List object of Employee type
// in main() method
List<Employee> extractedEmployeeData
= new ArrayList<Employee>();
// Try block to check if any exception/s occurs
try {
// excelFileContents.xlsx location need to be
// specified correctly or else IOException will be
// thrown. If file is available in that location, it
// gets the data and stored in a list variable
extractedEmployeeData
= getContentFromExcelSheets
.readDataFromExcelFile(
"excelFileContents.xlsx");
}
// Catch block to handle the exceptions if occurred
catch (IOException e) {
// Print the line number and exception
// in the program
e.printStackTrace();
}
// As there are possibility of data in multiple cells,
// it is always a good approach to follow a POJO pattern
// and get a row value in specified POJO As all data is
// collected in a list, we can iterate and display as
// below
for (int i = 0; i < extractedEmployeeData.size(); i++) {
// Print and display the employees data to the
// console using toString() method to the user
System.out.println(
extractedEmployeeData.get(i).toString());
}
}
Salida: para nuestro ejemplo, solo tenemos 3 filas de datos
Implementación:
Ejemplo:
Java
// Java Program to Extract Content from a Excel sheet
// As we are reading the excel file, java.io package is
// compulsorily required
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
// Below imports are required to access Apache POI
// The usermodel package maps HSSF low level structures to
// familiar workbook/sheet model
// org.apache.poi.hssf.usermodel
// But we are using higher excel formats hence,
// org.apache.poi.ss.usermodel is used To determine the type
// of cell content
import org.apache.poi.ss.usermodel.Cell;
// each and every row of excel is taken and stored in this
// row format
import org.apache.poi.ss.usermodel.Row;
// excel sheet is read in this sheet format
import org.apache.poi.ss.usermodel.Sheet;
// excel Workbook is read in this Workbook format
import org.apache.poi.ss.usermodel.Workbook;
// XSSFWorkbook denotes the API is for working with Excel
// 2007 and later.
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
// POJO class having 3 fields matching with the given excel
// file
class Employee {
private String employeeName;
private String employeeDesignation;
private double salary;
// All 3 fields getter, setter methods should be there
public Employee() {}
public String toString()
{
return String.format("%s - %s - %f", employeeName,
employeeDesignation, salary);
}
public String getEmployeeName() { return employeeName; }
public void setEmployeeName(String employeeName)
{
this.employeeName = employeeName;
}
public String getEmployeeDesignation()
{
return employeeDesignation;
}
public void
setEmployeeDesignation(String employeeDesignation)
{
this.employeeDesignation = employeeDesignation;
}
public double getSalary() { return salary; }
public void setSalary(double d) { this.salary = d; }
}
// class to assign the cell value once it is getting done to
// read from excel sheet It can be String/Boolean/Numeric
public class GetContentFromExcelSheets {
private Object getCellValue(Cell cell)
{
switch (cell.getCellType()) {
case Cell.CELL_TYPE_STRING:
return cell.getStringCellValue();
case Cell.CELL_TYPE_BOOLEAN:
return cell.getBooleanCellValue();
case Cell.CELL_TYPE_NUMERIC:
return cell.getNumericCellValue();
}
return null;
}
// Read the excel sheet contents and get the contents in
// a list
public List<Employee>
readBooksFromExcelFile(String excelFilePath)
throws IOException
{
List<Employee> listEmployees
= new ArrayList<Employee>();
FileInputStream inputStream
= new FileInputStream(new File(excelFilePath));
Workbook workbook = new XSSFWorkbook(inputStream);
Sheet firstSheet = workbook.getSheetAt(0);
Iterator<Row> iterator = firstSheet.iterator();
while (iterator.hasNext()) {
Row nextRow = iterator.next();
Iterator<Cell> cellIterator
= nextRow.cellIterator();
Employee emp = new Employee();
while (cellIterator.hasNext()) {
Cell nextCell = cellIterator.next();
int columnIndex = nextCell.getColumnIndex();
switch (columnIndex) {
case 1:
emp.setEmployeeName(
(String)getCellValue(nextCell));
break;
case 2:
emp.setEmployeeDesignation(
(String)getCellValue(nextCell));
break;
case 3:
emp.setSalary(Double.valueOf(
(String)getCellValue(nextCell)));
break;
}
}
listEmployees.add(emp);
}
((FileInputStream)workbook).close();
inputStream.close();
return listEmployees;
}
// Main program
public static void main(String[] args)
{
// detecting the file type
GetContentFromExcelSheets getContentFromExcelSheets
= new GetContentFromExcelSheets();
List<Employee> extractedEmployeeData
= new ArrayList<Employee>();
try {
extractedEmployeeData
= getContentFromExcelSheets
.readBooksFromExcelFile(
"excelFileContents.xlsx");
}
catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(extractedEmployeeData);
}
}
Conclusión: Apache POI proporciona una mejor implementación para extraer el contenido de los archivos de Excel. En la codificación, de acuerdo con la disponibilidad de datos en el número de celdas, necesitamos tener atributos de clase POJO y también necesitamos especificar datos de coll en el método » readDataFromExcelFile» . También podemos formatear datos dobles según nuestros requisitos.
Publicación traducida automáticamente
Artículo escrito por priyarajtt y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA