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 añadir 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); // 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 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 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 POI
sgoliver 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 import java.io.FileInputStream;

2 import java.io.FileOutputStream;

import java.io.IOException;
3
import java.util.Date;
4
  
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
import org.apache.poi.hssf.usermodel.HSSFSheet;
10 import org.apache.poi.hssf.usermodel.HSSFWorkbook;

11 import org.apache.poi.poifs.filesystem.POIFSFileSystem;

12   

13 public class DemoPOI

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

16     {
        escribirExcel();
17
  
18
        leerExcel();
19
  
20
        System.out.println("Ejemplo Finalizado.");
21
    }
22
  
23
    public static void escribirExcel()
24
    {
25         try

26         {

27             //Se crea el libro Excel

28             HSSFWorkbook wb = new HSSFWorkbook();

29   

30             //Se crea una nueva hoja dentro del libro

            HSSFSheet sheet = wb.createSheet("HojaEjemplo");
31
  
32
            //Se crea una fila dentro de la hoja
33
            HSSFRow row = sheet.createRow((short)0);
34
  
35
            //Creamos celdas de varios tipos
36
            row.createCell((short)0).setCellValue(1);
37
            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 patrón de formato

            HSSFCellStyle cellStyle = wb.createCellStyle();
43
            cellStyle.setDataFormat(
44
                    HSSFDataFormat.getBuiltinFormat("d/m/yy h:mm"));
45
  
46
            HSSFCell cell = row.createCell((short)4);
47
            cell.setCellValue(new Date());
48
            cell.setCellStyle(cellStyle);
49
  
50             //Escribimos los resultados a un fichero Excel

51             FileOutputStream fileOut =

52                 new FileOutputStream("ejemplo.xls");

53   

54             wb.write(fileOut);

55             fileOut.close();
        }
56
        catch(IOException e)
57
        {
58
            System.out.println("Error al escribir el fichero.");
59
        }
60
    }
61
  
62     public static void leerExcel()

63     {

64         try
65         {

66             //Se abre el fichero Excel

            POIFSFileSystem fs =
67
                    new POIFSFileSystem(
68
                            new FileInputStream("c:ejemplo.xls"));
69
  
70
            //Se obtiene el libro Excel
71
            HSSFWorkbook wb = new HSSFWorkbook(fs);
72
  
73
            //Se obtiene la primera hoja
74
            HSSFSheet sheet = wb.getSheetAt(0);
75   

76             //Se obtiene la primera fila de la hoja

77             HSSFRow row = sheet.getRow(0);

78   

79             //Se leen las primeras 5 celdas

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

81             {
                //Se obtiene la celda i-esima
82
                HSSFCell cell = row.getCell((short)i);
83
  
84
                //Si la celda leida no está vacía
85
                if (cell != null)
86
                {
87
                    //Se imprime en pantalla la celda según su tipo
88                     switch(cell.getCellType())

89                     {
90                         case HSSFCell.CELL_TYPE_NUMERIC:

91                             System.out.println("Número: " +
cell.getNumericCellValue());
92
                            break;
93                         case HSSFCell.CELL_TYPE_STRING:

94                             System.out.println("String: " +
cell.getStringCellValue());
95
                            break;
96
                        case HSSFCell.CELL_TYPE_BOOLEAN:
97
                            System.out.println("Boolean: " +
98 cell.getBooleanCellValue());
                            break;
99
                        default:
10
0                             System.out.println("Default: " +
cell.getDateCellValue());
10
                            break;
1
                    }
10
2                 }

10             }
3         }

10         catch(IOException ex)
4
        {
10
            System.out.println("Error al leer el fichero.");
5
        }
10
6     }
}
10
7

10
8

10
9

11
0

11
1

11
2

11
3

11
4

11
5

11
6

11
7

11
8
Cómo generar Hojas de Excel en una aplicación 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 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 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);

// 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 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 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 xls

HSSFWorkbook objWB = new HSSFWorkbook();

// Creo la hoja
HSSFSheet 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 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);

// 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 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 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).