Saludos estimados programadores.
Supongo que alguna vez en el trabajo o durante el desarrollo de algún proyecto se han visto en la necesidad de abrir y obtener el contenido de un archivo de excel.
Si buscas una solución para desarrollar en java, te sugiero la herramienta Apache POI, que puedes descargar en http://poi.apache.org/trans/es/index.html
El archivo que se va a descargar es un archivo zip con varios archivos. Para el ejemplo solo necesitamos poi-3.0.1-FINAL-20070705.jar, 20070705 supongo yo que es la fecha en que fue liberada dicha version y supongo que quizás cuando descargues pueda tener otro número, incluso otro número de versión.
Una vez extraído el archivo e incluido en el classpath, procedemos a crear una clase para leer los archivos de excel:
import java.io.FileInputStream;
import java.util.Iterator;
import java.util.Vector;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
/**
* Clase para leer los archivos de excel
*/
public class XLSOpener {
/**
* Este objeto de la clase HSSFWorkbook contiene todas las hojas o
* pestañas de un archivo xls
*/
private HSSFWorkbook wb;
/**
* Crea una instancia de XLSOpener con una ruta a un archivo xls
* Específico. Yo recomiendo que al momento de crear este objeto
* Utilicen un JFileChooser para elegir el archivo de excel.
*/
public XLSOpener(String file) throws Exception {
/*
* Esto crea un objeto que lee los bytes del archivo
* pero en si no lo divide en hojas, filas y celdas.
*/
FileInputStream input = new FileInputStream(file);
POIFSFileSystem fs = new POIFSFileSystem(input);
/*
* Una vez creado el workbook tenemos acceso a las hojas (pestañas)
* incluidas en el archivo de excel
this.wb = new HSSFWorkbook(fs);
}
/**
* Esta función se encarga de leer la hoja o pestaña elegida
* Para este tutorial nos referimos a un número especifico
* según el órden en que aparecen las pestañas, si un archivo
* xls solo cuenta con una hoja, para referirse a esa hoja
* utilizamos el primer índice que sería el cero.
*
* En este tutorial, por el ejemplo que cargamos el archivo de
* Excel en un JTable, la función devuelve un vector de vectores
* Pero ya dependerá del uso en su aplicación lo que harán con la
* Información extraida de los archivos.
*/
public Vector<Vector<String>> getBook(int sheetInt) {
/* Aqui recopilamos todas las filas leidas en la hoja */
Vector<Vector<String>> sheetVector = new Vector();
/* Obtenemos la hoja o pestaña elegida */
HSSFSheet sheet = wb.getSheetAt(sheetInt);
/* Para recorrer las filas utilizamos el Iterador de filas "rows" */
Iterator<HSSFrow< rows = sheet.rowIterator();
/* Hay que verificar si hay alguna otra fila que leer */
while (rows.hasNext()) {
/*
* Es por que si hay otra fila que leer que obtenemos
* la fila que sigue
*/
HSSFRow row = rows.next();
/* Aqui se colocan todos los valores almacenados en dicha fila.
Vector<String> rowVector = new Vector();
/*
* Para recorrer uno a uno las celdas disponibles
* creamos un iterador de celdas
*/
Iterator<HSSFCell> cells = row.cellIterator();
/* Se verifica que la fila tenga más celdas que recorrer */
while (cells.hasNext()) {
/* Como si hubieron más celdas pedimos la siguiente */
HSSFCell cell = cells.next();
/* Ya que hemos obtenido la celda evaluamos de que tipo es. */
switch (cell.getCellType()) {
/*
* La celda contiene texto (pueden ser nombres, direcciones
* ya sabes, lo que encuentra uno en un excel hoy en día
* en formato de xD
*/
case HSSFCell.CELL_TYPE_STRING:
rowVector.add(
cell.getRichStringCellValue().getString());
break;
/*
* El caso de que la celda contenga un valor númerico
*/
case HSSFCell.CELL_TYPE_NUMERIC:
rowVector.add(String.valueOf(
cell.getNumericCellValue()));
break;
/*
* Hace poco no consideré este caso pero cabe mensionar que se
* trabaja igual que como se trabaja con números y este caso es
* el de una celda que contenga una fórmula.
*/
case HSSFCell.CELL_TYPE_FORMULA:
rowVector.add(String.valueOf(
cell.getNumericCellValue()));
break;
/* En este caso para este tutorial no guardamos nada */
default:
rowVector.add("");
}
}
/*
* Una vez leidas las celdas, el vector de la fila es agregado
* al vector de vectores
*/
sheetVector.add(rowVector);
}
/* Se devuevlen los datos leidos en un vector de vectores. */
return sheetVector;
}
}
Para poder utilizar esta clase he creado una pequeña interfaz gráfica que pueden copiar para probar la clase.
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Vector;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.table.DefaultTableModel;
/**
*
* @author jmnovelov
*/
public class Main extends JFrame {
private JPanel north;
private JLabel lblFile;
private JTextField txtFile;
private JButton cmdOpenFile;
private JScrollPane scpData;
private JTable tblData;
/** Creates a new instance of Main */
public Main() {
initComponents();
}
private void initComponents() {
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setPreferredSize(new Dimension(500, 400));
this.setLayout(new BorderLayout());
tblData = new JTable();
tblData.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scpData = new JScrollPane();
scpData.setViewportView(tblData);
this.getContentPane().add(scpData, BorderLayout.CENTER);
north = new JPanel();
north.setLayout(new FlowLayout());
lblFile = new JLabel("Archivo: ");
north.add(lblFile);
txtFile = new JTextField();
txtFile.setColumns(25);
north.add(txtFile);
cmdOpenFile = new JButton("Abrir");
cmdOpenFile.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent actionEvent) {
cmdOpenFileActionPerformed(actionEvent);
}
});
north.add(cmdOpenFile);
this.getContentPane().add(north, BorderLayout.NORTH);
this.setTitle("Prueba de Apache POI");
this.pack();
this.setVisible(true);
}
private void cmdOpenFileActionPerformed(ActionEvent evt) {
/** Aqui se muestra como es elegido el archivo */
JFileChooser chooser = new JFileChooser();
int option = chooser.showOpenDialog(this);
if (option == JFileChooser.APPROVE_OPTION) {
txtFile.setText(chooser.getSelectedFile().getAbsolutePath());
XLSOpener xlsFile;
try {
/** Es creado el objeto para leer */
xlsFile = new XLSOpener(txtFile.getText());
} catch (Exception ex) {
ex.printStackTrace();
return;
}
/* Leo la hoja o pestaña cero */
Vector<Vector<String>> sheetVector = xlsFile.getBook(0);
if (sheetVector.size() > 0) {
int cols = sheetVector.get(0).size();
Vector headers = new Vector();
for (int i = 0; i < cols; i++) {
headers.add(i + 1);
}
/** Inserto lo leido en una tabla */
DefaultTableModel model = new DefaultTableModel(
sheetVector, headers);
tblData.setModel(model);
} else {
JOptionPane.showMessageDialog(this, "No hay filas escritas");
}
}
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Thread main = new Thread() {
public void run() {
new Main();
}
};
main.start();
}
}
Espero este mini tutorial les pueda ser realmente de utilidad.
Entradas
