Operaciones de Excel de importación y exportación de Java (jxl)

Autor：Eve Cole Fecha de actualización：2009-12-28 16:59:50

Operaciones de Excel de importación y exportación de Java (jxl)
Java interpreta datos de Excel (uso del paquete jxl.jar)
Palabras clave: java excel jxl.jar

Dirección de descarga del paquete jxl.jar:
http://www.andykhan.com/jexcelapi/
Dirección de descarga real:
http://www.andykhan.com/jexcelapi/download.html

Sus características se describen en el sitio web de la siguiente manera:
● Soporta todas las versiones de Excel 95-2000 ● Genera el formato estándar Excel 2000 ● Soporta operaciones de fuente, números y fechas ● Capaz de modificar atributos de celda ● Soporta imágenes y gráficos Cabe decir que las funciones anteriores pueden satisfacer aproximadamente nuestras necesidades. Lo más importante es que esta API es Java pura y no depende del sistema Windows. Incluso si se ejecuta en Linux, aún puede procesar archivos de Excel correctamente. También cabe señalar que este conjunto de API tiene un soporte muy limitado para gráficos y tablas, y solo reconoce el formato PNG.
Para crear el entorno, descomprima el archivo descargado para obtener jxl.jar, colóquelo en el classpath y la instalación estará completa.

Operaciones básicas

1. Cree el archivo para generar un archivo de Excel llamado "Test Data.xls", en el que la primera hoja de trabajo se denomina "Primera página". El efecto general es el siguiente:

código java
/*
* Creado el 30 de diciembre de 2007
*
* Para cambiar la plantilla para este archivo generado, vaya a
* Ventana>Preferencias>Java>Generación de Código>Código y Comentarios
*/
paquete JExcelTest.standard;

importar java.io.*;
importar jxl.*;
importar jxl.write.*;

/**
* @autor Ken
*
* Para cambiar la plantilla para este tipo de comentario generado, vaya a
* Ventana>Preferencias>Java>Generación de Código>Código y Comentarios
*/
clase pública CrearXLS {

público estático vacío principal (String [] argumentos) {
intentar {
//abrir archivo.
Libro WritableWorkbook = Workbook.createWorkbook(new File("d:/Test.xls"));

//crear hoja llamada "Hoja_1". 0 significa que esta es la primera página.
Hoja WritableSheet = libro.createSheet("Hoja_1", 0);

//definir la columna y la fila de la celda en Label Constructor, y el contenido de la celda escribe "prueba".
//la celda es la primera columna, el valor de la primera fila es "prueba".
Etiqueta etiqueta = nueva Etiqueta(0, 0, "prueba");
//agregar la celda definida arriba a la instancia de la hoja.
hoja.addCell(etiqueta);

//crear celda usando agregar numérico. ADVERTENCIA: necesariamente use la ruta del paquete integrada; de lo contrario, se generará un error de ruta.
//la celda es la segunda columna, el valor de la primera fila es 789.123.
jxl.write.Number número = nuevo jxl.write.Number(1, 0, 789.123);
//agregar la celda definida arriba a la instancia de la hoja.
hoja.addCell(número);

//agregar todas las celdas definidas arriba al caso.
libro.write();
//cerrar caso de archivo.
libro.cerrar();
} captura (Excepción e) {
e.printStackTrace();
}
}
}
Después de compilar y ejecutar Java, se generará un archivo de Excel en la ubicación actual.

2. Lea el archivo. Tome el archivo de Excel que acabamos de crear como ejemplo para realizar una operación de lectura simple. El código del programa es el siguiente:

3. Modificar archivos Puede utilizar jExcelAPI para modificar archivos de Excel existentes. Al modificar archivos de Excel, excepto por las diferentes formas de abrir el archivo, las demás operaciones son las mismas que para crear Excel. El siguiente ejemplo agrega una hoja de trabajo al archivo de Excel que hemos generado:
Modifica la clase de Excel y agrega una hoja de trabajo.
código java
/*
* Creado el 30 de diciembre de 2007
*
* Para cambiar la plantilla para este archivo generado, vaya a
* Ventana>Preferencias>Java>Generación de Código>Código y Comentarios
*/
paquete JExcelTest.standard;

importar java.io.*;
importar jxl.*;
importar jxl.write.*;

/**
* @autor Ken
*
* Para cambiar la plantilla para este tipo de comentario generado, vaya a
* Ventana>Preferencias>Java>Generación de Código>Código y Comentarios
*/
clase pública UpdateXLS {

público estático vacío principal (String [] argumentos) {
intentar {
//obtener archivo.
Libro de trabajo wb = Workbook.getWorkbook(new File("d:/Test.xls"));
//abre una copia del archivo (archivo nuevo), luego escribe contenido con el mismo contenido con Test.xls.
Libro de trabajo grabable =
Workbook.createWorkbook(nuevo archivo("d:/Test.xls"), wb);
//agregar una hoja.
Hoja WritableSheet = libro.createSheet("Hoja_2", 1);
hoja.addCell(nueva Etiqueta(0, 0, "prueba2"));
libro.write();
libro.cerrar();
} captura (Excepción e) {
e.printStackTrace();
}
}
}

Operaciones avanzadas

1. El formato de datos en Excel no implica tipos de datos complejos. Puede manejar cadenas, números y fechas relativamente bien y es suficiente para aplicaciones generales.
Formato de cadena El formato de cadena implica elementos como fuente, grosor, tamaño de fuente, etc. Estas funciones son las principales responsables de las clases WritableFont y WritableCellFormat. Supongamos que usamos la siguiente declaración al generar una celda que contiene una cadena. Para facilitar la descripción, numeramos cada línea de comando:
WritableFont font1= nuevo WritableFont(WritableFont.TIMES,16,WritableFont.BOLD);
o
//Establece el formato de fuente en un formato compatible con Excel
WritableFont font3=new WritableFont(WritableFont.createFont("楷体_GB2312"),12,WritableFont.NO_BOLD);
① WritableCellFormat formato1 = nuevo WritableCellFormat (fuente1);
② Etiqueta etiqueta = nueva etiqueta (0,0”, prueba de datos 4”, formato1)
③ Entre ellos
I. Se especifica el formato de la cadena: la fuente es TIMES, el tamaño de fuente es 16 y se muestra en negrita. WritableFont tiene un conjunto muy rico de constructores para usar en diferentes situaciones. Hay una lista detallada en el documento java de jExcelAPI, que no se enumerará aquí.
II. El código anterior utiliza la clase WritableCellFormat. Esta clase es muy importante a través de ella, se pueden especificar varios atributos de la celda. Habrá más descripciones en el formato de celda posterior.
III.El constructor de la clase Label se utiliza para especificar el formato que se le da a la cadena. En la clase WritableCellFormat, otro método muy importante es especificar la alineación de los datos. Por ejemplo, para nuestro ejemplo anterior, puede especificar:
//Especifica la alineación horizontal como centrada
format1.setAlignment(jxl.format.Alignment.CENTRE);
//Especificar alineación vertical como centrada
formato1.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);
//Establecer ajuste automático de línea
format1.setWrap(verdadero);

2. Operaciones celulares
Una parte muy importante de Excel es el funcionamiento de las celdas, como la altura de la fila, el ancho de la columna, la combinación de celdas, etc. Afortunadamente, jExcelAPI proporciona estos soportes. Estas operaciones son relativamente simples y a continuación solo se presentan las API relevantes.
1. Fusionar celdas
WritableSheet.mergeCells(int m,int n,int p,int q);
La función es fusionar todas las celdas de (m,n) a (p,q), por ejemplo:
WritableSheet hoja=book.createSheet("Primera página",0);
//Combina todas las celdas desde la primera fila de la primera columna con la primera fila de la sexta columna
hoja.mergeCells(0,0,5,0);
Las fusiones pueden ser horizontales o verticales. Las celdas fusionadas no se pueden volver a fusionar; de lo contrario, se activará una excepción.
2. Alto de fila y ancho de columna
WritableSheet.setRowView(int i,int altura);
La función es especificar la altura de la fila i+1, por ejemplo:
//Establece la altura de la primera fila en 200
hoja.setRowView(0,200);
WritableSheet.setColumnView(int i,int ancho);
Su función es especificar el ancho de la columna i+1, por ejemplo:
//Establece el ancho de la primera columna en 30
hoja.setColumnView(0,30);
3. Imágenes de operación
código java
escritura nula estática pública () lanza excepción {
WritableWorkbook wwb=Workbook.createWorkbook(nuevo archivo("c:/1.xls"));
WritableSheet ws=wwb.createSheet("Hoja de prueba 1",0);
Archivo archivo=nuevo archivo("C:\jbproject\PVS\WebRoot\weekhit\1109496996281.png");
Imagen WritableImage = nueva WritableImage (1, 4, 6, 18, archivo);
ws.addImage(imagen);
wwb.write();
wwb.close();
}
Es muy simple e igual que la forma de insertar celdas, pero tiene más parámetros. La clase WritableImage hereda Draw. Lo anterior es solo uno de sus métodos de construcción. No hace falta decir que el último parámetro es de tipo doble. por x, y, ancho, alto. Tenga en cuenta que el ancho y el alto aquí no son el ancho y el alto de la imagen, sino el número de unidades que ocupa la imagen. Debido a que hereda Draw, su tipo debe ser doble. No analicé los detalles de cómo se implementa :) Como tengo prisa, completaré las funciones primero y tendré tiempo para estudiar el resto más tarde. Continuaré escribiendo mi experiencia al usarlo en el futuro.

leer:
Al leer, la idea es la siguiente: primero use un flujo de entrada (InputStream) para obtener el archivo de Excel, luego use el Libro de trabajo en jxl para obtener el libro de trabajo, use Hoja para obtener la hoja de trabajo del libro de trabajo y use Celda para obtener una. cierto punto de la hoja de trabajo.
InputStream->Workbook->Hoja->Celda, obtendrás las celdas en el archivo de Excel.

código java
Ruta de cadena="c:\excel.xls";//URL del archivo Excel
InputStream es = new FileInputStream(ruta);//Escribir en FileInputStream
jxl.Workbook wb = Workbook.getWorkbook(is); //Obtener el libro de trabajo
jxl.Sheet st = wb.getSheet(0);//Obtener la primera hoja de trabajo del libro
Cell cell=st.getCell(0,0);//Obtiene la primera celda de la hoja de trabajo, que es A1
String content=cell.getContents();//getContents() convierte los caracteres de Cell en cadenas
wb.close();//Cerrar el libro de trabajo
is.close();//Cerrar el flujo de entrada
Ruta de cadena="c:\excel.xls";//URL del archivo Excel
InputStream es = new FileInputStream(ruta);//Escribir en FileInputStream
jxl.Workbook wb = Workbook.getWorkbook(is); //Obtener el libro de trabajo
jxl.Sheet st = wb.getSheet(0);//Obtener la primera hoja de trabajo del libro
Cell cell=st.getCell(0,0);//Obtiene la primera celda de la hoja de trabajo, que es A1
String content=cell.getContents();//getContents() convierte los caracteres de Cell en cadenas
wb.close();//Cerrar el libro de trabajo
is.close();//Cerrar el flujo de entrada Podemos obtener cualquier celda a través del método getCell(x,y) de Sheet, y x, y corresponden a las coordenadas en Excel.
Por ejemplo, A1 corresponde a (0,0), A2 corresponde a (0,1) y D3 corresponde a (3,2). Las coordenadas en Excel comienzan desde A,1, pero en jxl todas comienzan desde 0.
También puede obtener el número de filas y columnas a través de los métodos getRows() y getColumns() de Sheet, y usarlos como control de bucle para generar todo el contenido de una hoja.

Escribir:
Para escribir contenido en Excel, utiliza principalmente las clases del paquete jxl.write.
La idea es esta:
OutputStream<-WritableWorkbook<-WritableSheet<-Label
La Etiqueta aquí representa la ubicación y el contenido de la Celda escrita en la Hoja.

código java
OutputStream os=new FileOutputStream("c:\test.xls");//URL del archivo Excel de salida
WritableWorkbook wwb = Workbook.createWorkbook(os);//Crear un libro de trabajo grabable
WritableSheet ws = wwb.createSheet("sheet1", 0);//Crear una hoja de trabajo grabable
Label labelCF=new Label(0, 0, "hello");//Crear contenido y ubicación de escritura
ws.addCell(labelCF);//Escribe la etiqueta en la hoja
El constructor de Label Label(int x, int y, String aString) xy significa xy al leer, y aString es el contenido escrito.
WritableFont wf = new WritableFont(WritableFont.TIMES, 12, WritableFont.BOLD, false);//Establecer la fuente de escritura
WritableCellFormat wcfF = new WritableCellFormat(wf);//Establecer CellFormat
Label labelCF=new Label(0, 0, "hello");//Crear ubicación, contenido y formato de escritura
Otro constructor de Label, Label(int c, int r, String cont, CellFormat st), puede formatear el contenido escrito, establecer la fuente y otros atributos.
Puedes escribir ahora
wwb.write();
Cerrar después de escribir
wwb.close();
También cierre el flujo de salida.
os.cerrar;

Bien, siempre que combine lectura y escritura, puede leer datos en N Excel y escribirlos en la nueva tabla de Excel que desee, lo cual es bastante conveniente.

El siguiente es un ejemplo de un programa:

código java
sql = "seleccionar * del nombre de la tabla";
rs = stmt.executeQuery(sql);

//Crea un nuevo archivo Excel
String filePath=request.getRealPath("aaa.xls");
Archivo myFilePath=nuevo archivo(filePath);
si(!myFilePath.exists())
myFilePath.createNewFile();
FileWriter resultFile=new FileWriter(myFilePath);
PrintWriter miArchivo=nuevo PrintWriter(resultadoArchivo);
resultadoFile.close();

//Utiliza JXL para agregar contenido al archivo recién creado
OutputStream outf = nuevo FileOutputStream(filePath);
jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(outf);
jxl.write.WritableSheet ws = wwb.createSheet("sheettest", 0);

int i=0;
intj=0;

para (int k = 0; k < rs.getMetaData().getColumnCount(); k++) {
ws.addCell(new Label(k,0,rs.getMetaData().getColumnName(k+1)));
}

mientras(rs.siguiente()){
out.println(rs.getMetaData().getColumnCount());

para (int k = 0; k < rs.getMetaData().getColumnCount(); k++) {
ws.addCell(new Label(k,j+i+1,rs.getString(k+1)));
}

yo ++;
}
wwb.write();
wwb.close();
}catch(Excepción e){e.printStackTrace();}
finalmente{

rs.cerrar();
conexión.close();
}

respuesta.sendRedirect("aaa.xls");

Este artículo proviene del blog de CSDN. Indique la fuente al reimprimir: http://blog.csdn.net/yangf1984/archive/2009/12/28/5088933.aspx .