[JAVA] Excel-Operation mit Apache POI

Einführung

Ich habe versucht, mit Apache POI von CSV nach Excel auszugeben. Ich gebe auch ein Balkendiagramm aus. Es ist so

template.xlsx output.xlsx
template.gif output.gif

Da ich ein Anfänger bin, denke ich, dass es viele Punkte gibt, die ich nicht erreichen kann, aber ich würde mich über Ihre Meinung freuen.

github https://github.com/y012/POI_Sample.git

Inhaltsverzeichnis

  1. Über Apache POI
  2. Nutzungsumgebung
  3. Vorbereitung
  4. Implementierung
  5. Zusammenfassung

1. Über Apache POI

Was ist Apache POI überhaupt? Es begann von.

Als ich es nachgeschlagen habe, scheint es, dass ich Dateien im Microsoft Office-Format bearbeiten kann. (Zusätzlich zu Excel, Word, PowerPoint usw.)

wiki https://ja.wikipedia.org/wiki/Apache_POI API Document https://poi.apache.org/apidocs/dev/overview-summary.html

Dieses Mal werden wir, wie der Titel schon sagt, Excel betreiben!

2. Nutzungsumgebung

3. Vorbereitung

Apache POI https://poi.apache.org/index.html

Download über den Link → poi-bin- ～ .zip → Download über den Link, den Sie im roten Rahmen erhalten Diesmal habe ich die zweite von oben heruntergeladen.

poi_download_1.png poi_download_2.png

・ Entpacken, Pfad erstellen Klicken Sie mit der rechten Maustaste auf das Projekt, das Sie hinzufügen möchten → Neu → Ordner Erstellen Sie dann einen lib-Ordner und entpacken Sie die heruntergeladene Zip-Datei in den lib-Ordner. Dieses Mal habe ich den Erstellungspfad durch alle JAR-Dateien im entpackten Ordner gelegt!

・ Eingabedaten (.csv) Diesmal wurden die Eingabedaten von der unten stehenden Seite vorbereitet!

Was für eine persönliche Information http://kazina.com/dummy/

Es scheint interessant zu sein, wie man Curry isst, aber diesmal lehnte ich ab.

・ Vorlage erstellen (.xlsx) Das Festlegen von Schriftarten und Stilen mit POI von 1 ist schwierig ~~ mühsam ~~, erstellen Sie also zuerst eine Vorlage!

4. Implementierung

Die Vorbereitungen sind beendet und es wird endlich umgesetzt. Verwenden Sie XSSF oder HSSF, wenn Sie mit Excel mit Apache POI arbeiten. Es gibt ungefähr die folgenden Unterschiede, und dieses Mal werden wir XSSF verwenden.

HSSF ～Excel2003(.xls)
XSSF Excel2007(.xlsx)～

Lesen Sie vorerst die Vorlagendatei und geben Sie sie aus

FileInputStream fis = null;
FileOutputStream fos = null;
Workbook wb = null;

try{
	//Vorlagendatei abrufen
	fis = new FileInputStream("Vorlagendateipfad");
	wb = (XSSFWorkbook)WorkbookFactory.create(fis);
	//Standardschriftarteneinstellungen
	wb.createFont().setFontName("Schriftartenname");

	// (1)start
	//Duplizieren Sie das Blatt aus der Vorlage und legen Sie den Blattnamen fest
	//Das Duplikat wird dem letzten Blatt in der Arbeitsmappe hinzugefügt
	Sheet sheet = wb.cloneSheet(wb.getSheetIndex("Name des Vorlagenblatts"));
	wb.setSheetName(wb.getSheetIndex(sheet), "Name des Ausgabeblatts");
	
	//Holen Sie sich Zeilen, Zellen(Kann nicht spaltenweise abgerufen werden)
	//Erstellen, da die Zeile oder Zelle im Standardzustand null ist
	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);
	}
	
	//Auf A1 einstellen
	cell.setCellValue("Hello World!!");
	
	// (1)end
	
	//Ausgabe in Ausgabedatei
	fos = new FileOutputStream("Pfad der Ausgabedatei");
	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) {
		}
	}
}

Damit können Sie ausgeben, ohne die Vorlagendatei zu ändern. Da der Wert jedoch für jede Zelle festgelegt ist, muss der Bereich von (1) viele Male wiederholt werden. Aus diesem Grund habe ich eine Manager-Klasse erstellt, die die Verschiebungsverarbeitung und die Eingabeverarbeitung zusammenfasst.

Manager-Klassenerstellung

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;

	//Einstellvorgang

	/**
	 *Stellen Sie das Blatt ein und stellen Sie die Position der Referenzzelle auf "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;
	}

	/**
	 *Kopieren Sie die Druckeinstellungen der Vorlage
	 * @param printSetup
	 */
	public void setPrintSetup(PrintSetup printSetup) {
		PrintSetup newSetup = this.sheet.getPrintSetup();

		//Anzahl der Kopien
		newSetup.setCopies(printSetup.getCopies());
		//Entwurfsmodus
		//newSetup.setDraft(printSetup.getDraft());
		//Anzahl der Seiten, die hoch genug sind, um auf das Blatt zu passen
		newSetup.setFitHeight(printSetup.getFitHeight());
		//Anzahl der Seiten, die breit genug sind, um auf das Blatt zu passen
		newSetup.setFitWidth(printSetup.getFitWidth());
		//Fußzeilenrand
		//newSetup.setFooterMargin(printSetup.getFooterMargin());
		//Header-Rand
		//newSetup.setHeaderMargin(printSetup.getHeaderMargin());
		//Horizontale Auflösung
		//newSetup.setHResolution(printSetup.getHResolution());
		//Querformat
		newSetup.setLandscape(printSetup.getLandscape());
		//Druckauftrag von links nach rechts
		//newSetup.setLeftToRight(printSetup.getLeftToRight());
		//Schwarz und weiß
		newSetup.setNoColor(printSetup.getNoColor());
		//Richtung
		newSetup.setNoOrientation(printSetup.getNoOrientation());
		//Memo drucken
		//newSetup.setNotes(printSetup.getNotes());
		//Startseite
		//newSetup.setPageStart(printSetup.getPageStart());
		//Papiergröße
		newSetup.setPaperSize(printSetup.getPaperSize());
		//Rahmen
		newSetup.setScale(printSetup.getScale());
		//Seitenzahl verwendet
		//newSetup.setUsePage(printSetup.getUsePage());
		//Gültige Einstellungen
		//newSetup.setValidSettings(printSetup.getValidSettings());
		//Vertikale Auflösung
		//newSetup.setVResolution(printSetup.getVResolution());

	}

	/**
	 *Druckbereich abrufen
	 * @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;
	}

	//Dies ist das Ende des Einstellungsprozesses

	//Verarbeitung verschieben

	/**
	 *Stellen Sie die Linienposition ein, auf die Bezug genommen werden soll
	 */
	private void setRow() {
		if((this.row = sheet.getRow(this.rowIndex)) == null) {
			this.row = sheet.createRow(this.rowIndex);
		}
	}

	/**
	 *Stellen Sie die Zellenposition ein, auf die Bezug genommen werden soll
	 */
	private void setCell() {
		if((this.cell = row.getCell(this.columnIndex)) == null) {
			this.cell = row.createCell(this.columnIndex);
		}
	}

	/**
	 *Stellen Sie den Versatz (Bewegungsbetrag) ein.
	 ** Der Standardwert ist "1"
	 * @param offset
	 */
	public void setOffset(int offset) {
		this.offset = offset;
	}

	/**
	 *Stellen Sie die Zeilenposition und die Zellenposition ein, auf die Bezug genommen werden soll
	 */
	private void setPosition() {
		setRow();
		setCell();
	}

	/**
	 *Legen Sie die Zellenposition fest, auf die verwiesen werden soll, indem Sie die Zeile und Spalte angeben
	 * @param rowIndex
	 *Linienposition(0 Basis)
	 * @param columnIndex
	 *Spaltenposition(0 Basis)
	 */
	public void setPosition(int rowIndex, int columnIndex) {
		this.rowIndex = rowIndex;
		this.columnIndex = columnIndex;
		setPosition();
	}

	/**
	 *Verschieben Sie die referenzierte Zellenposition entsprechend dem eingestellten Versatz
	 *Aktuelle Spaltenposition+Versatz
	 */
	public void nextCell() {
		moveCell(this.offset);
	}

	/**
	 *Verschiebt die referenzierte Zellenposition entsprechend dem angegebenen Versatz
	 *Aktuelle Spaltenposition+Versatz
	 * @param columnOffset
	 */
	public void moveCell(int columnOffset) {
		move(0, columnOffset);
	}

	/**
	 *Verschieben Sie die Position der referenzierten Linie entsprechend dem eingestellten Versatz
	 *Aktuelle Leitungsposition+Versatz
	 ** Die Spaltenposition ist 0 (A) Spalte
	 */
	public void nextRow() {
		nextRow(0);
	}

	/**
	 *Verschiebt die referenzierte Zeilenposition entsprechend dem eingestellten Versatz und bewegt sich an die angegebene Spaltenposition
	 *Aktuelle Leitungsposition+Versatz
	 * @param columnIndex
	 */
	public void nextRow(int columnIndex) {
		this.columnIndex = columnIndex;
		moveRow(this.offset);
	}

	/**
	 *Verschiebt die referenzierte Zeilenposition entsprechend dem angegebenen Versatz
	 *Aktuelle Leitungsposition+Versatz
	 ** Die Zeilenposition ändert sich nicht
	 * @param rowOffset
	 */
	public void moveRow(int rowOffset) {
		move(rowOffset, 0);
	}

	/**
	 *Verschiebt die referenzierte Zeilenposition und Spaltenposition entsprechend dem angegebenen Zeilenversatz und Spaltenversatz.
	 *Aktuelle Leitungsposition+Zeilenversatz
	 *Aktuelle Spaltenposition+Spaltenversatz
	 * @param rowOffset
	 * @param columnOffset
	 */
	public void move(int rowOffset, int columnOffset) {
		this.rowIndex += rowOffset;
		this.columnIndex += columnOffset;
		setPosition();
	}

	/**
	 *Verschiebt nachfolgende Zeilen um eine Zeile von der aktuellen Zeilenposition nach unten (Zeile einfügen)
	 ** Erben Sie den Stil und die Höhe der oberen Reihe
	 */
	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);
			//Stileinstellung, wenn oldCell nicht null ist
			//Es gibt eine Obergrenze für den Zellenstil, der im Wrokbook erstellt werden kann. Packen Sie ihn also in die Karte
			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();
	}

	//Dies ist das Ende des Verschiebungsprozesses

	//Eingabeverarbeitung

	/**
	 *Legen Sie einen Wert für den Zeichentyp in der Zelle fest und verschieben Sie die Position der referenzierten Spalte entsprechend dem angegebenen Versatz
	 *Setzen Sie BLANK, wenn kein Wert vorhanden ist
	 * @param value
	 * @param columnOffset
	 */
	public void setCellValue(char value, int columnOffset) {
		setCellValue(String.valueOf(value), columnOffset);
	}
	/**
	 *Legen Sie einen Wert für den Zeichentyp in der Zelle fest und verschieben Sie die Position der referenzierten Spalte entsprechend dem festgelegten Versatz
	 *Setzen Sie BLANK, wenn kein Wert vorhanden ist
	 * @param value
	 */
	public void setCellValue(char value) {
		setCellValue(value, this.offset);
	}

	/**
	 *Legen Sie einen Wert vom Typ String in der Zelle fest und verschieben Sie die Position der referenzierten Spalte entsprechend dem angegebenen Versatz
	 *Setzen Sie BLANK, wenn kein Wert vorhanden ist
	 * @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);
	}

	/**
	 *Legen Sie einen Wert vom Typ String in der Zelle fest und verschieben Sie die Position der referenzierten Spalte entsprechend dem festgelegten Versatz
	 *Setzen Sie BLANK, wenn kein Wert vorhanden ist
	 * @param value
	 */
	public void setCellValue(String value) {
		setCellValue(value, this.offset);
	}

	/**
	 *Legen Sie einen Wert vom Typ RichTextString für die Zelle fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem angegebenen Versatz
	 *Setzen Sie BLANK, wenn kein Wert vorhanden ist
	 * @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);
	}

	/**
	 *Legen Sie einen RichTextString-Typwert in der Zelle fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem festgelegten Versatz
	 *Setzen Sie BLANK, wenn kein Wert vorhanden ist
	 * @param value
	 */
	public void setCellValue(RichTextString value) {
		setCellValue(value, this.offset);
	}

	/**
	 *Legen Sie einen Bytetypwert in der Zelle fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem angegebenen Versatz
	 * @param value
	 * @param columnOffset
	 */
	public void setCellValue(byte value, int columnOffset) {
		this.cell.setCellValue(value);
		moveCell(columnOffset);
	}

	/**
	 *Legen Sie einen Bytetypwert in der Zelle fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem eingestellten Versatz
	 * @param value
	 */
	public void setCellValue(byte value) {
		setCellValue(value, this.offset);
	}

	/**
	 *Legen Sie einen kurzen Typwert in der Zelle fest und verschieben Sie die Position der referenzierten Spalte entsprechend dem angegebenen Versatz
	 * @param value
	 * @param columnOffset
	 */
	public void setCellValue(short value, int columnOffset) {
		this.cell.setCellValue(value);
		moveCell(columnOffset);
	}

	/**
	 *Legen Sie einen kurzen Typwert in der Zelle fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem eingestellten Versatz
	 * @param value
	 */
	public void setCellValue(short value) {
		setCellValue(value, this.offset);
	}

	/**
	 *Legen Sie einen Int-Typ-Wert in der Zelle fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem angegebenen Versatz
	 * @param value
	 * @param columnOffset
	 */
	public void setCellValue(int value, int columnOffset) {
		this.cell.setCellValue(value);
		moveCell(columnOffset);
	}

	/**
	 *Legen Sie einen Int-Typ-Wert in der Zelle fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem festgelegten Versatz
	 * @param value
	 */
	public void setCellValue(int value) {
		setCellValue(value, this.offset);
	}

	/**
	 *Legen Sie einen langen Wert in der Zelle fest und verschieben Sie die Position der referenzierten Spalte entsprechend dem angegebenen Versatz
	 * @param value
	 * @param columnOffset
	 */
	public void setCellValue(long value, int columnOffset) {
		this.cell.setCellValue(value);
		moveCell(columnOffset);
	}

	/**
	 *Legen Sie einen langen Typwert in der Zelle fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem eingestellten Versatz
	 * @param value
	 */
	public void setCellValue(long value) {
		setCellValue(value, this.offset);
	}

	/**
	 *Legen Sie einen doppelten Typwert in der Zelle fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem angegebenen Versatz
	 * @param value
	 * @param columnOffset
	 */
	public void setCellValue(double value, int columnOffset) {
		this.cell.setCellValue(value);
		moveCell(columnOffset);
	}

	/**
	 *Legen Sie einen doppelten Typwert in der Zelle fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem festgelegten Versatz
	 * @param value
	 */
	public void setCellValue(double value) {
		setCellValue(value, this.offset);
	}

	/**
	 *Legen Sie einen Gleitkommawert in der Zelle fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem angegebenen Versatz
	 * @param value
	 * @param columnOffset
	 */
	public void setCellValue(float value, int columnOffset) {
		this.cell.setCellValue(value);
		moveCell(columnOffset);
	}

	/**
	 *Legen Sie einen Gleitkommawert in der Zelle fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem eingestellten Versatz
	 * @param value
	 */
	public void setCellValue(float value) {
		setCellValue(value, this.offset);
	}

	/**
	 *Legen Sie einen booleschen Wert in der Zelle fest und verschieben Sie die Position der referenzierten Spalte entsprechend dem angegebenen Versatz
	 * @param value
	 * @param columnOffset
	 */
	public void setCellValue(boolean value, int columnOffset) {
		this.cell.setCellValue(value);
		moveCell(columnOffset);
	}

	/**
	 *Legen Sie einen booleschen Typwert in der Zelle fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem festgelegten Versatz.
	 * @param value
	 */
	public void setCellValue(boolean value) {
		setCellValue(value, this.offset);
	}

	/**
	 *Legen Sie einen Kalendertypwert in der Zelle fest und verschieben Sie die Position der referenzierten Spalte entsprechend dem angegebenen Versatz
	 * @param value
	 * @param columnOffset
	 */
	public void setCellValue(Calendar value, int columnOffset) {
		this.cell.setCellValue(value);
		moveCell(columnOffset);
	}

	/**
	 *Legen Sie einen Kalendertypwert in der Zelle fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem festgelegten Versatz
	 * @param value
	 */
	public void setCellValue(Calendar value) {
		setCellValue(value, this.offset);
	}

	/**
	 *Legen Sie einen Datumswert in der Zelle fest und verschieben Sie die Position der referenzierten Spalte entsprechend dem angegebenen Versatz
	 * @param value
	 * @param columnOffset
	 */
	public void setCellValue(Date value, int columnOffset) {
		this.cell.setCellValue(value);
		moveCell(columnOffset);
	}

	/**
	 *Legen Sie in der Zelle einen Wert für den Datumstyp fest und verschieben Sie die Position der referenzierten Spalte entsprechend dem festgelegten Versatz
	 * @param value
	 */
	public void setCellValue(Date value) {
		setCellValue(value, this.offset);
	}

	/**
	 *Legen Sie in der Zelle einen Wert vom Typ LocalDate fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem angegebenen Versatz
	 * @param value
	 * @param columnOffset
	 */
	public void setCellValue(LocalDate value, int columnOffset) {
		this.cell.setCellValue(value);
		moveCell(columnOffset);
	}

	/**
	 *Legen Sie in der Zelle einen Wert vom Typ LocalDate fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem festgelegten Versatz.
	 * @param value
	 */
	public void setCellValue(LocalDate value) {
		setCellValue(value, this.offset);
	}

	/**
	 *Legen Sie in der Zelle einen Wert vom Typ LocalDateTime fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem angegebenen Versatz
	 * @param value
	 * @param columnOffset
	 */
	public void setCellValue(LocalDateTime value, int columnOffset) {
		this.cell.setCellValue(value);
		moveCell(columnOffset);
	}

	/**
	 *Legen Sie in der Zelle einen Wert vom Typ LocalDateTime fest und verschieben Sie die referenzierte Spaltenposition entsprechend dem festgelegten Versatz.
	 * @param value
	 */
	public void setCellValue(LocalDateTime value) {
		setCellValue(value, this.offset);
	}

	/**
	 *Zeichenfolgentypformel("="Ich brauche nicht)In die Zelle und verschieben Sie die referenzierte Spaltenposition entsprechend dem angegebenen Versatz
	 * @param value
	 * @param columnOffset
	 */
	public void setCellFormula(String value, int columnOffset) {
		this.cell.setCellFormula(value);
		moveCell(columnOffset);
	}

	/**
	 *Zeichenfolgentypformel("="Ich brauche nicht)In die Zelle und verschieben Sie die referenzierte Spaltenposition entsprechend dem eingestellten Versatz
	 * @param value
	 */
	public void setCellFormula(String value) {
		setCellFormula(value, this.offset);
	}

	/**
	 *Legen Sie einen Kommentar vom Typ String in einer Zelle fest(Anzeigebereich ist fester Wert)
	 ** Die Zeilenposition bewegt sich nicht
	 * @param commentStr
	 */
	public void setCellComment(String commentStr) {
		CreationHelper helper = sheet.getWorkbook().getCreationHelper();
		XSSFDrawing drawing = (XSSFDrawing)sheet.createDrawingPatriarch();
		//Wert, der von der Position von Zeile1 verschoben werden soll(In Pixel)
		int dx1 = 0;
		//Wert, der von der Position von col1 verschoben werden soll(In Pixel)
		int dy1 = 0;
		//Wert, der von der Position von Zeile 2 verschoben werden soll(In Pixel)
		int dx2 = 0;
		//Wert, der von der Position von col2 verschoben werden soll(In Pixel)
		int dy2 = 0;
		//Position des Kommentarbereichs in der oberen linken Spalte(Zelleneinheit)
		int col1 = this.columnIndex + 1;
		//Position der oberen linken Zeile im Kommentaranzeigebereich(Zelleneinheit)
		int row1 = this.rowIndex;
		//Position der unteren rechten Spalte im Anzeigebereich für Kommentare(Zelleneinheit)
		int col2 = this.columnIndex + 4;
		//Position der unteren rechten Zeile im Kommentaranzeigebereich(Zelleneinheit)
		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);
	}

	/**
	 *Balkendiagramm von der aktuellen Zellenposition einfügen(Die Größe ist ein fester Wert)
	 */
	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();
           //Gebrauchsanweisung
           ctStrRef.setF("Aggregat!$B$" + r);
           ctBarSer.addNewIdx().setVal(r-4);
           CTAxDataSource cttAxDataSource = ctBarSer.addNewCat();
           ctStrRef = cttAxDataSource.addNewStrRef();
           //Artikel
           ctStrRef.setF("Aggregat!$C$3:$I$3");
           CTNumDataSource ctNumDataSource = ctBarSer.addNewVal();
           CTNumRef ctNumRef = ctNumDataSource.addNewNumRef();
           //Datenbereich
           ctNumRef.setF("Aggregat!$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);
	}

	//Die Eingabeverarbeitung endet hier

	//Umwandlungsprozess

	/**
	 *Konvertiert die angegebene Spaltennummer in die A1-Notation
	 * @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;
	}

	/**
	 *Ändern Sie die aktuelle Spaltennummer in A1-Notation
	 * @return
	 */
	public String getColumnAlphabet() {
		return getColumnAlphabet(this.columnIndex);
	}

	//Dies ist das Ende des Konvertierungsprozesses

}

Auf den Punkt gebracht -NextCell () wechselt zur nächsten Zelle, nextRow () wechselt zur nächsten Zeile und die Zelle wechselt zur Spalte 0 (Spalte A).

Abgeschlossene Version der Hauptklasse

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("Start");

		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);
			//Holen Sie sich durch Angabe des Blattnamens
			Sheet sheet = wb.cloneSheet(wb.getSheetIndex(SHEET_NAME_TEMPLATE));

			//Einstellung des Blattnamens
			wb.setSheetName(wb.getSheetIndex(sheet), SHEET_NAME_ALL_DATA);

			System.out.println("createSheet:" + sheet.getSheetName());

			manager.setSheet(sheet);

			csvInDao.open();

			//Alle Daten ausgeben
			while((csvDto = csvInDao.read()) != null) {
				if(rowIndex != 0){
					if(rowIndex >= 2) {
						manager.shiftRows();
					}

					int age = Integer.parseInt(csvDto.getAge());
					String comment = "Telefon:" + csvDto.getTelephone() + LINE_SEPARATOR
							+ "Mobiltelefon:" + 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());
					//Alterserwerb 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();
			}
			//Druckeinstellungen, Druckbereich
			manager.setPrintSetup(wb.getSheetAt(wb.getSheetIndex(SHEET_NAME_TEMPLATE)).getPrintSetup());
			wb.setPrintArea(wb.getSheetIndex(sheet), manager.getPrintArea());


			//Ausgabe durch Aufteilung in Blätter für jedes Alter
			List<String> sheetNames = new ArrayList<>();
			for(Map.Entry<Integer, List<CSVDto>> ageMap : agesMap.entrySet()) {
				String sheetName = String.valueOf(ageMap.getKey()) + "Ersatz";
				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 = "Telefon:" + nextDto.getTelephone() + LINE_SEPARATOR
							+ "Mobiltelefon:" + 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();
				}
				//Druckeinstellungen, Druckbereich
				manager.setPrintSetup(wb.getSheetAt(wb.getSheetIndex(SHEET_NAME_TEMPLATE)).getPrintSetup());
				wb.setPrintArea(wb.getSheetIndex(sheet), manager.getPrintArea());
			}


			//Gesamtausgabe
			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);
				}
			}
			//Die Formel wird nicht nur durch Einstellen berechnet, sondern neu berechnet
			wb.getCreationHelper().createFormulaEvaluator().evaluateAll();
			rowIndex++;
			manager.setPosition(rowIndex, 1);
			//Balkendiagrammeinstellungen
			manager.setBarChart();

			//Druckeinstellungen, Druckbereich
			manager.setPrintSetup(wb.getSheetAt(wb.getSheetIndex(SHEET_NAME_GRAPH_TEMPLATE)).getPrintSetup());
			wb.setPrintArea(wb.getSheetIndex(sheet), manager.getPrintArea());

			//Löschen Sie unnötige Vorlagen
			wb.removeSheetAt(wb.getSheetIndex(SHEET_NAME_TEMPLATE));
			wb.removeSheetAt(wb.getSheetIndex(SHEET_NAME_GRAPH_TEMPLATE));

			//Dateiausgabe
			fos = new FileOutputStream(FILE_PATH_OUTPUT);
			wb.write(fos);

			System.out.println("Ende");

		}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. Zusammenfassung

Es gab viele Dinge, die ich nicht verstand, also machte ich einen Versuch und Irrtum. Es gelang mir jedoch, die CSV-Datei zu lesen, alle Daten auszugeben, nach Alter auszugeben und die Gesamtsumme auszugeben! Ich habe persönlich die Manager-Klasse erstellt, was die Implementierung vereinfacht hat, aber ich denke, ich hätte die Vererbung verwenden sollen, indem ich die Klasse nach dem Verarbeitungsinhalt aufgeteilt habe, weil ich zu viele Dinge gepackt habe. Ich kann nicht gut erben, also muss ich lernen.

Danke, dass du bis zum Ende zugesehen hast! Zum Schluss werde ich den Github-Link wieder veröffentlichen!

github https://github.com/y012/POI_Sample.git

Recommended Posts

Excel-Operation mit Apache POI
Ausgabe nach Excel mit Apache POI!
[Java] Erstellen einer Excel-Datei mit Apache POI
[Apache POI] Entsprechende Excel-Version
Bearbeiten Sie Excel mit Apache POI
Apache POI Excel mit Kotlin
gemeinsamer Export, um mit Poi zu übertreffen
[Java] Behandeln Sie Excel-Dateien mit Apache POI
[Java] Textextraktion aus PowerPoint (ppt) mit Apache POI
Ersetzen Sie Text in der AutoShape of Excel-Datei durch Apache POI
Apache POI Addictive Point List
Datenverarbeitung mit Apache Flink
Apache POI persönliches Memo Crossfish21
Elasticsearch-Vorgang über die REST-API mit Apache HttpClient in Java
Signieren Sie XML mit Apache Santuario
Ich habe versucht, Apache Wicket zu verwenden
Verwendung von Apache POI
Erstellen Sie eine Excel-Datei mit poi
[Apache POI] Beurteilung unnötiger Zellen
Hinweise zum Lesen und Generieren von XLSX-Dateien aus Java mit Apache POI