Soy consciente de los postes que están alrededor, he probado varios intentos para alcanzar mi objetivo, como voy a elaborar a continuación:
Tengo un .zip/ .rar, que contiene múltiples xlsy xlsxarchivos.
Cada archivo de Excel contiene duzens hasta miles de filas, columnas alrededor de 90 o menos (cada archivo de Excel pueden tener más o menos columnas).
He creado una aplicación java WindowBuilder, donde selecciono un .zip/ .rararchivo y seleccione dónde descomprimir estos archivos y crearlos utilizando FileOutputStream. Después de cada archivo que se guarda, estoy leyendo el archivo de su contenido.
Hasta aquí todo bien. Después de varios intentos de evitar OOM (OutOfMemory) y acelerar las cosas, he llegado a la 'versión final' (que es bastante horrible pero es hasta que encontrar la manera de leer cosas correctamente) que explicaré:
File file = new File('certainFile.xlsx'); //or xls, For example purposes
Workbook wb;
Sheet sheet;
/*
There is a ton of other things up to this point that I don't consider relevant, as it's related to unzipping and renaming, etc.
This is within a cycle
/
In every zip file, there is at least 1 or 2 files that somehow, when it goes to
WorkbookFactory.create(), it still gives an OOM because it recognizes is has
a bit over a million rows, meaning it's an 2007 format file (according to our friend Google.com), or so I believe so.
When I open the xlsx file, it indeed has like 10-20mb size and thousands of empty rows. When I save it again
it has 1mb and a couple thousand. After many attempts to read as InputStream, File or trying to save it in
an automatic way, I've worked with converting it to a CSV and read it differently,
ence, this 'solution'. if parseAsXLS is true, it applies my regular logic
per row per cell, otherwise I parse the CSV.
*/
if (file.getName().contains("xlsx")) {
this.parseAsXLS = false;
OPCPackage pkg = OPCPackage.open(file);
//This is just to output the content into a csv file, that I will read later on and it gets overwritten everytime it comes by
FileOutputStream fo = new FileOutputStream(this.filePath + File.separator + "excel.csv");
PrintStream ps = new PrintStream(fo);
XLSX2CSV xlsxCsvConverter = new XLSX2CSV(pkg, ps, 90);
try {
xlsxCsvConverter.process();
} catch (Exception e) {
//I've added a count at the XLSX2CSV class in order to limit the ammount of rows I want to fetch and throw an Exception on purpose
System.out.println("Limited the file at 60k rows");
}
} else {
this.parseAsXLS = true;
this.wb = WorkbookFactory.create(file);
this.sheet = wb.getSheetAt(0);
}
Lo que sucede ahora es que un .xlsx(a partir de un .ziparchivo con varios otros .xlsy .xlsx) tiene algo de cierto personaje en una fila y la XLSX2CSV considera como Filafinal, lo que resulta en una salida incorrecta.
Este es un ejemplo: ImageLink
Nota: El objetivo es sólo para buscar un cierto conjunto de columnas que tienen en commum (o podrían tener, no obligado) de cada archivo de Excel y ponerlos juntos en un nuevo cálculo de Excel. La columna de correo electrónico (que contiene varios correos electrónicos separados por una coma), tiene lo que yo creo que es un 'Enter' antes de que el correo electrónico, ya que si lo borro manualmente, se soluciona el problema. Sin embargo, el objetivo es no abrir manualmente cada excel y fijarlo, de lo contrario estaría simplemente abierto todos los Excel y copiar y pegar las columnas que necesitaría. En ese ejemplo, yo requiero columnas: fieldAA , fieldAG , fieldAL y fieldAN .
XLSX2CSV.java (no soy el creador de este archivo, simplemente apliqué mis necesidades a ella)
import java.awt.List;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import javax.xml.parsers.ParserConfigurationException;
import org.apache.poi.openxml4j.exceptions.OpenXML4JException;
import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.openxml4j.opc.PackageAccess;
import org.apache.poi.ss.usermodel.DataFormatter;
import org.apache.poi.ss.util.CellAddress;
import org.apache.poi.ss.util.CellReference;
import org.apache.poi.util.SAXHelper;
import org.apache.poi.xssf.eventusermodel.ReadOnlySharedStringsTable;
import org.apache.poi.xssf.eventusermodel.XSSFReader;
import org.apache.poi.xssf.eventusermodel.XSSFSheetXMLHandler;
import org.apache.poi.xssf.eventusermodel.XSSFSheetXMLHandler.SheetContentsHandler;
import org.apache.poi.xssf.extractor.XSSFEventBasedExcelExtractor;
import org.apache.poi.xssf.model.StylesTable;
import org.apache.poi.xssf.usermodel.XSSFComment;
import org.xml.sax.ContentHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
/**
* A rudimentary XLSX -> CSV processor modeled on the
* POI sample program XLS2CSVmra from the package
* org.apache.poi.hssf.eventusermodel.examples.
* As with the HSSF version, this tries to spot missing
* rows and cells, and output empty entries for them.
* <p>
* Data sheets are read using a SAX parser to keep the
* memory footprint relatively small, so this should be
* able to read enormous workbooks. The styles table and
* the shared-string table must be kept in memory. The
* standard POI styles table class is used, but a custom
* (read-only) class is used for the shared string table
* because the standard POI SharedStringsTable grows very
* quickly with the number of unique strings.
* <p>
* For a more advanced implementation of SAX event parsing
* of XLSX files, see {@link XSSFEventBasedExcelExtractor}
* and {@link XSSFSheetXMLHandler}. Note that for many cases,
* it may be possible to simply use those with a custom
* {@link SheetContentsHandler} and no SAX code needed of
* your own!
*/
public class XLSX2CSV {
/**
* Uses the XSSF Event SAX helpers to do most of the work
* of parsing the Sheet XML, and outputs the contents
* as a (basic) CSV.
*/
private class SheetToCSV implements SheetContentsHandler {
private boolean firstCellOfRow;
private int currentRow = -1;
private int currentCol = -1;
private int maxrows = 60000;
private void outputMissingRows(int number) {
for (int i=0; i<number; i++) {
for (int j=0; j<minColumns; j++) {
output.append(',');
}
output.append('\n');
}
}
@Override
public void startRow(int rowNum) {
// If there were gaps, output the missing rows
outputMissingRows(rowNum-currentRow-1);
// Prepare for this row
firstCellOfRow = true;
currentRow = rowNum;
currentCol = -1;
if (rowNum == maxrows) {
throw new RuntimeException("Force stop at maxrows");
}
}
@Override
public void endRow(int rowNum) {
// Ensure the minimum number of columns
for (int i=currentCol; i<minColumns; i++) {
output.append(',');
}
output.append('\n');
}
@Override
public void cell(String cellReference, String formattedValue,
XSSFComment comment) {
if (firstCellOfRow) {
firstCellOfRow = false;
} else {
output.append(',');
}
// gracefully handle missing CellRef here in a similar way as XSSFCell does
if(cellReference == null) {
cellReference = new CellAddress(currentRow, currentCol).formatAsString();
}
// Did we miss any cells?
int thisCol = (new CellReference(cellReference)).getCol();
int missedCols = thisCol - currentCol - 1;
for (int i=0; i<missedCols; i++) {
output.append(',');
}
currentCol = thisCol;
// Number or string?
try {
//noinspection ResultOfMethodCallIgnored
Double.parseDouble(formattedValue);
output.append(formattedValue);
} catch (NumberFormatException e) {
output.append('"');
output.append(formattedValue);
output.append('"');
}
}
@Override
public void headerFooter(String arg0, boolean arg1, String arg2) {
// TODO Auto-generated method stub
}
}
///////////////////////////////////////
private final OPCPackage xlsxPackage;
/**
* Number of columns to read starting with leftmost
*/
private final int minColumns;
/**
* Destination for data
*/
private final PrintStream output;
/**
* Creates a new XLSX -> CSV converter
*
* @param pkg The XLSX package to process
* @param output The PrintStream to output the CSV to
* @param minColumns The minimum number of columns to output, or -1 for no minimum
*/
public XLSX2CSV(OPCPackage pkg, PrintStream output, int minColumns) {
this.xlsxPackage = pkg;
this.output = output;
this.minColumns = minColumns;
}
/**
* Parses and shows the content of one sheet
* using the specified styles and shared-strings tables.
*
* @param styles The table of styles that may be referenced by cells in the sheet
* @param strings The table of strings that may be referenced by cells in the sheet
* @param sheetInputStream The stream to read the sheet-data from.
* @exception java.io.IOException An IO exception from the parser,
* possibly from a byte stream or character stream
* supplied by the application.
* @throws SAXException if parsing the XML data fails.
*/
public void processSheet(
StylesTable styles,
ReadOnlySharedStringsTable strings,
SheetContentsHandler sheetHandler,
InputStream sheetInputStream) throws IOException, SAXException {
DataFormatter formatter = new DataFormatter();
InputSource sheetSource = new InputSource(sheetInputStream);
try {
XMLReader sheetParser = SAXHelper.newXMLReader();
ContentHandler handler = new XSSFSheetXMLHandler(
styles, null, strings, sheetHandler, formatter, false);
sheetParser.setContentHandler(handler);
sheetParser.parse(sheetSource);
} catch(ParserConfigurationException e) {
throw new RuntimeException("SAX parser appears to be broken - " + e.getMessage());
}
}
/**
* Initiates the processing of the XLS workbook file to CSV.
*
* @throws IOException If reading the data from the package fails.
* @throws SAXException if parsing the XML data fails.
*/
public void process() throws IOException, OpenXML4JException, SAXException {
ReadOnlySharedStringsTable strings = new ReadOnlySharedStringsTable(this.xlsxPackage);
XSSFReader xssfReader = new XSSFReader(this.xlsxPackage);
StylesTable styles = xssfReader.getStylesTable();
XSSFReader.SheetIterator iter = (XSSFReader.SheetIterator) xssfReader.getSheetsData();
int index = 0;
while (iter.hasNext()) {
try (InputStream stream = iter.next()) {
processSheet(styles, strings, new SheetToCSV(), stream);
}
++index;
}
}
}
Estoy en busca de diferentes (y de trabajo) se acerca a mi objetivo.
Gracias por tu tiempo
Muy bien, así que he intentado replicar el archivo de Excel y yo completamente tiró el XLSX2CSV por la ventana. No creo que el enfoque de convertir el xlsx en csv es la correcta porque, como función de su formato XLSX, puede leer todas las filas vacías (probablemente porque saben que usted ha fijado un contador de filas de 60k). No sólo eso, pero si estamos tomando en consideración los campos, puede o no puede causar una salida incorrecta con caracteres especiales, como su problema.
Lo que he hecho es que he utilizado esta biblioteca https://github.com/davidpelfree/sjxlsx de leer y re-escribir el archivo. Es más o menos recta hacia adelante y el nuevo archivo generado xlsx tiene los campos corregidos.
Le sugiero que pruebe este enfoque (tal vez no con este lib), de tratar de re-escribir el archivo con el fin de corregirlo.