exportar e importar a excel desde java

Para trabajar con excel vamos a hacerlo con el

formato csv , este formato es super simple de utilizar
Para bajar el jar que vamos aadir a nuestro proyecto
lo vamos a buscar aqui:
http://www.csvreader.com/java_csv.php
asi se guarda y es el formato con el cual tenemos que guardar
nuestro archivo

El siguiente ejemplo vamos a guardar un archivo

csv 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); // aadimos 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 buscamos
nuestro 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 navegacin, buscar

En este ejemplo vamos a crear una hoja Excel desde Java usando la librera POI. Para
ello, lo primero es descargarse la librera POI desde su pgina de descargas
http://www.apache.org/dyn/closer.cgi/poi/
Una vez descargada y desempaquetada, tendremos una serie de jars que deberemos aadir 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 aadir al menos una hoja
HSSFSheet hoja = libro.createSheet();

A la hoja debemos aadirle las filas que deseemos. Para nuestro ejemplo, nos bastar con
una. La numeracin empieza en cero.
HSSFRow fila = hoja.createRow(0);

Finalemente, a la fila debemos aadirle 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 slo nos resta escribir en ella lo que queramos: una
frmula, un nmero, un booleano, un texto, etc. Para ello usaremos los mtodos de la celda
HSSFCell. En nuestro caso y por se el ms complejo, lo haremos para un String. El mtodo
setCellValue(String) est obsoleto, as que usaremos el mtodo

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. Slo nos queda grabar el fichero. Para ello, usamos el mtodo write() del
HSSFWorkbook
try {
FileOutputStream elFichero = new FileOutputStream("holamundo.xls");
libro.write(elFichero);
elFichero.close();
} catch (Exception e) {
e.printStackTrace();
}

Y ahora el cdigo completo para este ejemplo de Excel con Java y POI
package com.chuidiang.ejemplos.poi_excel;
import java.io.FileOutputStream;
import
import
import
import
import

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

/**
* Ejemplo sencillo de cmo 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();
}
}
}

Grficas 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 podra calificar de trivial pero que me quito algo de
tiempo.
Supongamos que queremos crear una grfica que muestre los valores anuales desde una
fecha determinada hasta el da de hoy. La solucin puede sonar simple: creamos una
grfica en un archivo y listo, posteriormente escribimos los valores mediante POI en otro
archivo tomando como base el primero. Cuando el nmero de aos entre la fecha actual y
la de inicio cambia (el tiempo pasa) el problema deja de ser trivial.
La principal razn por la que esto sucede es por el simple hecho de que POI no incluye
soporte para grficas, entonces, no es posible crearla o alterarla de manera directa. La
solucin que yo encontre es un poco rebuscada pero funciona.

1. Crear el archivo con la grfica 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 parmetro.

3. Crear la grfica hasta el paso donde se seleccionan los datos de origen.

4. Una vez en este paso dar clic en la pestaa de series

5. Dentro de la pestaa 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 grfica.

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
import
import
import
import
import
import
import

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

import
import
import
import
import

org.apache.poi.hssf.usermodel.*;
org.apache.poi.hssf.record.*;
org.apache.poi.hssf.model.*;
org.apache.poi.hssf.util.*;
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 POI

sgoliver Comments Of

En esta pgina se muestra un programa java completo como ejemplo de uso de la librera
Jakarta POI. Puedes encontrar mucha ms informacin sobre esta librera en el artculo
original que contiene este ejemplo.
1 import java.io.FileInputStream;
2 import java.io.FileOutputStream;
3 import java.io.IOException;
4

import java.util.Date;

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

6 import org.apache.poi.hssf.usermodel.HSSFCellStyle;
7 import org.apache.poi.hssf.usermodel.HSSFDataFormat;
8 import org.apache.poi.hssf.usermodel.HSSFRow;
9
10
11

import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

12
13
14
15

public class DemoPOI

{
public static void main(String[] args)
{

16

escribirExcel();

17
18

leerExcel();

19
20
21

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

22
23

public static void escribirExcel()

24

25

try

26

27

//Se crea el libro Excel

28

HSSFWorkbook wb = new HSSFWorkbook();

29
30
31

//Se crea una nueva hoja dentro del libro

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

32
33

//Se crea una fila dentro de la hoja

34

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

35
36

//Creamos celdas de varios tipos

37

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

38

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

39

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

40
41

//Creamos una celda de tipo fecha y la mostramos

42

//indicando un patrn de formato

43

HSSFCellStyle cellStyle = wb.createCellStyle();

44

cellStyle.setDataFormat(

45

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

46
47

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

48

cell.setCellValue(new Date());

49

cell.setCellStyle(cellStyle);

50
51

//Escribimos los resultados a un fichero Excel

52

FileOutputStream fileOut =
new FileOutputStream("ejemplo.xls");

53
54
55

wb.write(fileOut);

56

fileOut.close();

57

58

catch(IOException e)

59

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

60
}

61
62

63
64
65
66
67
68

public static void leerExcel()

{
try
{
//Se abre el fichero Excel
POIFSFileSystem fs =

69

new POIFSFileSystem(

70

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

71
72

//Se obtiene el libro Excel

73

HSSFWorkbook wb = new HSSFWorkbook(fs);

74
75

//Se obtiene la primera hoja

76

HSSFSheet sheet = wb.getSheetAt(0);

77
78

//Se obtiene la primera fila de la hoja

79

HSSFRow row = sheet.getRow(0);

80
81
82
83

//Se leen las primeras 5 celdas

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

84

//Se obtiene la celda i-esima

85

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

86
87

//Si la celda leida no est vaca

88

if (cell != null)
{

89

//Se imprime en pantalla la celda segn su tipo

90

switch(cell.getCellType())

91

92

case HSSFCell.CELL_TYPE_NUMERIC:

93

System.out.println("Nmero: " +

94 cell.getNumericCellValue());
break;

95

case HSSFCell.CELL_TYPE_STRING:

96
97

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

98

break;

99

case HSSFCell.CELL_TYPE_BOOLEAN:

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

10
1

default:

10
2 cell.getDateCellValue());
10
3

break;
}

10
4
10
5
10

System.out.println("Default: " +

}
}
}

6
10
7
10
8
10
9
11
0
catch(IOException ex)

11
1

11
2

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

}

11
3
11
4
11
5
11
6
11
7
11
8

}
}

Cmo generar Hojas de Excel en una aplicacin JAVA

usando Apache POI
octubre 22, 2007 apiconz Deja un comentario Ir a los comentarios

El presente tutorial espero les sirva como referencia para el uso de la librera POI. Si tienen
alguna observacin y/o correccin deseo que me la hagan llegar.
Al principio, descargas los jars correspondientes a la ltima versin desde la web de
Apache POI (http://poi.apache.org/)
Copias los jars en la carpeta de libreras (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 mencin de esto porque nos ayudar a ver cmo se
organiza la informacin en el archivo.

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

// Proceso la informacin y genero el xls.
HSSFWorkbook objWB = new HSSFWorkbook();

a continuacin, 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 enva al mtodo encargado de crear las filas es de tipo short, el
mismo que indica el nmero 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 fuente
HSSFFont 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);
// Tambin, 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 celda
estiloCelda.setFillForegroundColor((short)22);
estiloCelda.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
// Creamos la celda, aplicamos el estilo y definimos
// el tipo de dato que contendr la celda
HSSFCell celda = objFila.createCell((short)0);
celda.setCellStyle(estiloCelda);

celda.setCellType(HSSFCell.CELL_TYPE_STRING);
// Finalmente, establecemos el valor
celda.setCellValue("Un valor");

Como podemos apreciar en el cdigo 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 mtodos setPointHeightInPoints que recibe
un valor de tipo short que representa el tamao de la fuente; el mtodo setFontName el
mismo que recibe una constante de la misma clase que nos permite establecer la fuente que
se ha de emplear, y, otros mtodos como: setBoldweight y setUnderline, entre otros, que
nos permitirn 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 mtodos setWrapText, setAlignment y
setVerticalAlignment; aplicar la fuente trabajada, con el mtodo setFont; configurar los
bordes mediante los mtodos: 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 mtodos 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 mtodos que nos permitan ahorrar lneas
de cdigo, preestableciendo, los estilos que se emplearn.
Segn la versin de la librera que se est empleando, podremos contar o no, con algunas
constantes para la configuracin del color y el establecimiento de los sombreados. Por ello
adjunto informacin 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 informacin a un archivo.
String strNombreArchivo = "C:/libro1.xls";
File objFile = new File(strNombreArchivo);
FileOutputStream archivoSalida = new FileOutputStream(objFile);
objWB.write(archivoSalida);
archivoSalida.close();

A continuacin les presento el cdigo completo..

// Proceso la informacin y genero el xls
HSSFWorkbook objWB = new HSSFWorkbook();

// Creo la hoja
HSSFSheet hoja1 = objWB.createSheet("hoja 1");
// Proceso la informacin 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 fuente
HSSFFont 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);
// Tambin, 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 celda
estiloCelda.setFillForegroundColor((short)22);
estiloCelda.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
// Creamos la celda, aplicamos el estilo y definimos
// el tipo de dato que contendr la celda
HSSFCell celda = objFila.createCell((short)0);
celda.setCellStyle(estiloCelda);
celda.setCellType(HSSFCell.CELL_TYPE_STRING);
// Finalmente, establecemos el valor
celda.setCellValue("Un valor");
// Volcamos la informacin 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 simpln, todo lo presentado aqu generalmente se combina

con arreglos de beans y bucles, los cuales, nos ayudarn a presentar ms datos en nuestras
hojas de Excel.

El objetivo de este tutorial no es mostrar todas las opciones disponibles, sino solo presentar
un pequeo caso prctico sobre el uso de HSSF (POI) para la generacin de archivos en
formato Excel.
Deseo mencionar que para la creacin del presente tutorial me bas en la documentacin de
la pgina de Apache POI as como tambin al contenido de la pgina JAVA DRIVE (en
japons).