opérations d'importation et d'exportation Java Excel (jxl)

Auteur：Eve Cole Date de mise à jour：2009-12-28 16:59:50

opérations d'importation et d'exportation Java Excel (jxl)
Java interprète les données Excel (utilisation du package jxl.jar)
Mots-clés : java excel jxl.jar

Adresse de téléchargement du package jxl.jar :
http://www.andykhan.com/jexcelapi/
Adresse réelle de téléchargement :
http://www.andykhan.com/jexcelapi/download.html

Ses caractéristiques sont décrites sur le site Internet comme suit :
● Prend en charge toutes les versions d'Excel 95-2000 ● Génère le format standard Excel 2000 ● Prend en charge les opérations de police, de nombre et de date ● Capable de modifier les attributs des cellules ● Prend en charge les images et les graphiques Il faut dire que les fonctions ci-dessus peuvent à peu près répondre à nos besoins. Le plus important est que cette API est purement Java et ne dépend pas du système Windows. Même si elle fonctionne sous Linux, elle peut toujours traiter correctement les fichiers Excel. Il convient également de noter que cet ensemble d'API a une prise en charge très limitée des graphiques et des diagrammes et ne reconnaît que le format PNG.
Pour créer l'environnement, décompressez le fichier téléchargé pour obtenir jxl.jar, placez-le dans le chemin de classe et l'installation est terminée.

Opérations de base

1. Créez le fichier pour générer un fichier Excel nommé « Test Data.xls », dans lequel la première feuille de calcul est nommée « Première page ». L'effet général est le suivant :

Code Java
/*
* Créé le 30 décembre 2007
*
* Pour modifier le modèle de ce fichier généré, accédez à
* Fenêtre>Préférences>Java>Génération de code>Code et commentaires
*/
package JExcelTest.standard ;

importer java.io.* ;
importer jxl.*;
importer jxl.write.*;

/**
* @auteur Ken
*
* Pour modifier le modèle de ce commentaire de type généré, accédez à
* Fenêtre>Préférences>Java>Génération de code>Code et commentaires
*/
classe publique CreateXLS {

public static void main (String[] arguments) {
essayer {
// ouvre le fichier.
WritableWorkbook book = Workbook.createWorkbook(new File("d:/Test.xls"));

//crée une feuille nommée "Sheet_1". 0 signifie qu'il s'agit de la 1ère page.
Feuille WritableSheet = book.createSheet("Sheet_1", 0);

// définit la colonne et la ligne de cellule dans Label Constructor, et le contenu de la cellule écrit "test".
// la cellule est la 1ère colonne, la valeur de la 1ère ligne est "test".
Étiquette étiquette = new Étiquette(0, 0, "test");
// ajoute la cellule définie ci-dessus à l'instance de feuille.
sheet.addCell(étiquette);

//crée une cellule en utilisant un ajout numérique WARN : utilisez nécessairement le chemin du package intégré, sinon une erreur de chemin sera générée.
// la cellule est la 2e colonne, la valeur de la 1ère ligne est 789,123.
jxl.write.Number nombre = nouveau jxl.write.Number(1, 0, 789.123);
// ajoute la cellule définie ci-dessus à l'instance de feuille.
feuille.addCell(nombre);

//ajoute la définition de toutes les cellules ci-dessus au cas.
livre.write();
//ferme le dossier.
livre.close();
} attraper (Exception e) {
e.printStackTrace();
}
}
}
Une fois Java compilé et exécuté, un fichier Excel sera généré à l’emplacement actuel.

2. Lisez le fichier. Prenez le fichier Excel que nous venons de créer comme exemple pour effectuer une opération de lecture simple. Le code du programme est le suivant :

3. Modifier des fichiers Vous pouvez utiliser jExcelAPI pour modifier des fichiers Excel existants Lors de la modification de fichiers Excel, à l'exception des différentes manières d'ouvrir le fichier, les autres opérations sont les mêmes que la création d'Excel. L'exemple suivant ajoute une feuille de calcul au fichier Excel que nous avons généré :
Modifier la classe Excel et ajouter une feuille de calcul
Code Java
/*
* Créé le 30 décembre 2007
*
* Pour modifier le modèle de ce fichier généré, accédez à
* Fenêtre>Préférences>Java>Génération de code>Code et commentaires
*/
package JExcelTest.standard ;

importer java.io.* ;
importer jxl.*;
importer jxl.write.*;

/**
* @auteur Ken
*
* Pour modifier le modèle de ce commentaire de type généré, accédez à
* Fenêtre>Préférences>Java>Génération de code>Code et commentaires
*/
classe publique UpdateXLS {

public static void main (String[] arguments) {
essayer {
//récupère le fichier.
Classeur wb = Workbook.getWorkbook(new File("d:/Test.xls"));
//ouvrez un fichier de copie (nouveau fichier), puis écrivez le contenu avec le même contenu avec Test.xls.
Livre WritableWorkbook =
Workbook.createWorkbook(new File("d:/Test.xls"), wb);
//ajoute une feuille.
Feuille WritableSheet = book.createSheet("Sheet_2", 1);
sheet.addCell(new Label(0, 0, "test2"));
livre.write();
livre.close();
} attraper (Exception e) {
e.printStackTrace();
}
}
}

Opérations avancées

1. Le formatage des données dans Excel n'implique pas de types de données complexes. Il peut relativement bien gérer les chaînes, les nombres et les dates et est suffisant pour les applications générales.
Formatage de chaîne Le formatage de chaîne implique des éléments tels que la police, l'épaisseur, la taille de la police, etc. Ces fonctions sont principalement responsables des classes WritableFont et WritableCellFormat. Supposons que nous utilisions l'instruction suivante lors de la génération d'une cellule contenant une chaîne. Pour faciliter la description, nous numérotons chaque ligne de commande :
WritableFont font1= new WritableFont(WritableFont.TIMES,16,WritableFont.BOLD);
ou
//Définit le format de police sur un format pris en charge par Excel
WritableFont font3=new WritableFont(WritableFont.createFont("楷体_GB2312"),12,WritableFont.NO_BOLD );
① WritableCellFormat format1=nouveau WritableCellFormat(font1);
② Étiquette étiquette = nouvelle étiquette (0,0, « test de données 4 », format1)
③ Parmi eux
I. Le format de chaîne est spécifié : la police est TIMES, la taille de la police est 16 et elle est affichée en gras. WritableFont possède un ensemble très riche de constructeurs à utiliser dans différentes situations. Il existe une liste détaillée dans la documentation java de jExcelAPI, qui ne sera pas répertoriée ici.
II. Le code ci-dessus utilise la classe WritableCellFormat. Cette classe est très importante, grâce à elle, divers attributs de la cellule peuvent être spécifiés. Il y aura plus de descriptions dans le formatage de cellule ultérieur.
III. Le constructeur de la classe Label est utilisé pour spécifier le format donné à la chaîne. Dans la classe WritableCellFormat, une autre méthode très importante consiste à spécifier l'alignement des données. Par exemple, pour notre exemple ci-dessus, vous pouvez spécifier :
//Spécifiez l'alignement horizontal comme centré
format1.setAlignment(jxl.format.Alignment.CENTRE);
// Spécifie l'alignement vertical comme centré
format1.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);
//Définir le retour à la ligne automatique
format1.setWrap(true);

2. Opérations cellulaires
Une partie très importante d'Excel est le fonctionnement des cellules, comme la hauteur des lignes, la largeur des colonnes, la fusion des cellules, etc. Heureusement, jExcelAPI fournit ces supports. Ces opérations sont relativement simples et seules les API pertinentes sont présentées ci-dessous.
1. Fusionner les cellules
WritableSheet.mergeCells (int m, int n, int p, int q);
La fonction est de fusionner toutes les cellules de (m,n) à (p,q), par exemple :
WritableSheet sheet=book.createSheet("Première page",0);
//Fusionner toutes les cellules de la première ligne de la première colonne à la première ligne de la sixième colonne
feuille.mergeCells(0,0,5,0);
Les fusions peuvent être horizontales ou verticales. Les cellules fusionnées ne peuvent pas être fusionnées à nouveau, sinon une exception sera déclenchée.
2. Hauteur des lignes et largeur des colonnes
WritableSheet.setRowView(int i,int hauteur);
La fonction est de spécifier la hauteur de la i+1ème ligne, par exemple :
// Fixe la hauteur de la première ligne à 200
feuille.setRowView(0,200);
WritableSheet.setColumnView(int i,int largeur);
Sa fonction est de préciser la largeur de la colonne i+1, par exemple :
// Fixe la largeur de la première colonne à 30
feuille.setColumnView(0,30);
3. Images d'opération
Code Java
public static void write() lève une exception{
WritableWorkbook wwb=Workbook.createWorkbook(new File("c:/1.xls"));
WritableSheet ws=wwb.createSheet("Feuille de test 1",0);
Fichier file=new File("C:\jbproject\PVS\WebRoot\weekhit\1109496996281.png");
WritableImage image=new WritableImage(1, 4, 6, 18,fichier);
ws.addImage(image);
wwb.write();
wwb.close();
}
C'est très simple et identique à la manière d'insérer des cellules, mais elle a plus de paramètres. La classe WritableImage hérite de Draw. Ce qui précède n'est qu'une de ses méthodes de construction. Inutile de dire que le dernier paramètre est de type double . par x, y, width, height. Notez que la largeur et la hauteur ici ne sont pas la largeur et la hauteur de l'image, mais le nombre d'unités occupées par l'image. Parce qu'elle hérite de Draw, son type doit être double. Je n'ai pas regardé en détail comment il est implémenté :) Comme je suis pressé, je vais d'abord terminer les fonctions, et j'aurai le temps d'étudier le reste plus tard. Je continuerai à écrire mon expérience d'utilisation à l'avenir.

lire:
Lors de la lecture, l'idée est la suivante. Utilisez d'abord un flux d'entrée (InputStream) pour obtenir le fichier Excel, puis utilisez le Workbook dans jxl pour obtenir le classeur, utilisez Sheet pour obtenir la feuille de calcul du classeur et utilisez Cell pour obtenir un certain point dans la cellule de la feuille de calcul.
InputStream->Workbook->Sheet->Cell, vous obtiendrez les cellules du fichier Excel

Code Java
Chemin de chaîne="c:\excel.xls";//URL du fichier Excel
InputStream est = new FileInputStream (chemin); // Écrire dans FileInputStream
jxl.Workbook wb = Workbook.getWorkbook(is); //Récupérer le classeur
jxl.Sheet st = wb.getSheet(0);//Obtenir la première feuille de calcul du classeur
Cell cell=st.getCell(0,0);//Obtenir la première cellule de la feuille de calcul, qui est A1
String content=cell.getContents();//getContents() convertit les caractères de Cell en chaînes
wb.close();//Ferme le classeur
is.close();//Ferme le flux d'entrée
Chemin de chaîne="c:\excel.xls";//URL du fichier Excel
InputStream est = new FileInputStream (chemin); // Écrire dans FileInputStream
jxl.Workbook wb = Workbook.getWorkbook(is); //Récupérer le classeur
jxl.Sheet st = wb.getSheet(0);//Obtenir la première feuille de calcul du classeur
Cell cell=st.getCell(0,0);//Obtenir la première cellule de la feuille de calcul, qui est A1
String content=cell.getContents();//getContents() convertit les caractères de Cell en chaînes
wb.close();//Ferme le classeur
is.close();//Fermez le flux d'entrée. Nous pouvons obtenir n'importe quelle cellule via la méthode getCell(x,y) de Sheet, et x, y correspondent aux coordonnées dans Excel.
Par exemple, A1 correspond à (0,0), A2 correspond à (0,1) et D3 correspond à (3,2). Les coordonnées dans Excel commencent à A,1, mais dans jxl elles commencent toutes à 0.
Vous pouvez également obtenir le nombre de lignes et de colonnes via les méthodes getRows() et getColumns() de Sheet, et les utiliser pour le contrôle de boucle afin de générer tout le contenu d'une feuille.

Écrire:
Pour écrire du contenu dans Excel, vous utilisez principalement les classes du package jxl.write.
L'idée est la suivante :
OutputStream<-WritableWorkbook<-WritableSheet<-Label
L'étiquette représente ici l'emplacement et le contenu de la cellule écrite dans la feuille.

Code Java
OutputStream os=new FileOutputStream("c:\test.xls");//URL du fichier Excel de sortie
WritableWorkbook wwb = Workbook.createWorkbook(os);//Créer un classeur inscriptible
WritableSheet ws = wwb.createSheet("sheet1", 0);//Créer une feuille de calcul inscriptible
Label labelCF=new Label(0, 0, "hello");//Créer un emplacement et un contenu d'écriture
ws.addCell(labelCF);//Écrire l'étiquette dans la feuille
Le constructeur de Label Label(int x, int y, String aString) xy signifie xy lors de la lecture, et aString est le contenu écrit.
WritableFont wf = new WritableFont(WritableFont.TIMES, 12, WritableFont.BOLD, false);//Définir la police d'écriture
WritableCellFormat wcfF = new WritableCellFormat(wf);//Définir CellFormat
Label labelCF=new Label(0, 0, "hello");//Créer l'emplacement, le contenu et le format d'écriture
Un autre constructeur de Label, Label(int c, int r, String cont, CellFormat st), peut formater le contenu écrit, définir la police et d'autres attributs.
Tu peux écrire maintenant
wwb.write();
Fermer après avoir écrit
wwb.close();
Fermez également le flux de sortie
os.close;

OK, tant que vous combinez lecture et écriture, vous pouvez lire des données dans N Excel et les écrire dans le nouveau tableau Excel de votre choix, ce qui est assez pratique.

Voici un exemple de programme :

Code Java
sql = "sélectionner * à partir du nom de la table" ;
rs = stmt.executeQuery(sql);

//Créer un nouveau fichier Excel
String filePath=request.getRealPath("aaa.xls");
Fichier monFilePath=nouveau fichier(filePath);
si(!myFilePath.exists())
monFilePath.createNewFile();
FileWriter resultFile=nouveau FileWriter(monFilePath);
PrintWriter monFichier=nouveau PrintWriter(resultFile);
resultFile.close();

//Utilisez JXL pour ajouter du contenu au fichier nouvellement créé
OutputStream outf = nouveau FileOutputStream(filePath);
jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(outf);
jxl.write.WritableSheet ws = wwb.createSheet("sheettest", 0);

entier je = 0 ;
entier j=0 ;

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

tandis que(rs.next()){
out.println(rs.getMetaData().getColumnCount());

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

je++;
}
wwb.write();
wwb.close();
}catch(Exception e){e.printStackTrace();}
enfin{

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

réponse.sendRedirect("aaa.xls");

Cet article provient du blog CSDN Veuillez indiquer la source lors de la réimpression : http://blog.csdn.net/yangf1984/archive/2009/12/28/5088933.aspx.