exportar e importar a excel desde java

Para trabajar con excel vamos a hacerlo con elformato csv , este formato es super simple de utilizar

Para bajar el jar que vamos añadir a nuestro proyectolo vamos a buscar aqui:

http://www.csvreader.com/java_csv.php

asi se guarda y es el formato con el cual tenemos que guardarnuestro archivo

El siguiente ejemplo vamos a guardar un archivocsv en un Arraylist el cual guarda objetos de la clase

libro( con sus get y set de atrivutos privados)

//////// clase libro /////////////////

public class libro_ingresado {

private String nombre;private String autor;

private String edicion;private String anio;

private String codigo;private String area;

/** Creates a new instance of libro_ingresado */public libro_ingresado() {

}

public String getNombre() {return nombre;

}

public void setNombre(String nombre) {this.nombre = nombre;

}

public String getAutor() {return autor;

}

public void setAutor(String autor) {this.autor = autor;

}

public String getEdicion() {return edicion;

}

public void setEdicion(String edicion) {this.edicion = edicion;

}

public String getAnio() {return anio;

}

public void setAnio(String anio) {this.anio = anio;

}

public String getCodigo() {return codigo;

}

public void setCodigo(String codigo) {this.codigo = codigo;

}

public String getArea() {return area;

}

public void setArea(String area) {

this.area = area;}

}

/////// clase de manejo de csv //////////

import com.csvreader.CsvReader;import java.io.FileNotFoundException;

import java.io.IOException;import java.util.ArrayList;import java.util.Iterator;

import javax.swing.JOptionPane;

public class leer_archivo {

public ArrayList leer_archivo_exel(String archivo){

ArrayList lista_libros = new ArrayList();

CsvReader reader = null;

try {

reader = new CsvReader(archivo,';');

} catch (FileNotFoundException ex) {ex.printStackTrace();

JOptionPane.showInputDialog("en leer archivo");}

try {

reader.readHeaders();

} catch (IOException ex) {ex.printStackTrace();

}

try {

libro_ingresado libr;

while (reader.readRecord()){

libr=new libro_ingresado();libr.setNombre(reader.get("nombre"));

libr.setAutor(reader.get("autor"));libr.setEdicion(reader.get("edicion"));

libr.setAnio(reader.get("anio"));libr.setCodigo(reader.get("codigo"));

libr.setArea(reader.get("area")); lista_libros.add(libr); // añadimos el objeto al arrayList

}

} catch (IOException ex) {ex.printStackTrace();

System.err.println(" en while readrecord ");}

reader.close();

return lista_libros; // retorna una objeto de ArrayList

}

}

////////////////////////////////////////////////////////

el siquiente codigo es abrir un JFileChooser donde buscamosnuestro archivo csv , luego lo seleccionamos y es procesado.

el archivo es pasado a un jtable

////////////////// codigo evento boton ///////////////

DefaultTableModel dtm;ArrayList libro_recivido=new ArrayList();

JFileChooser fileChooser = new JFileChooser(".");int status = fileChooser.showOpenDialog(null); //fileChooser

if (status == JFileChooser.APPROVE_OPTION) {

File selectedFile =fileChooser.getSelectedFile();

leer_archivo l=new leer_archivo();String direccion=selectedFile.getParent()+"/"+selectedFile.getName();

libro_recivido=l.leer_archivo_exel(direccion);Iterator it=libro_recivido.iterator();

try{

Object datos[] = new Object [6];dtm = (DefaultTableModel) jTable1.getModel();for (int i = jTable1.getRowCount() - 1; i>=0; i--)

{dtm.removeRow(i);

}

while(it.hasNext()){

libro_ingresado lib_ing;lib_ing=(libro_ingresado) it.next();

datos[0]=lib_ing.getNombre();datos[1]=lib_ing.getAutor();

datos[2]=lib_ing.getEdicion();datos[3]=lib_ing.getAnio();

datos[4]=lib_ing.getCodigo();datos[5]=lib_ing.getArea();

dtm.addRow(datos);}

} catch(Exception e){//manejo de error

}

} else if (status == JFileChooser.CANCEL_OPTION) {

System.out.println("cancele");

}

//////////////////////////////////////////////////

como fin un link de interes

Crear archivo Excel desde Java con POI

De ChuWiki

Saltar a navegación, buscar

En este ejemplo vamos a crear una hoja Excel desde Java usando la librería POI. Para ello, lo primero es descargarse la librería POI desde su página de descargas http://www.apache.org/dyn/closer.cgi/poi/

Una vez descargada y desempaquetada, tendremos una serie de jars que deberemos añadir a nuestro proyecto Java o a nuestro CLASSPATH. En el momento de escribir este ejemplo, los jar obtenidos eran

poi-3.0.2-FINAL-20080204.jar poi-scratchpad-3.0.2-FINAL-20080204.jar poi-contrib-3.0.2-FINAL-20080204.jar

Estando todo preparado, ya podemos escribir nuestro programa Java. Lo primero de todo, es crear lo que en Excel se conoce como un libro de trabajo (workbook). Este será nuestro "Excel".

HSSFWorkbook libro = new HSSFWorkbook();

Un libro de trabajo tiene hojas, así que debermos añadir al menos una hoja

HSSFSheet hoja = libro.createSheet();

A la hoja debemos añadirle las filas que deseemos. Para nuestro ejemplo, nos bastará con una. La numeración empieza en cero.

HSSFRow fila = hoja.createRow(0);

Finalemente, a la fila debemos añadirle la celda/columna que queramos usar. Nuevamente, el índice empieza en cero, pero esta vez admite short y no int.

HSSFCell celda = fila.createCell((short)0);

Una vez que tenemos la celda, ya sólo nos resta escribir en ella lo que queramos: una fórmula, un número, un booleano, un texto, etc. Para ello usaremos los métodos de la celda HSSFCell. En nuestro caso y por se el más complejo, lo haremos para un String. El método setCellValue(String) está obsoleto, así que usaremos el método setCellValue(HSSFRichTextString), que vale para lo mismo pero admite un "texto rico", es decir, con distintas fuentes.

HSSFRichTextString texto = new HSSFRichTextString("hola mundo");celda.setCellValue(texto);

Listo, ya tenemos una hoja de Excel muy sencilla con un "hola mundo" en la primera celda de la tabla. Sólo nos queda grabar el fichero. Para ello, usamos el método write() del HSSFWorkbook

try { FileOutputStream elFichero = new FileOutputStream("holamundo.xls");

libro.write(elFichero); elFichero.close();} catch (Exception e) { e.printStackTrace();}

Y ahora el código completo para este ejemplo de Excel con Java y POI

package com.chuidiang.ejemplos.poi_excel;

import java.io.FileOutputStream;

import org.apache.poi.hssf.usermodel.HSSFCell;import org.apache.poi.hssf.usermodel.HSSFRichTextString;import org.apache.poi.hssf.usermodel.HSSFRow;import org.apache.poi.hssf.usermodel.HSSFSheet;import org.apache.poi.hssf.usermodel.HSSFWorkbook;

/** * Ejemplo sencillo de cómo crear una hoja Excel con POI * * @author chuidiang * */public class EjemploCrearExcel {

/** * Crea una hoja Excel y la guarda. * * @param args */ public static void main(String[] args) { // Se crea el libro HSSFWorkbook libro = new HSSFWorkbook();

// Se crea una hoja dentro del libro HSSFSheet hoja = libro.createSheet();

// Se crea una fila dentro de la hoja HSSFRow fila = hoja.createRow(0);

// Se crea una celda dentro de la fila HSSFCell celda = fila.createCell((short) 0);

// Se crea el contenido de la celda y se mete en ella. HSSFRichTextString texto = new HSSFRichTextString("hola mundo"); celda.setCellValue(texto);

// Se salva el libro. try { FileOutputStream elFichero = new FileOutputStream("holamundo.xls"); libro.write(elFichero); elFichero.close(); } catch (Exception e) { e.printStackTrace();

} }}

Gráficas con rangos variables HSSF - POI

Recientemente comence a utilizar Apache POI para crear archivos de Excel desde Java y me encontre con un problema que podría calificar de trivial pero que me quito algo de tiempo.

Supongamos que queremos crear una gráfica que muestre los valores anuales desde una fecha determinada hasta el día de hoy. La solución puede sonar simple: creamos una gráfica en un archivo y listo, posteriormente escribimos los valores mediante POI en otro archivo tomando como base el primero. Cuando el número de años entre la fecha actual y la de inicio cambia (el tiempo pasa) el problema deja de ser trivial.

La principal razón por la que esto sucede es por el simple hecho de que POI no incluye soporte para gráficas, entonces, no es posible crearla o alterarla de manera directa. La solución que yo encontre es un poco rebuscada pero funciona.

1. Crear el archivo con la gráfica en Excel con datos de muestra.

2. Crear un rango nombrado que cuente el numero de valores que pueden cubrir nuestros datos.

1. En el menú Insert > Name > Define...

2. En la parte inferior crear una formula para seleccionar el rango:

=OFFSET(Hoja!$B$1, 1, 0, COUNTA(Hoja!$B:$B) - 1, 1)

OFFSET selecciona un rango a partir de la celda pasada como primer parametro con el numero de filas indicado (el primer uno), el numero de columnas (el cero), y un alto igual al tercer parametro con un ancho del cuarto parametro.

COUNTA cuenta las celdas no vacias de el rango pasado como parámetro.

3. Crear la gráfica hasta el paso donde se seleccionan los datos de origen.

4. Una vez en este paso dar clic en la pestaña de series

5. Dentro de la pestaña series cambiar el valor de valores y etiquetas por los nombres definidos previamente

6. Ahora pueden agregarse datos en la fila por debajo de la ultima con datos y estos se agregaran a la gráfica.

7. El resto es sencillo con POI

Una libreria a la que le encontre mucho uso, y me saco de apuro en innumerables ocasiones es Jakarta POI .

Una API de Jakarta destinada al manejo de archivos Excels. Muy sencilla de utilizar, con mucha potencia, permite crear un nuevo archivo, leer uno ya existente, no solo crear hojas de calculo con datos sino con formulas, formato, graficos en ella.

Vean la guia rapida para ver lo sencillo que es utilizar este libreria.

import java.io.*;import java.util.*;import java.awt.*;import java.awt.event.*;import javax.swing.*;import javax.swing.table.*;import javax.swing.border.*;import javax.swing.event.*;

import org.apache.poi.hssf.usermodel.*;import org.apache.poi.hssf.record.*;import org.apache.poi.hssf.model.*;import org.apache.poi.hssf.util.*;import org.apache.poi.hssf.usermodel.HSSFCellStyle;

public class EjemploPOI extends JFrame {

public EjemploPOI() { setTitle("Ejemplo"); JPanel panel = new JPanel(new BorderLayout()); panel.add(getPanelBotones(),BorderLayout.NORTH); panel.add(getPanelTabla(),BorderLayout.CENTER); setContentPane(panel); setVisible(true); pack(); } private JTable tabla; private DefaultTableModel model; /* * Construye el panel con la tabla de datos */ private JScrollPane getPanelTabla() { String[] columnas = { "Mes","Cantidad" }; Object[][] datos = { { "Enero","10" }, { "Febrero","23" }, { "Marzo","14" }, { "Abril","26" } };

model = new DefaultTableModel(datos,columnas); tabla = new JTable(model); JScrollPane scrol = new JScrollPane(tabla); return scrol; } /* * Construye el panel con el boton */ private JPanel getPanelBotones() { JButton btnExportar = new JButton("Exportar"); ExportarListener listener = new ExportarListener(); btnExportar.addActionListener(listener); JPanel panel = new JPanel(new FlowLayout()); panel.add(btnExportar); return panel; } public static void main(String[] args) { EjemploPOI frame = new EjemploPOI(); }

public class ExportarListener implements ActionListener { public void actionPerformed(ActionEvent e) { int rows = model.getRowCount(); int columnas = model.getColumnCount(); //Creamos el libro HSSFWorkbook wb = new HSSFWorkbook(); //Creamos la hoja de calculo, con el nombre "Archivo" HSSFSheet sheet1 = wb.createSheet("Archivo");

for(int i=0;i< rows;i++) { //Se crea la fila dentro de la hoja de calculo HSSFRow row = sheet1.createRow((short)(i+1)); for(int j=0;j < columnas;j++) { //Se recupera el valor de la tabla String dato = model.getValueAt(i,j).toString();

//Se crea la celda dentro de la fila HSSFCell celda = row.createCell((short) j); //Asignamos el valor a la celda celda.setCellValue(dato); } }

try { FileOutputStream fileOut = new FileOutputStream("ejemplo.xls"); wb.write(fileOut); fileOut.close(); JOptionPane.showMessageDialog(new JFrame(),"Se exporto con exito", "Completo",JOptionPane.INFORMATION_MESSAGE); } catch(IOException e1) { System.err.println("Se produjo un error"); System.err.println(e1.getMessage()); } } } }

Ejemplo Jakarta POIsgoliver Comments Off

En esta página se muestra un programa java completo como ejemplo de uso de la librería Jakarta POI. Puedes encontrar mucha más información sobre esta librería en el artículo original que contiene este ejemplo.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Date;

 

import org.apache.poi.hssf.usermodel.HSSFCell;

import org.apache.poi.hssf.usermodel.HSSFCellStyle;

import org.apache.poi.hssf.usermodel.HSSFDataFormat;

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;

 

public class DemoPOI

{

    public static void main(String[] args)

    {

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

        escribirExcel();

 

        leerExcel();

 

        System.out.println("Ejemplo Finalizado.");

    }

 

    public static void escribirExcel()

    {

        try

        {

            //Se crea el libro Excel

            HSSFWorkbook wb = new HSSFWorkbook();

 

            //Se crea una nueva hoja dentro del libro

            HSSFSheet sheet = wb.createSheet("HojaEjemplo");

 

            //Se crea una fila dentro de la hoja

            HSSFRow row = sheet.createRow((short)0);

 

            //Creamos celdas de varios tipos

            row.createCell((short)0).setCellValue(1);

            row.createCell((short)1).setCellValue(1.2);

            row.createCell((short)2).setCellValue("ejemplo");

            row.createCell((short)3).setCellValue(true);

 

            //Creamos una celda de tipo fecha y la mostramos

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

            //indicando un patrón de formato

            HSSFCellStyle cellStyle = wb.createCellStyle();

            cellStyle.setDataFormat(

                    HSSFDataFormat.getBuiltinFormat("d/m/yy h:mm"));

 

            HSSFCell cell = row.createCell((short)4);

            cell.setCellValue(new Date());

            cell.setCellStyle(cellStyle);

 

            //Escribimos los resultados a un fichero Excel

            FileOutputStream fileOut =

                new FileOutputStream("ejemplo.xls");

 

            wb.write(fileOut);

            fileOut.close();

        }

        catch(IOException e)

        {

            System.out.println("Error al escribir el fichero.");

        }

    }

 

    public static void leerExcel()

    {

        try

        {

            //Se abre el fichero Excel

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

            POIFSFileSystem fs =

                    new POIFSFileSystem(

                            new FileInputStream("c:ejemplo.xls"));

 

            //Se obtiene el libro Excel

            HSSFWorkbook wb = new HSSFWorkbook(fs);

 

            //Se obtiene la primera hoja

            HSSFSheet sheet = wb.getSheetAt(0);

 

            //Se obtiene la primera fila de la hoja

            HSSFRow row = sheet.getRow(0);

 

            //Se leen las primeras 5 celdas

            for(int i=0; i<5; i++)

            {

                //Se obtiene la celda i-esima

                HSSFCell cell = row.getCell((short)i);

 

                //Si la celda leida no está vacía

                if (cell != null)

                {

                    //Se imprime en pantalla la celda según su tipo

                    switch(cell.getCellType())

                    {

                        case HSSFCell.CELL_TYPE_NUMERIC:

                            System.out.println("Número: " +

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

11

cell.getNumericCellValue());

                            break;

                        case HSSFCell.CELL_TYPE_STRING:

                            System.out.println("String: " + cell.getStringCellValue());

                            break;

                        case HSSFCell.CELL_TYPE_BOOLEAN:

                            System.out.println("Boolean: " + cell.getBooleanCellValue());

                            break;

                        default:

                            System.out.println("Default: " + cell.getDateCellValue());

                            break;

                    }

                }

            }

        }

        catch(IOException ex)

        {

            System.out.println("Error al leer el fichero.");

        }

    }

}

0

111

112

113

114

115

116

117

118

Cómo generar Hojas de Excel en una aplicación JAVA usando Apache POIoctubre 22, 2007 apiconz Deja un comentario Ir a los comentarios

El presente tutorial espero les sirva como referencia para el uso de la librería POI. Si tienen alguna observación y/o corrección deseo que me la hagan llegar.

Al principio, descargas los jars correspondientes a la última versión desde la web de Apache POI (http://poi.apache.org/)

Copias los jars en la carpeta de librerías (WEB-INF/lib).

Es importante tener en cuenta que cada archivo de Excel representa un LIBRO, dentro de cada libro tenemos HOJAS, dentro de cada HOJA tenemos FILAS, y, finalmente, en cada FILA tenemos CELDAS. Hago mención de esto porque nos ayudará a ver cómo se organiza la información en el archivo.

Primero, necesitamos crear un LIBRO haciendo uso de la blasé HSSFWorkbook:

// Proceso la información y genero el xls.

HSSFWorkbook objWB = new HSSFWorkbook();

… a continuación, creamos la hoja con la clase HSSFSheet

// Creo la hoja

HSSFSheet hoja1 = objWB.createSheet("hoja 1");

… luego, creamos la fila con HSSFRow

// creo la fila.HSSFRow fila = hoja1.createRow((short)1);

Notemos que el valor que se envía al método encargado de crear las filas es de tipo short, el mismo que indica el número correspondiente a la fila que hemos de trabajar. El índice de las filas empieza en “0″, aunque ello no nos impide trabajar directamente con otras filas.

Una vez creada la fila, empezamos a trabajar con las celdas.

// Aunque no es necesario podemos establecer estilos a las celdas.// Primero, establecemos el tipo de fuenteHSSFFont fuente = objLibro.createFont();fuente.setFontHeightInPoints((short)11);fuente.setFontName(fuente.FONT_ARIAL);fuente.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);

// Luego creamos el objeto que se encargará de aplicar el estilo a la celdaHSSFCellStyle estiloCelda = objLibro.createCellStyle();estiloCelda.setWrapText(true);estiloCelda.setAlignment(HSSFCellStyle. ALIGN_JUSTIFY);estiloCelda.setVerticalAlignment(HSSFCellStyle.VERTICAL_TOP);estiloCelda.setFont(fuente);

// También, podemos establecer bordes...estiloCelda.setBorderBottom(HSSFCellStyle.BORDER_MEDIUM);estiloCelda.setBottomBorderColor((short)8);estiloCelda.setBorderLeft(HSSFCellStyle.BORDER_MEDIUM);estiloCelda.setLeftBorderColor((short)8);estiloCelda.setBorderRight(HSSFCellStyle.BORDER_MEDIUM);estiloCelda.setRightBorderColor((short)8);estiloCelda.setBorderTop(HSSFCellStyle.BORDER_MEDIUM);estiloCelda.setTopBorderColor((short)8);

// Establecemos el tipo de sombreado de nuestra celdaestiloCelda.setFillForegroundColor((short)22);estiloCelda.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);

// Creamos la celda, aplicamos el estilo y definimos// el tipo de dato que contendrá la celdaHSSFCell celda = objFila.createCell((short)0);celda.setCellStyle(estiloCelda);celda.setCellType(HSSFCell.CELL_TYPE_STRING);

// Finalmente, establecemos el valorcelda.setCellValue("Un valor");

Como podemos apreciar en el código tenemos la posibilidad de establecer estilos mediante las clases HSSFFont y HSSFCellStyle.

La primera, nos permite establecer el tipo de fuente que se empleará para la celda que hemos de utilizar. Para ello, contamos con los métodos setPointHeightInPoints que recibe un valor de tipo short que representa el tamaño de la fuente; el método setFontName el

mismo que recibe una constante de la misma clase que nos permite establecer la fuente que se ha de emplear, y, otros métodos como: setBoldweight y setUnderline, entre otros, que nos permitirán aplicarle otros estilos y efectos al valor que ocupe nuestra celda.

La segunda, es la clase que, finalmente, nos ayudará a aplicar el estilo a la celda. Podemos acomodar y alinear el texto mediante los métodos setWrapText, setAlignment y setVerticalAlignment; aplicar la fuente trabajada, con el método setFont; configurar los bordes mediante los métodos: setBorderBottom, setBorderLeft, setBorderRight, setBorderTop, para el tipo; y, setBottomBorderColor, setLeftBorderColor, setRightBorderColor, setTopBorderColor para establecer el color de los bordes; y, establecer el sombreado de las celdas mediante los métodos setFillForegroundColor, setFillBackgroundColor y setFillPattern .

Aunque, es un poco ‘engorroso’ andar trabajando estos estilos, celda por celda, de esta forma, lo mejor es encapsular todo este proceso en métodos que nos permitan ahorrar líneas de código, preestableciendo, los estilos que se emplearán.

Según la versión de la librería que se esté empleando, podremos contar o no, con algunas constantes para la configuración del color y el establecimiento de los sombreados. Por ello adjunto información respecto a los colores en el anexo A y respecto a los sombreados en el Anexo B, al final del documento.

Finalmente, volcamos nuestro libro a un archivo de la siguiente forma:

// Volcamos la información a un archivo.String strNombreArchivo = "C:/libro1.xls";File objFile = new File(strNombreArchivo);FileOutputStream archivoSalida = new FileOutputStream(objFile);objWB.write(archivoSalida);archivoSalida.close();

A continuación les presento el código completo..

// Proceso la información y genero el xlsHSSFWorkbook objWB = new HSSFWorkbook();

// Creo la hojaHSSFSheet hoja1 = objWB.createSheet("hoja 1");

// Proceso la información y genero el xls.HSSFRow fila = hoja1.createRow((short)1);

// Aunque no es necesario podemos establecer estilos a las celdas.// Primero, establecemos el tipo de fuenteHSSFFont fuente = objLibro.createFont();fuente.setFontHeightInPoints((short)11);fuente.setFontName(fuente.FONT_ARIAL);fuente.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);

// Luego creamos el objeto que se encargará de aplicar el estilo a la celda

HSSFCellStyle estiloCelda = objLibro.createCellStyle();estiloCelda.setWrapText(true);estiloCelda.setAlignment(HSSFCellStyle. ALIGN_JUSTIFY);estiloCelda.setVerticalAlignment(HSSFCellStyle.VERTICAL_TOP);estiloCelda.setFont(fuente);

// También, podemos establecer bordes...estiloCelda.setBorderBottom(HSSFCellStyle.BORDER_MEDIUM);estiloCelda.setBottomBorderColor((short)8);estiloCelda.setBorderLeft(HSSFCellStyle.BORDER_MEDIUM);estiloCelda.setLeftBorderColor((short)8);estiloCelda.setBorderRight(HSSFCellStyle.BORDER_MEDIUM);estiloCelda.setRightBorderColor((short)8);estiloCelda.setBorderTop(HSSFCellStyle.BORDER_MEDIUM);estiloCelda.setTopBorderColor((short)8);

// Establecemos el tipo de sombreado de nuestra celdaestiloCelda.setFillForegroundColor((short)22);estiloCelda.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);

// Creamos la celda, aplicamos el estilo y definimos// el tipo de dato que contendrá la celdaHSSFCell celda = objFila.createCell((short)0);celda.setCellStyle(estiloCelda);celda.setCellType(HSSFCell.CELL_TYPE_STRING);

// Finalmente, establecemos el valorcelda.setCellValue("Un valor");

// Volcamos la información a un archivo.String strNombreArchivo = "C:/libro1.xls";File objFile = new File(strNombreArchivo);FileOutputStream archivoSalida = new FileOutputStream(objFile);objWB.write(archivoSalida);archivoSalida.close();

Aunque el ejemplo es un tanto simplón, todo lo presentado aquí generalmente se combina con arreglos de beans y bucles, los cuales, nos ayudarán a presentar más datos en nuestras hojas de Excel.

El objetivo de este tutorial no es mostrar todas las opciones disponibles, sino solo presentar un pequeño caso práctico sobre el uso de HSSF (POI) para la generación de archivos en formato Excel.

Deseo mencionar que para la creación del presente tutorial me basé en la documentación de la página de Apache POI así como también al contenido de la página JAVA DRIVE (en japonés).