[JAVA] Opération Excel avec Apache POI
introduction
J'ai essayé de sortir de csv vers Excel en utilisant Apache POI. J'ai également sorti un graphique à barres. C'est comme ça
| template.xlsx | output.xlsx |
|---|---|
 |
 |
Étant donné que je suis débutant, je pense qu'il y a de nombreux points que je ne peux pas atteindre, mais j'apprécierais vos opinions.
github https://github.com/y012/POI_Sample.git
table des matières
- À propos d'Apache POI
- Environnement d'utilisation
- Préparation
- Mise en œuvre
- Résumé
1. À propos d'Apache POI
Qu'est-ce qu'Apache POI en premier lieu? Cela a commencé à partir de.
Quand je l'ai recherché, il semble que je puisse exploiter des fichiers au format Microsoft Office. (En plus d'Excel, Word, PowerPoint, etc.)
wiki https://ja.wikipedia.org/wiki/Apache_POI API Document https://poi.apache.org/apidocs/dev/overview-summary.html
Il semble que diverses choses peuvent être faites et c'est pratique, mais il semble que la profondeur est plus profonde ... Cette fois, comme le titre l'indique, nous allons faire fonctionner Excel!
2. Environnement d'utilisation
-
Windows 7
-
Java 8
-
Apache POI 4.1.1
-
Microsoft Excel 2010
3. Préparation
-Télécharger Apache POI.
Apache POI https://poi.apache.org/index.html
Télécharger à partir du lien → poi-bin- ～ .zip → Télécharger à partir du lien qui peut être obtenu dans le cadre rouge Cette fois, j'ai téléchargé le second par le haut.
・ Décompressez, construisez le chemin Faites un clic droit sur le projet que vous souhaitez ajouter → Nouveau → Dossier Ensuite, créez un dossier lib et décompressez le zip téléchargé dans le dossier lib. Cette fois, j'ai mis le chemin de construction à travers tous les fichiers jar dans le dossier décompressé!
・ Données d'entrée (.csv) Cette fois, les données d'entrée ont été préparées à partir du site ci-dessous!
Quelle information personnelle http://kazina.com/dummy/
Il semble intéressant de manger du curry, mais j'ai refusé cette fois.
・ Créer un modèle (.xlsx) Définir des polices et des styles avec POI à partir de 1 est difficile ~~ gênant ~~, alors créez d'abord un modèle!
4. Mise en œuvre
Les préparatifs sont terminés et il est enfin mis en œuvre. Utilisez XSSF ou HSSF lorsque vous travaillez avec Excel avec Apache POI. Il existe à peu près les différences suivantes, et cette fois, nous utiliserons XSSF.
| HSSF | ～Excel2003(.xls) |
|---|---|
| XSSF | Excel2007(.xlsx)～ |
Pour le moment, lisez le fichier modèle et la sortie
FileInputStream fis = null;
FileOutputStream fos = null;
Workbook wb = null;
try{
//Obtenir le fichier de modèle
fis = new FileInputStream("Chemin du fichier de modèle");
wb = (XSSFWorkbook)WorkbookFactory.create(fis);
//Paramètres de police par défaut
wb.createFont().setFontName("Nom de la police");
// (1)start
//Dupliquer la feuille du modèle et définir le nom de la feuille
//Le duplicata est ajouté à la dernière feuille du classeur
Sheet sheet = wb.cloneSheet(wb.getSheetIndex("Nom de la feuille de modèle"));
wb.setSheetName(wb.getSheetIndex(sheet), "Nom de la feuille de sortie");
//Obtenir des lignes, des cellules(Ne peut pas être obtenu colonne par colonne)
//Créer car la ligne ou la cellule sera nulle dans l'état par défaut
int rowIndex = 0;
Row row = sheet.getRow(rowIndex);
if(row == null){
row = sheet.createRow(rowIndex);
}
int columnIndex = 0;
Cell cell = row.getCell(columnIndex);
if(cell == null){
cell = row.createCell(columnIndex);
}
//Régler sur A1
cell.setCellValue("Hello World!!");
// (1)end
//Sortie vers le fichier de sortie
fos = new FileOutputStream("Chemin du fichier de sortie");
wb.write(fos);
}catch(Exception e) {
e.printStackTrace();
}finally {
if(fis != null) {
try {
fis.close();
}catch(IOException e) {
}
}
if(fos != null) {
try {
fos.close();
}catch(IOException e) {
}
}
if(wb != null) {
try {
wb.close();
}catch(IOException e) {
}
}
}
Avec cela, vous pouvez sortir sans modifier le fichier modèle, mais comme la valeur est définie pour chaque cellule, il est nécessaire de répéter la plage de (1) plusieurs fois. Par conséquent, j'ai créé une classe Manager qui résume le traitement des déplacements et le traitement des entrées.
Création de classe de manager
ExcelManager.java
package poi.common.util;
import static poi.common.constant.ExcelConstants.*;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import org.apache.poi.ss.usermodel.BorderStyle;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.ClientAnchor;
import org.apache.poi.ss.usermodel.Comment;
import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.ss.usermodel.PrintSetup;
import org.apache.poi.ss.usermodel.RichTextString;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.xddf.usermodel.chart.XDDFChart;
import org.apache.poi.xssf.usermodel.XSSFChart;
import org.apache.poi.xssf.usermodel.XSSFDrawing;
import org.openxmlformats.schemas.drawingml.x2006.chart.CTAxDataSource;
import org.openxmlformats.schemas.drawingml.x2006.chart.CTBarChart;
import org.openxmlformats.schemas.drawingml.x2006.chart.CTBarSer;
import org.openxmlformats.schemas.drawingml.x2006.chart.CTBoolean;
import org.openxmlformats.schemas.drawingml.x2006.chart.CTCatAx;
import org.openxmlformats.schemas.drawingml.x2006.chart.CTChart;
import org.openxmlformats.schemas.drawingml.x2006.chart.CTLegend;
import org.openxmlformats.schemas.drawingml.x2006.chart.CTNumDataSource;
import org.openxmlformats.schemas.drawingml.x2006.chart.CTNumRef;
import org.openxmlformats.schemas.drawingml.x2006.chart.CTPlotArea;
import org.openxmlformats.schemas.drawingml.x2006.chart.CTScaling;
import org.openxmlformats.schemas.drawingml.x2006.chart.CTSerTx;
import org.openxmlformats.schemas.drawingml.x2006.chart.CTStrRef;
import org.openxmlformats.schemas.drawingml.x2006.chart.CTValAx;
import org.openxmlformats.schemas.drawingml.x2006.chart.STAxPos;
import org.openxmlformats.schemas.drawingml.x2006.chart.STBarDir;
import org.openxmlformats.schemas.drawingml.x2006.chart.STLegendPos;
import org.openxmlformats.schemas.drawingml.x2006.chart.STOrientation;
import org.openxmlformats.schemas.drawingml.x2006.chart.STTickLblPos;
public class ExcelManager {
private Sheet sheet = null;
private Row row = null;
private Cell cell = null;
private int offset;
private int rowIndex;
private int columnIndex;
private Map<Integer,CellStyle> styleMap;
//Processus de réglage
/**
*Définissez la feuille et définissez la position de la cellule de référence sur "A1"
* @param sheet
*/
public void setSheet(Sheet sheet) {
this.sheet = sheet;
setPosition();
this.styleMap = new HashMap<>();
this.offset = 1;
this.rowIndex = 0;
this.columnIndex = 0;
}
/**
*Copiez les paramètres d'impression du modèle
* @param printSetup
*/
public void setPrintSetup(PrintSetup printSetup) {
PrintSetup newSetup = this.sheet.getPrintSetup();
//Nombre de copies
newSetup.setCopies(printSetup.getCopies());
//Mode brouillon
//newSetup.setDraft(printSetup.getDraft());
//Nombre de pages suffisamment élevé pour tenir sur la feuille
newSetup.setFitHeight(printSetup.getFitHeight());
//Nombre de pages suffisamment large pour s'adapter à la feuille
newSetup.setFitWidth(printSetup.getFitWidth());
//Marge de pied de page
//newSetup.setFooterMargin(printSetup.getFooterMargin());
//Marge d'en-tête
//newSetup.setHeaderMargin(printSetup.getHeaderMargin());
//Résolution horizontale
//newSetup.setHResolution(printSetup.getHResolution());
//Mode paysage
newSetup.setLandscape(printSetup.getLandscape());
//Commande d'impression de gauche à droite
//newSetup.setLeftToRight(printSetup.getLeftToRight());
//Noir et blanc
newSetup.setNoColor(printSetup.getNoColor());
//direction
newSetup.setNoOrientation(printSetup.getNoOrientation());
//Imprimer le mémo
//newSetup.setNotes(printSetup.getNotes());
//Début de page
//newSetup.setPageStart(printSetup.getPageStart());
//format de papier
newSetup.setPaperSize(printSetup.getPaperSize());
//échelle
newSetup.setScale(printSetup.getScale());
//Numéro de page utilisé
//newSetup.setUsePage(printSetup.getUsePage());
//Paramètres valides
//newSetup.setValidSettings(printSetup.getValidSettings());
//Résolution verticale
//newSetup.setVResolution(printSetup.getVResolution());
}
/**
*Obtenir la gamme d'impression
* @return
*/
public String getPrintArea() {
int firstRow = this.sheet.getFirstRowNum();
int lastRow = this.rowIndex;
int firstColumn = this.sheet.getRow(firstRow).getFirstCellNum();
int lastColumn = this.sheet.getRow(lastRow).getLastCellNum()-1;
String printArea = "$" + getColumnAlphabet(firstColumn)
+ "$" + String.valueOf(firstRow+1)
+ ":$" + getColumnAlphabet(lastColumn)
+ "$" + String.valueOf(lastRow);
return printArea;
}
//C'est la fin du processus de réglage
//Traitement des déplacements
/**
*Définissez la position de la ligne à laquelle se référer
*/
private void setRow() {
if((this.row = sheet.getRow(this.rowIndex)) == null) {
this.row = sheet.createRow(this.rowIndex);
}
}
/**
*Définir la position de la cellule à laquelle se référer
*/
private void setCell() {
if((this.cell = row.getCell(this.columnIndex)) == null) {
this.cell = row.createCell(this.columnIndex);
}
}
/**
*Définir le décalage (quantité de mouvement)
** La valeur par défaut est "1"
* @param offset
*/
public void setOffset(int offset) {
this.offset = offset;
}
/**
*Définissez la position de la ligne et la position de la cellule à
*/
private void setPosition() {
setRow();
setCell();
}
/**
*Définissez la position de la cellule à référencer en spécifiant la ligne et la colonne
* @param rowIndex
*Position de la ligne(0 base)
* @param columnIndex
*Position de la colonne(0 base)
*/
public void setPosition(int rowIndex, int columnIndex) {
this.rowIndex = rowIndex;
this.columnIndex = columnIndex;
setPosition();
}
/**
*Déplacer la position de cellule référencée en fonction du décalage défini
*Position actuelle de la colonne+décalage
*/
public void nextCell() {
moveCell(this.offset);
}
/**
*Déplace la position de la cellule référencée en fonction du décalage spécifié
*Position actuelle de la colonne+décalage
* @param columnOffset
*/
public void moveCell(int columnOffset) {
move(0, columnOffset);
}
/**
*Déplacer la position de ligne référencée en fonction du décalage défini
*Position actuelle de la ligne+décalage
** La position de la colonne est la colonne 0 (A)
*/
public void nextRow() {
nextRow(0);
}
/**
*Déplace la position de ligne référencée en fonction du décalage défini et se déplace vers la position de colonne spécifiée
*Position actuelle de la ligne+décalage
* @param columnIndex
*/
public void nextRow(int columnIndex) {
this.columnIndex = columnIndex;
moveRow(this.offset);
}
/**
*Déplace la position de ligne référencée en fonction du décalage spécifié
*Position actuelle de la ligne+décalage
** La position de la ligne ne change pas
* @param rowOffset
*/
public void moveRow(int rowOffset) {
move(rowOffset, 0);
}
/**
*Déplace la position de ligne et la position de colonne référencées en fonction du décalage de ligne et du décalage de colonne spécifiés.
*Position actuelle de la ligne+Décalage de ligne
*Position actuelle de la colonne+Décalage de colonne
* @param rowOffset
* @param columnOffset
*/
public void move(int rowOffset, int columnOffset) {
this.rowIndex += rowOffset;
this.columnIndex += columnOffset;
setPosition();
}
/**
*Décale les lignes suivantes d'une ligne vers le bas à partir de la position actuelle de la ligne (insérer une ligne)
** Hériter du style et de la hauteur de la rangée supérieure
*/
public void shiftRows() {
int lastRowNum = this.sheet.getLastRowNum();
int lastCellNum = this.sheet.getRow(this.rowIndex-1).getLastCellNum();
this.sheet.shiftRows(this.rowIndex, lastRowNum+1, 1);
Row newRow = this.sheet.getRow(this.rowIndex);
if(newRow == null) {
newRow = this.sheet.createRow(this.rowIndex);
}
Row oldRow = this.sheet.getRow(this.rowIndex-1);
for(int i = 0; i < lastCellNum-1; i++) {
Cell newCell = newRow.createCell(i);
Cell oldCell = oldRow.getCell(i);
//Paramètre de style si oldCell n'est pas nul
//Il y a une limite supérieure au style de cellule qui peut être créé dans wrokbook, donc emballez-le dans la carte
if(oldCell != null) {
if(!styleMap.containsKey(i)) {
CellStyle newStyle = this.sheet.getWorkbook().createCellStyle();
newStyle.cloneStyleFrom(oldCell.getCellStyle());
newStyle.setBorderTop(BorderStyle.DOTTED);
styleMap.put(i, newStyle);
}
newCell.setCellStyle(styleMap.get(i));
}
}
newRow.setHeightInPoints(oldRow.getHeightInPoints());
setPosition();
}
//C'est la fin du processus de déménagement
//Traitement des entrées
/**
*Définissez une valeur de type char dans la cellule et déplacez la position de la colonne référencée en fonction du décalage spécifié
*Définir BLANK s'il n'y a pas de valeur
* @param value
* @param columnOffset
*/
public void setCellValue(char value, int columnOffset) {
setCellValue(String.valueOf(value), columnOffset);
}
/**
*Définissez une valeur de type char dans la cellule et déplacez la position de la colonne référencée en fonction du décalage défini
*Définir BLANK s'il n'y a pas de valeur
* @param value
*/
public void setCellValue(char value) {
setCellValue(value, this.offset);
}
/**
*Définissez une valeur de type String dans la cellule et déplacez la position de la colonne référencée en fonction du décalage spécifié
*Définir BLANK s'il n'y a pas de valeur
* @param value
* @param columnOffset
*/
public void setCellValue(String value, int columnOffset) {
if(value.trim().length() == 0) {
this.cell.setBlank();
}else {
this.cell.setCellValue(value);
}
moveCell(columnOffset);
}
/**
*Définissez une valeur de type String dans la cellule et déplacez la position de la colonne référencée en fonction du décalage défini
*Définir BLANK s'il n'y a pas de valeur
* @param value
*/
public void setCellValue(String value) {
setCellValue(value, this.offset);
}
/**
*Définissez une valeur de type RichTextString sur la cellule et déplacez la position de la colonne référencée en fonction du décalage spécifié
*Définir BLANK s'il n'y a pas de valeur
* @param value
* @param columnOffset
*/
public void setCellValue(RichTextString value, int columnOffset) {
if(value.getString().trim().length() == 0) {
this.cell.setBlank();
}else {
this.cell.setCellValue(value);
}
moveCell(columnOffset);
}
/**
*Définir une valeur de type RichTextString dans la cellule et déplacer la position de la colonne référencée en fonction du décalage défini
*Définir BLANK s'il n'y a pas de valeur
* @param value
*/
public void setCellValue(RichTextString value) {
setCellValue(value, this.offset);
}
/**
*Définissez une valeur de type d'octet dans la cellule et déplacez la position de colonne référencée en fonction du décalage spécifié
* @param value
* @param columnOffset
*/
public void setCellValue(byte value, int columnOffset) {
this.cell.setCellValue(value);
moveCell(columnOffset);
}
/**
*Définissez une valeur de type d'octet dans la cellule et déplacez la position de colonne référencée en fonction du décalage défini
* @param value
*/
public void setCellValue(byte value) {
setCellValue(value, this.offset);
}
/**
*Définissez une valeur de type court dans la cellule et déplacez la position de la colonne référencée en fonction du décalage spécifié
* @param value
* @param columnOffset
*/
public void setCellValue(short value, int columnOffset) {
this.cell.setCellValue(value);
moveCell(columnOffset);
}
/**
*Définissez une valeur de type court dans la cellule et déplacez la position de la colonne référencée en fonction du décalage défini
* @param value
*/
public void setCellValue(short value) {
setCellValue(value, this.offset);
}
/**
*Définissez une valeur de type int dans la cellule et déplacez la position de la colonne référencée en fonction du décalage spécifié
* @param value
* @param columnOffset
*/
public void setCellValue(int value, int columnOffset) {
this.cell.setCellValue(value);
moveCell(columnOffset);
}
/**
*Définissez une valeur de type int dans la cellule et déplacez la position de la colonne référencée en fonction du décalage défini
* @param value
*/
public void setCellValue(int value) {
setCellValue(value, this.offset);
}
/**
*Définissez une valeur longue dans la cellule et déplacez la position de colonne référencée en fonction du décalage spécifié
* @param value
* @param columnOffset
*/
public void setCellValue(long value, int columnOffset) {
this.cell.setCellValue(value);
moveCell(columnOffset);
}
/**
*Définissez une valeur de type long dans la cellule et déplacez la position de la colonne référencée en fonction du décalage défini
* @param value
*/
public void setCellValue(long value) {
setCellValue(value, this.offset);
}
/**
*Définissez une valeur de type double dans la cellule et déplacez la position de colonne référencée en fonction du décalage spécifié
* @param value
* @param columnOffset
*/
public void setCellValue(double value, int columnOffset) {
this.cell.setCellValue(value);
moveCell(columnOffset);
}
/**
*Définissez une valeur de type double dans la cellule et déplacez la position de la colonne référencée en fonction du décalage défini
* @param value
*/
public void setCellValue(double value) {
setCellValue(value, this.offset);
}
/**
*Définissez une valeur de type flottant dans la cellule et déplacez la position de la colonne référencée en fonction du décalage spécifié
* @param value
* @param columnOffset
*/
public void setCellValue(float value, int columnOffset) {
this.cell.setCellValue(value);
moveCell(columnOffset);
}
/**
*Définissez une valeur de type flottant dans la cellule et déplacez la position de la colonne référencée en fonction du décalage défini
* @param value
*/
public void setCellValue(float value) {
setCellValue(value, this.offset);
}
/**
*Définissez une valeur booléenne dans la cellule et déplacez la position de colonne référencée en fonction du décalage spécifié
* @param value
* @param columnOffset
*/
public void setCellValue(boolean value, int columnOffset) {
this.cell.setCellValue(value);
moveCell(columnOffset);
}
/**
*Définissez une valeur de type booléen dans la cellule et déplacez la position de la colonne référencée en fonction du décalage défini.
* @param value
*/
public void setCellValue(boolean value) {
setCellValue(value, this.offset);
}
/**
*Définissez une valeur de type Calendrier dans la cellule et déplacez la position de colonne référencée en fonction du décalage spécifié
* @param value
* @param columnOffset
*/
public void setCellValue(Calendar value, int columnOffset) {
this.cell.setCellValue(value);
moveCell(columnOffset);
}
/**
*Définissez une valeur de type Calendrier dans la cellule et déplacez la position de colonne référencée en fonction du décalage défini
* @param value
*/
public void setCellValue(Calendar value) {
setCellValue(value, this.offset);
}
/**
*Définissez une valeur de type Date dans la cellule et déplacez la position de colonne référencée en fonction du décalage spécifié
* @param value
* @param columnOffset
*/
public void setCellValue(Date value, int columnOffset) {
this.cell.setCellValue(value);
moveCell(columnOffset);
}
/**
*Définissez une valeur de type Date dans la cellule et déplacez la position de colonne référencée en fonction du décalage défini
* @param value
*/
public void setCellValue(Date value) {
setCellValue(value, this.offset);
}
/**
*Définissez une valeur de type LocalDate dans la cellule et déplacez la position de la colonne référencée en fonction du décalage spécifié
* @param value
* @param columnOffset
*/
public void setCellValue(LocalDate value, int columnOffset) {
this.cell.setCellValue(value);
moveCell(columnOffset);
}
/**
*Définissez une valeur de type LocalDate dans la cellule et déplacez la position de colonne référencée en fonction du décalage défini.
* @param value
*/
public void setCellValue(LocalDate value) {
setCellValue(value, this.offset);
}
/**
*Définissez une valeur de type LocalDateTime dans la cellule et déplacez la position de la colonne référencée en fonction du décalage spécifié
* @param value
* @param columnOffset
*/
public void setCellValue(LocalDateTime value, int columnOffset) {
this.cell.setCellValue(value);
moveCell(columnOffset);
}
/**
*Définissez une valeur de type LocalDateTime dans la cellule et déplacez la position de colonne référencée en fonction du décalage défini.
* @param value
*/
public void setCellValue(LocalDateTime value) {
setCellValue(value, this.offset);
}
/**
*Formule de type chaîne("="Je n'ai pas besoin)Vers la cellule et déplacez la position de colonne référencée en fonction du décalage spécifié
* @param value
* @param columnOffset
*/
public void setCellFormula(String value, int columnOffset) {
this.cell.setCellFormula(value);
moveCell(columnOffset);
}
/**
*Formule de type chaîne("="Je n'ai pas besoin)Vers la cellule et déplacez la position de la colonne référencée en fonction du décalage défini
* @param value
*/
public void setCellFormula(String value) {
setCellFormula(value, this.offset);
}
/**
*Définir un commentaire de type String dans une cellule(La zone d'affichage est à valeur fixe)
** La position de la ligne ne bouge pas
* @param commentStr
*/
public void setCellComment(String commentStr) {
CreationHelper helper = sheet.getWorkbook().getCreationHelper();
XSSFDrawing drawing = (XSSFDrawing)sheet.createDrawingPatriarch();
//Valeur décalée de la position de row1(En pixels)
int dx1 = 0;
//Valeur à décaler de la position de col1(En pixels)
int dy1 = 0;
//Valeur à décaler de la position de la ligne2(En pixels)
int dx2 = 0;
//Valeur à décaler de la position de col2(En pixels)
int dy2 = 0;
//Position de la colonne supérieure gauche de la zone d'affichage des commentaires(Unité cellulaire)
int col1 = this.columnIndex + 1;
//Position de la ligne supérieure gauche dans la zone d'affichage des commentaires(Unité cellulaire)
int row1 = this.rowIndex;
//Position de la colonne inférieure droite dans la zone d'affichage des commentaires(Unité cellulaire)
int col2 = this.columnIndex + 4;
//Position de la ligne inférieure droite dans la zone d'affichage des commentaires(Unité cellulaire)
int row2 = this.rowIndex + 3;
ClientAnchor anchor = drawing.createAnchor(dx1, dy1, dx2, dy2, col1, row1, col2, row2);
Comment comment = drawing.createCellComment(anchor);
//comment.setAuthor("master");
comment.setString(helper.createRichTextString(commentStr));
this.cell.setCellComment(comment);
}
/**
*Insérer un graphique à barres à partir de la position actuelle de la cellule(La taille est une valeur fixe)
*/
public void setBarChart() {
XSSFDrawing drawing = (XSSFDrawing)sheet.createDrawingPatriarch();
int dx1 = 0;
int dy1 = 0;
int dx2 = 0;
int dy2 = 0;
int col1 = this.columnIndex;
int row1 = this.rowIndex;
move(16, 10);
int col2 = this.columnIndex;
int row2 = this.rowIndex;
ClientAnchor anchor = drawing.createAnchor(dx1, dy1, dx2, dy2, col1, row1, col2, row2);
XDDFChart chart = (XDDFChart)drawing.createChart(anchor);
CTChart ctChart = ((XSSFChart)chart).getCTChart();
CTPlotArea ctPlotArea = ctChart.getPlotArea();
CTBarChart ctBarChart = ctPlotArea.addNewBarChart();
CTBoolean ctBoolean = ctBarChart.addNewVaryColors();
ctBoolean.setVal(true);
ctBarChart.addNewBarDir().setVal(STBarDir.COL);
for (int r = 4; r < 8; r++) {
CTBarSer ctBarSer = ctBarChart.addNewSer();
CTSerTx ctSerTx = ctBarSer.addNewTx();
CTStrRef ctStrRef = ctSerTx.addNewStrRef();
//Guide d'utilisation
ctStrRef.setF("Agrégat!$B$" + r);
ctBarSer.addNewIdx().setVal(r-4);
CTAxDataSource cttAxDataSource = ctBarSer.addNewCat();
ctStrRef = cttAxDataSource.addNewStrRef();
//article
ctStrRef.setF("Agrégat!$C$3:$I$3");
CTNumDataSource ctNumDataSource = ctBarSer.addNewVal();
CTNumRef ctNumRef = ctNumDataSource.addNewNumRef();
//Zone de données
ctNumRef.setF("Agrégat!$C$" + r + ":$I$" + r);
ctBarSer.addNewSpPr().addNewLn().addNewSolidFill()
.addNewSrgbClr().setVal(new byte[] {0,0,0});
}
int catId = 100;
int valId = 200;
ctBarChart.addNewAxId().setVal(catId);
ctBarChart.addNewAxId().setVal(valId);
CTCatAx ctCatAx = ctPlotArea.addNewCatAx();
ctCatAx.addNewAxId().setVal(catId);
CTScaling ctScaling = ctCatAx.addNewScaling();
ctScaling.addNewOrientation().setVal(STOrientation.MIN_MAX);
ctCatAx.addNewDelete().setVal(false);
ctCatAx.addNewAxPos().setVal(STAxPos.B);
ctCatAx.addNewCrossAx().setVal(valId);
ctCatAx.addNewTickLblPos().setVal(STTickLblPos.NEXT_TO);
CTValAx ctValAx = ctPlotArea.addNewValAx();
ctValAx.addNewAxId().setVal(valId);
ctScaling = ctValAx.addNewScaling();
ctScaling.addNewOrientation().setVal(STOrientation.MIN_MAX);
ctValAx.addNewDelete().setVal(false);
ctValAx.addNewAxPos().setVal(STAxPos.L);
ctValAx.addNewCrossAx().setVal(catId);
ctValAx.addNewTickLblPos().setVal(STTickLblPos.NEXT_TO);
CTLegend ctLegend = ctChart.addNewLegend();
ctLegend.addNewLegendPos().setVal(STLegendPos.B);
ctLegend.addNewOverlay().setVal(false);
}
//Le traitement des entrées se termine ici
//Processus de conversion
/**
*Convertit le numéro de colonne spécifié en notation A1
* @param ascii
* @return
*/
public String getColumnAlphabet(int ascii) {
String alphabet = "";
if(ascii < 26) {
alphabet = String.valueOf((char)(ASCII+ascii));
}else {
int div = ascii / 26;
int mod = ascii % 26;
alphabet = getColumnAlphabet(div-1) + getColumnAlphabet(mod);
}
return alphabet;
}
/**
*Changer le numéro de colonne actuel en notation A1
* @return
*/
public String getColumnAlphabet() {
return getColumnAlphabet(this.columnIndex);
}
//C'est la fin du processus de conversion
}
Pour expliquer en quelques mots -NextCell () passe à la cellule suivante, nextRow () passe à la ligne suivante et la cellule passe à la colonne 0 (colonne A). -Définissez une valeur dans une cellule avec setCellValue () et passez à la cellule suivante. -Depuis que setBarChart () a préparé une cellule pour mettre une valeur dans le modèle, le paramètre de plage est défini sur une valeur fixe. Je bourre ceci et cela et ça devient une classe de Dieu, alors j'ai pensé que je devais le diviser, mais une fois avec ça (rires)
Version terminée de la classe principale
PoiSample.java
package poi.main;
import static poi.common.constant.ExcelConstants.*;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import poi.common.dao.CSVInputDao;
import poi.common.dto.CSVDto;
import poi.common.util.ExcelManager;
public class PoiSample {
public static void main(String[] args) {
System.out.println("début");
FileInputStream fis = null;
FileOutputStream fos = null;
Workbook wb = null;
ExcelManager manager = new ExcelManager();
int rowIndex = 0;
CSVInputDao csvInDao = new CSVInputDao();
CSVDto csvDto = new CSVDto();
Map<Integer, List<CSVDto>> agesMap = new TreeMap<>();
SimpleDateFormat sdFormat = new SimpleDateFormat("yyyy/MM/dd");
csvInDao.setFile(FILE_PATH_INPUT);
try {
fis = new FileInputStream(FILE_PATH_TEMPLATE);
wb = (XSSFWorkbook)WorkbookFactory.create(fis);
wb.createFont().setFontName(FONT);
//Obtenir en spécifiant le nom de la feuille
Sheet sheet = wb.cloneSheet(wb.getSheetIndex(SHEET_NAME_TEMPLATE));
//Réglage du nom de la feuille
wb.setSheetName(wb.getSheetIndex(sheet), SHEET_NAME_ALL_DATA);
System.out.println("createSheet:" + sheet.getSheetName());
manager.setSheet(sheet);
csvInDao.open();
//Toutes les sorties de données
while((csvDto = csvInDao.read()) != null) {
if(rowIndex != 0){
if(rowIndex >= 2) {
manager.shiftRows();
}
int age = Integer.parseInt(csvDto.getAge());
String comment = "téléphone:" + csvDto.getTelephone() + LINE_SEPARATOR
+ "Téléphone portable:" + csvDto.getMobile() + LINE_SEPARATOR
+ "Email:" + csvDto.getMail();
manager.setCellComment(comment);
manager.setCellValue(csvDto.getName());
manager.setCellValue(csvDto.getFurigana());
manager.setCellValue(csvDto.getSex());
manager.setCellValue(age);
manager.setCellValue(sdFormat.parse(csvDto.getBirthDay()));
manager.setCellValue(csvDto.getMarriage());
manager.setCellValue(csvDto.getBloodType());
manager.setCellValue(csvDto.getBirthPlace());
manager.setCellValue(csvDto.getCareer());
//Acquisition d'âge ex)23→20
age = (int)(age / 10) * 10;
if(agesMap.containsKey(age)) {
agesMap.get(age).add(csvDto);
}else {
List<CSVDto> dtoList = new ArrayList<>();
dtoList.add(csvDto);
agesMap.put(age, dtoList);
}
}
rowIndex++;
manager.nextRow();
}
//Paramètres d'impression, plage d'impression
manager.setPrintSetup(wb.getSheetAt(wb.getSheetIndex(SHEET_NAME_TEMPLATE)).getPrintSetup());
wb.setPrintArea(wb.getSheetIndex(sheet), manager.getPrintArea());
//Sortie en divisant en feuilles pour chaque âge
List<String> sheetNames = new ArrayList<>();
for(Map.Entry<Integer, List<CSVDto>> ageMap : agesMap.entrySet()) {
String sheetName = String.valueOf(ageMap.getKey()) + "Remplacer";
if((sheet = wb.getSheet(sheetName)) == null) {
sheet = wb.cloneSheet(wb.getSheetIndex(SHEET_NAME_TEMPLATE));
wb.setSheetName(wb.getSheetIndex(sheet), sheetName);
}
sheetNames.add(sheet.getSheetName());
System.out.println("createSheet:" + sheet.getSheetName());
manager.setSheet(sheet);
rowIndex = 1;
manager.nextRow();
for(CSVDto nextDto: ageMap.getValue()) {
if(rowIndex >= 2) {
manager.shiftRows();
}
String comment = "téléphone:" + nextDto.getTelephone() + LINE_SEPARATOR
+ "Téléphone portable:" + nextDto.getMobile() + LINE_SEPARATOR
+ "Email:" + nextDto.getMail();
manager.setCellComment(comment);
manager.setCellValue(nextDto.getName());
manager.setCellValue(nextDto.getFurigana());
manager.setCellValue(nextDto.getSex());
manager.setCellValue(Integer.parseInt(nextDto.getAge()));
manager.setCellValue(sdFormat.parse(nextDto.getBirthDay()));
manager.setCellValue(nextDto.getMarriage());
manager.setCellValue(nextDto.getBloodType());
manager.setCellValue(nextDto.getBirthPlace());
manager.setCellValue(nextDto.getCareer());
rowIndex++;
manager.nextRow();
}
//Paramètres d'impression, plage d'impression
manager.setPrintSetup(wb.getSheetAt(wb.getSheetIndex(SHEET_NAME_TEMPLATE)).getPrintSetup());
wb.setPrintArea(wb.getSheetIndex(sheet), manager.getPrintArea());
}
//La production globale
sheet = wb.cloneSheet(wb.getSheetIndex(SHEET_NAME_GRAPH_TEMPLATE));
wb.setSheetName(wb.getSheetIndex(sheet), SHEET_NAME_AGGREGATED);
System.out.println("createSheet:" + sheet.getSheetName());
manager.setSheet(sheet);
String formula = "";
for(rowIndex = 3; 7 >= rowIndex; rowIndex++) {
manager.setPosition(rowIndex, 2);
for(String sheetName: sheetNames) {
if(rowIndex == 7) {
formula = "SUM($" + manager.getColumnAlphabet() + "$4:$"
+ manager.getColumnAlphabet() +"$7)";
}else {
formula = "COUNTIF(\'" + sheetName + "\'!$I:$I,$B$" + String.valueOf(rowIndex+1) + ")";
}
manager.setCellFormula(formula);
}
}
//La formule n'est pas calculée simplement en la définissant, alors recalculez
wb.getCreationHelper().createFormulaEvaluator().evaluateAll();
rowIndex++;
manager.setPosition(rowIndex, 1);
//Paramètres du graphique à barres
manager.setBarChart();
//Paramètres d'impression, plage d'impression
manager.setPrintSetup(wb.getSheetAt(wb.getSheetIndex(SHEET_NAME_GRAPH_TEMPLATE)).getPrintSetup());
wb.setPrintArea(wb.getSheetIndex(sheet), manager.getPrintArea());
//Supprimer les modèles inutiles
wb.removeSheetAt(wb.getSheetIndex(SHEET_NAME_TEMPLATE));
wb.removeSheetAt(wb.getSheetIndex(SHEET_NAME_GRAPH_TEMPLATE));
//Sortie de fichier
fos = new FileOutputStream(FILE_PATH_OUTPUT);
wb.write(fos);
System.out.println("Fin");
}catch(Exception e) {
e.printStackTrace();
}finally {
if(fis != null) {
try {
fis.close();
}catch(IOException e) {
}
}
if(fos != null) {
try {
fos.close();
}catch(IOException e) {
}
}
if(wb != null) {
try {
wb.close();
}catch(IOException e) {
}
}
}
}
}
5. Résumé
Il y avait beaucoup de choses que je ne comprenais pas, alors j'ai fait un essai et une erreur. Cependant, j'ai réussi à lire le fichier csv, à afficher toutes les données, à afficher par âge et à afficher le total! J'ai personnellement créé la classe Manager, ce qui a facilité sa mise en œuvre, mais je pense que j'aurais dû utiliser l'héritage en divisant la classe en fonction du contenu de traitement car j'ai emballé trop de choses. Je ne suis pas doué pour hériter, donc je dois étudier.
Merci d'avoir regardé jusqu'au bout! Enfin, je publierai à nouveau le lien github!
github https://github.com/y012/POI_Sample.git
Recommended Posts