operações de importação e exportação de java do Excel (jxl)

Autor：Eve Cole Data da Última Atualização：2009-12-28 16:59:50

operações de importação e exportação de java do Excel (jxl)
Java interpreta dados do Excel (uso do pacote jxl.jar)
Palavras-chave: java excel jxl.jar

Endereço de download do pacote jxl.jar:
http://www.andykhan.com/jexcelapi/
Endereço de download real:
http://www.andykhan.com/jexcelapi/download.html

Suas características estão descritas no site da seguinte forma:
● Suporta todas as versões do Excel 95-2000 ● Gera o formato padrão do Excel 2000 ● Suporta operações de fonte, número e data ● Capaz de modificar atributos de células ● Suporta imagens e gráficos Deve-se dizer que as funções acima podem atender aproximadamente às nossas necessidades. O mais importante é que esta API é Java pura e não depende do sistema Windows. Mesmo rodando em Linux, ela ainda pode processar arquivos Excel corretamente. Deve-se notar também que este conjunto de APIs tem suporte muito limitado para gráficos e tabelas e reconhece apenas o formato PNG.
Para construir o ambiente, descompacte o arquivo baixado para obter jxl.jar, coloque-o no caminho de classe e a instalação estará concluída.

Operações básicas

1. Crie o arquivo para gerar um arquivo Excel denominado "Test Data.xls", no qual a primeira planilha é denominada "Primeira Página".

Código Java
/*
* Criado em 30 de dezembro de 2007
*
* Para alterar o modelo deste arquivo gerado acesse
* Janela>Preferências>Java>Geração de Código>Código e Comentários
*/
pacote JExcelTest.standard;

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

/**
* @autor Ken
*
* Para alterar o modelo deste tipo de comentário gerado, acesse
* Janela>Preferências>Java>Geração de Código>Código e Comentários
*/
classe pública CriarXLS {

public static void main(String[] args) {
tentar {
//abre arquivo.
WritableWorkbook book = Workbook.createWorkbook(new File("d:/Test.xls"));

//cria uma planilha chamada "Folha_1". 0 significa que esta é a primeira página.
Folha WritableSheet = book.createSheet("Folha_1", 0);

//define a coluna e a linha da célula no Label Construtor e o conteúdo da célula escreve "test".
//célula é a 1ª coluna, o valor da 1ª linha é "teste".
Rótulo rótulo = novo Rótulo(0, 0, "teste");
//adiciona a célula definida acima à instância da planilha.
planilha.addCell(rótulo);

//cria célula usando add numérico. WARN: use necessariamente o caminho do pacote integrado, caso contrário será gerado um erro de caminho.
//célula é 2ª coluna, o valor da 1ª linha é 789.123.
jxl.write.Number número = novo jxl.write.Number(1, 0, 789.123);
//adiciona a célula definida acima à instância da planilha.
planilha.addCell(número);

//adiciona todas as células definidas acima ao case.
livro.write();
//fecha o arquivo case.
livro.fechar();
} catch (Exceção e) {
e.printStackTrace();
}
}
}
Depois que o Java for compilado e executado, um arquivo Excel será gerado no local atual.

2. Leia o arquivo. Pegue o arquivo Excel que acabamos de criar como exemplo para realizar uma operação de leitura simples.

3. Modificar arquivos Você pode usar jExcelAPI para modificar arquivos Excel existentes Ao modificar arquivos Excel, exceto pelas diferentes formas de abrir o arquivo, as demais operações são iguais à criação do Excel. O exemplo a seguir adiciona uma planilha ao arquivo Excel que geramos:
Modifique a classe Excel e adicione uma planilha
Código Java
/*
* Criado em 30 de dezembro de 2007
*
* Para alterar o modelo deste arquivo gerado acesse
* Janela>Preferências>Java>Geração de Código>Código e Comentários
*/
pacote JExcelTest.standard;

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

/**
* @autor Ken
*
* Para alterar o modelo deste tipo de comentário gerado, acesse
* Janela>Preferências>Java>Geração de Código>Código e Comentários
*/
classe pública UpdateXLS {

public static void main(String[] args) {
tentar {
//obter arquivo.
Pasta de trabalho wb = Workbook.getWorkbook(new File("d:/Test.xls"));
//abra um arquivo de cópia (novo arquivo) e escreva o conteúdo com o mesmo conteúdo com Test.xls.
Livro gravávelWorkbook =
Workbook.createWorkbook(new Arquivo("d:/Test.xls"), wb);
//adiciona uma planilha.
Folha WritableSheet = book.createSheet("Folha_2", 1);
planilha.addCell(new Label(0, 0, "test2"));
livro.write();
livro.fechar();
} catch (Exceção e) {
e.printStackTrace();
}
}
}

Operações avançadas

1. A formatação de dados no Excel não envolve tipos de dados complexos. Ele pode lidar relativamente bem com strings, números e datas e é suficiente para aplicações gerais.
Formatação de string A formatação de string envolve elementos como fonte, espessura, tamanho da fonte, etc. Essas funções são as principais responsáveis pelas classes WritableFont e WritableCellFormat. Suponha que usemos a seguinte instrução ao gerar uma célula contendo uma string. Para conveniência da descrição, numeramos cada linha de comando:
Fonte WritableFont1= new WritableFont(WritableFont.TIMES,16,WritableFont.BOLD);
ou
//Define o formato da fonte para um formato suportado pelo Excel
WritableFont font3=new WritableFont(WritableFont.createFont("楷体_GB2312"),12,WritableFont.NO_BOLD );
① WritableCellFormat formato1 = novo WritableCellFormat (fonte1);
② Rótulo = novo rótulo (0,0,”teste de dados 4”,formato1)
③ Entre eles
I. O formato da string é especificado: a fonte é TIMES, o tamanho da fonte é 16 e é exibido em negrito. WritableFont possui um conjunto muito rico de construtores para uso em diferentes situações. Há uma lista detalhada no java-doc do jExcelAPI, que não será listada aqui.
II. O código acima usa a classe WritableCellFormat. Esta classe é muito importante. Através dela, vários atributos da célula podem ser especificados na formatação subsequente da célula.
III. O construtor da classe Label é usado para especificar o formato que a string é fornecida. Na classe WritableCellFormat, outro método muito importante é especificar o alinhamento dos dados. Por exemplo, para nosso exemplo acima, você pode especificar:
//Especifica o alinhamento horizontal como centralizado
format1.setAlignment(jxl.format.Alignment.CENTRE);
//Especifica o alinhamento vertical como centralizado
format1.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);
//Definir quebra automática de linha
formato1.setWrap(verdadeiro);

2. Operações celulares
Uma parte muito importante do Excel é a operação de células, como altura de linha, largura de coluna, mesclagem de células, etc. Felizmente, jExcelAPI fornece esses suportes. Essas operações são relativamente simples e apenas as APIs relevantes são apresentadas abaixo.
1. Mesclar células
WritableSheet.mergeCells(int m,int n,int p,int q);
A função é mesclar todas as células de (m,n) a (p,q), por exemplo:
WritableSheet sheet=book.createSheet("Primeira página",0);
//Mescla todas as células da primeira linha da primeira coluna até a primeira linha da sexta coluna
planilha.mergeCells(0,0,5,0);
As fusões podem ser horizontais ou verticais. As células mescladas não podem ser mescladas novamente, caso contrário, uma exceção será acionada.
2. Altura da linha e largura da coluna
WritableSheet.setRowView(int i,int altura);
A função é especificar a altura da i+1ª linha, por exemplo:
//Define a altura da primeira linha como 200
planilha.setRowView(0,200);
WritableSheet.setColumnView(int i,int largura);
Sua função é especificar a largura da coluna i+1, por exemplo:
//Define a largura da primeira coluna como 30
planilha.setColumnView(0,30);
3. Imagens de operação
Código Java
public static void write() lança exceção{
WritableWorkbook wwb=Workbook.createWorkbook(new Arquivo("c:/1.xls"));
WritableSheet ws=wwb.createSheet("Folha de teste 1",0);
Arquivo arquivo=novo arquivo("C:\jbproject\PVS\WebRoot\weekhit\1109496996281.png");
Imagem WritableImage = nova WritableImage (1, 4, 6, 18, arquivo);
ws.addImage(imagem);
wwb.write();
close();
}
É muito simples e igual à forma de inserir células, mas possui mais parâmetros. A classe WritableImage herda Draw . por x, y, largura, altura Observe que a largura e a altura aqui não são a largura e a altura da imagem, mas o número de unidades que a imagem ocupa. Analisei os detalhes de como ele é implementado :) Como estou com pressa, vou completar as funções primeiro e terei tempo para estudar o resto depois. Continuarei anotando minha experiência em usá-lo no futuro.

ler:
Ao ler, a ideia é a seguinte. Primeiro use um fluxo de entrada (InputStream) para obter o arquivo Excel, depois use a pasta de trabalho em jxl para obter a pasta de trabalho, use Sheet para obter a planilha da pasta de trabalho e use Cell para obter uma planilha. determinado ponto da célula da planilha.
InputStream->Workbook->Sheet->Cell, você obterá as células no arquivo Excel

Código Java
String path="c:\excel.xls";//URL do arquivo Excel
InputStream é = new FileInputStream(caminho);//Escreve em FileInputStream
jxl.Workbook wb = Workbook.getWorkbook(is);
jxl.Sheet st = wb.getSheet(0);//Obtém a primeira planilha da pasta de trabalho
Cell cell=st.getCell(0,0);//Obtém a primeira célula da planilha, que é A1
String content=cell.getContents();//getContents() converte os caracteres da célula em strings
wb.close(); //Fecha a pasta de trabalho
is.close(); //Fecha o fluxo de entrada
String path="c:\excel.xls";//URL do arquivo Excel
InputStream é = new FileInputStream(caminho);//Escreve em FileInputStream
jxl.Workbook wb = Workbook.getWorkbook(is);
jxl.Sheet st = wb.getSheet(0);//Obtém a primeira planilha da pasta de trabalho
Cell cell=st.getCell(0,0);//Obtém a primeira célula da planilha, que é A1
String content=cell.getContents();//getContents() converte os caracteres da célula em strings
wb.close(); //Fecha a pasta de trabalho
is.close();//Fecha o fluxo de entrada Podemos obter qualquer célula por meio do método getCell(x,y) do Sheet e x, y correspondem às coordenadas no Excel.
Por exemplo, A1 corresponde a (0,0), A2 corresponde a (0,1) e D3 corresponde a (3,2). As coordenadas no Excel começam em A,1, mas em jxl todas começam em 0.
Você também pode obter o número de linhas e colunas por meio dos métodos getRows() e getColumns() da planilha e usá-los para controle de loop para gerar todo o conteúdo de uma planilha.

Escrever:
Para escrever conteúdo no Excel, você usa principalmente as classes do pacote jxl.write.
A ideia é esta:
OutputStream<-WritableWorkbook<-WritableSheet<-Label
O rótulo aqui representa a localização e o conteúdo da célula escrita na planilha.

Código Java
OutputStream os=new FileOutputStream("c:\test.xls");//URL do arquivo Excel de saída
WritableWorkbook wwb = Workbook.createWorkbook(os);//Cria uma pasta de trabalho gravável
WritableSheet ws = wwb.createSheet("sheet1", 0);//Cria uma planilha gravável
Label labelCF=new Label(0, 0, "hello");//Cria local de escrita e conteúdo
ws.addCell(labelCF); //Escreve o rótulo na planilha
O construtor do rótulo Label(int x, int y, String aString) xy significa xy durante a leitura e aString é o conteúdo escrito.
WritableFont wf = new WritableFont(WritableFont.TIMES, 12, WritableFont.BOLD, false);//Definir a fonte de escrita
WritableCellFormat wcfF = new WritableCellFormat(wf);//Definir CellFormat
Label labelCF=new Label(0, 0, "hello");//Cria local de escrita, conteúdo e formato
Outro construtor de Label, Label(int c, int r, String cont, CellFormat st), pode formatar o conteúdo escrito, definir a fonte e outros atributos.
Você pode escrever agora
wwb.write();
Fechar depois de escrever
close();
Feche também o fluxo de saída
os.close;

OK, contanto que você combine leitura e escrita, você pode ler os dados no N Excel e gravá-los na nova tabela do Excel desejada, o que é bastante conveniente.

A seguir está um exemplo de programa:

Código Java
sql = "selecione * do nome da tabela";
rs = stmt.executeQuery(sql);

//Cria um novo arquivo Excel
String filePath=request.getRealPath("aaa.xls");
Arquivo meuCaminhoArquivo=novo Arquivo(CaminhoArquivo);
if(!myFilePath.exists())
meuFilePath.createNewFile();
FileWriter resultFile=new FileWriter(meuCaminhoDoArquivo);
PrintWriter meuArquivo=new PrintWriter(resultFile);
resultadoArquivo.close();

//Use JXL para adicionar conteúdo ao arquivo recém-criado
SaídaStream outf = new FileOutputStream(filePath);
jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(outf);
jxl.write.WritableSheet ws = wwb.createSheet("sheettest", 0);

int i=0;
intj=0;

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

enquanto(rs.next()){
out.println(rs.getMetaData().getColumnCount());

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

eu++;
}
wwb.write();
close();
}catch(Exceção e){e.printStackTrace();}
finalmente{

rs.close();
conn.close();
}

resposta.sendRedirect("aaa.xls");

Este artigo vem do blog CSDN. Por favor, indique a fonte ao reimprimir: http://blog.csdn.net/yangf1984/archive/2009/12/28/5088933.aspx.