Använder LightCells API

Ibland behöver du läsa och skriva stora Microsoft Excel-filer med en enorm lista med data eller innehåll i kalkylbladet. LightCells API är användbar för att skapa enorma Excel-kalkylblad: med den behöver du minne och få bättre prestanda och effektivitet.

Händelsedriven arkitektur

Aspose.Cells tillhandahåller LightCells API, huvudsakligen utformade för att manipulera celldata en efter en utan att bygga ett komplett datamodellblock (med Cell-samlingen etc.) i minnet. Det fungerar i ett händelsestyrt läge.

För att spara arbetsböcker, ange cellinnehållet cell för cell när du sparar, och komponenten sparar det direkt i utdatafilen.

När du läser mallfiler analyserar komponenten varje cell och ger deras värde en efter en.

I båda procedurerna bearbetas ett Cell-objekt och kasseras sedan, Workbook-objektet innehåller inte samlingen. I detta läge sparas därför minne vid import och export av Microsoft Excel-fil som har en stor datamängd som annars skulle använda mycket minne.

Även om LightCells API bearbetar cellerna på samma sätt för XLSX- och XLS-filer (den laddar faktiskt inte alla celler i minnet utan bearbetar en cell och kasserar den), sparar den minnet mer effektivt för XLSX filer på grund av 4 än 4811 filer de olika datamodellerna och strukturerna för de två formaten.

I alla fall,för XLS filer , för att spara mer minne kan utvecklare ange en tillfällig plats för att spara temporär data som genereras under Spara-processen. Vanligen,att använda LightCells API för att spara XLSX fil kan spara 50 % eller mer minne än att använda det vanliga sättet,Att spara XLS kan spara cirka 20-40 % minne.

Skriva stora Excel-filer

Aspose.Cells tillhandahåller ett gränssnitt, LightCellsDataProvider, som måste implementeras i ditt program. Gränssnittet representerar dataleverantör för att spara stora kalkylbladsfiler i lättviktsläge.

När du sparar en arbetsbok i det här läget, markeras startSheet(int) när du sparar alla kalkylblad i arbetsboken. För ett ark, om startSheet(int) är sant, tillhandahålls alla data och egenskaper för rader och celler i detta ark som ska sparas av denna implementering. I första hand anropas nextRow() för att få nästa radindex som ska sparas. Om ett giltigt radindex returneras (radindexet måste vara i stigande ordning för att raderna ska sparas), tillhandahålls ett Row-objekt som representerar denna rad för implementering för att ställa in dess egenskaper med startRow(Row).

För en rad, checkas nextCell() först. Om ett giltigt kolumnindex returneras (kolumnindexet måste vara i stigande ordning för att alla celler i en rad ska sparas), så tillhandahålls ett Cell-objekt som representerar denna cell för att ställa in data och egenskaper av startCell(Cell). Efter att data för denna cell har ställts in, sparas denna cell direkt i den genererade kalkylarksfilen och nästa cell kommer att kontrolleras och bearbetas.

Följande exempel visar hur LightCells API fungerar.

Följande program skapar en enorm fil med 100 000 poster i ett kalkylblad, fylld med data. Vi har lagt till några hyperlänkar, strängvärden, numeriska värden och även formler till vissa celler i kalkylbladet. Dessutom har vi formaterat ett antal celler också.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
public class LightCellsDataProviderDemo implements LightCellsDataProvider {
    private final int sheetCount;
    private final int maxRowIndex;
    private final int maxColIndex;
    private int rowIndex;
    private int colIndex;
    private final Style style1;
    private final Style style2;
    
    public LightCellsDataProviderDemo(Workbook wb, int sheetCount, int rowCount, int colCount) {
    	// set the variables/objects
    	this.sheetCount = sheetCount;
    	this.maxRowIndex = rowCount - 1;
    	this.maxColIndex = colCount - 1;
    
    	// add new style object with specific formattings
    	style1 = wb.createStyle();
    	Font font = style1.getFont();
    	font.setName("MS Sans Serif");
    	font.setSize(10);
    	font.setBold(true);
    	font.setItalic(true);
    	font.setUnderline(FontUnderlineType.SINGLE);
    	font.setColor(Color.fromArgb(0xffff0000));
    	style1.setHorizontalAlignment(TextAlignmentType.CENTER);
    
    	// create another style
    	style2 = wb.createStyle();
    	style2.setCustom("#,##0.00");
    	font = style2.getFont();
    	font.setName("Copperplate Gothic Bold");
    	font.setSize(8);
    	style2.setPattern(BackgroundType.SOLID);
    	style2.setForegroundColor(Color.fromArgb(0xff0000ff));
    	style2.setBorder(BorderType.TOP_BORDER, CellBorderType.THICK, Color.getBlack());
    	style2.setVerticalAlignment(TextAlignmentType.CENTER);
    }
    
    public boolean isGatherString() {
    	return false;
    }
    
    public int nextCell() {
    	if (colIndex < maxColIndex) {
    		colIndex++;
    		return colIndex;
    	}
    	return -1;
    }
    
    public int nextRow() {
    	if (rowIndex < maxRowIndex) {
    		rowIndex++;
    		colIndex = -1; // reset column index
    		if (rowIndex % 1000 == 0) {
    			System.out.println("Row " + rowIndex);
    		}
    		return rowIndex;
    	}
    	return -1;
    }
    
    public void startCell(Cell cell) {
    	if (rowIndex % 50 == 0 && (colIndex == 0 || colIndex == 3)) {
    		// do not change the content of hyperlink.
    		return;
    	}
    	if (colIndex < 10) {
    		cell.putValue("test_" + rowIndex + "_" + colIndex);
    		cell.setStyle(style1);
    	} else {
    		if (colIndex == 19) {
    			cell.setFormula("=Rand() + test!L1");
    		} else {
    			cell.putValue(rowIndex * colIndex);
    		}
    		cell.setStyle(style2);
    	}
    }
    
    public void startRow(Row row) {
    	row.setHeight(25);
    }
    
    public boolean startSheet(int sheetIndex) {
    	if (sheetIndex < sheetCount) {
    		// reset row/column index
    		rowIndex = -1;
    		colIndex = -1;
    		return true;
    	}
    	return false;
    }
}

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
public class Demo {
	private static final String OUTPUT_FILE_PATH = Utils.getDataDir(LightCellsDataProviderDemo.class);

	public static void main(String[] args) throws Exception {
		// Instantiate a new Workbook
		Workbook wb = new Workbook();
		// set the sheet count
		int sheetCount = 1;
		// set the number of rows for the big matrix
		int rowCount = 100000;
		// specify the worksheet
		for (int k = 0; k < sheetCount; k++) {
			Worksheet sheet = null;
			if (k == 0) {
				sheet = wb.getWorksheets().get(k);
				sheet.setName("test");
			} else {
				int sheetIndex = wb.getWorksheets().add();
				sheet = wb.getWorksheets().get(sheetIndex);
				sheet.setName("test" + sheetIndex);
			}
			Cells cells = sheet.getCells();

			// set the columns width
			for (int j = 0; j < 15; j++) {
				cells.setColumnWidth(j, 15);
			}

			// traverse the columns for adding hyperlinks and merging
			for (int i = 0; i < rowCount; i++) {
				// The first 10 columns
				for (int j = 0; j < 10; j++) {
					if (j % 3 == 0) {
						cells.merge(i, j, 1, 2, false, false);
					}

					if (i % 50 == 0) {
						if (j == 0) {
							sheet.getHyperlinks().add(i, j, 1, 1, "test!A1");
						} else if (j == 3) {
							sheet.getHyperlinks().add(i, j, 1, 1, "http://www.google.com");
						}
					}
				}

				// The second 10 columns
				for (int j = 10; j < 20; j++) {
					if (j == 12) {
						cells.merge(i, j, 1, 3, false, false);
					}
				}
			}
		}

		// Create an object with respect to LightCells data provider
		LightCellsDataProviderDemo dataProvider = new LightCellsDataProviderDemo(wb, 1, rowCount, 20);
		// Specify the XLSX file's Save options
		OoxmlSaveOptions opt = new OoxmlSaveOptions();
		// Set the data provider for the file
		opt.setLightCellsDataProvider(dataProvider);

		// Save the big file
		wb.save(OUTPUT_FILE_PATH + "/DemoTest.xlsx", opt);
	}
}

Läsa stora Excel-filer

Aspose.Cells tillhandahåller ett gränssnitt, LightCellsDataHandler, som måste implementeras i ditt program. Gränssnittet representerar dataleverantören för att läsa stora kalkylbladsfiler i ett lättviktsläge.

När du läser en arbetsbok i det här läget, kontrolleras startSheet() när du läser alla kalkylblad i arbetsboken. För ett ark, om startSheet() returnerar sant, kontrolleras och bearbetas alla data och egenskaper för cellerna i arkets rader och kolumner. För varje rad anropas startRow() för att kontrollera om den behöver bearbetas. Om en rad behöver bearbetas läses radens egenskaper först och utvecklare kan komma åt dess egenskaper med processRow().

Om radens celler också behöver bearbetas, returnerar processRow() true och startCell() anropas för varje befintlig cell i raden för att kontrollera om den behöver bearbetas. Om den gör det anropas processCell().

Följande exempelkod illustrerar denna process. Programmet läser en stor fil med miljontals poster. Det tar lite tid att läsa varje blad i arbetsboken. Exempelkoden läser filen och hämtar det totala antalet celler, antal strängar och formler för varje kalkylblad.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
public class LightCellsTest1 {
	public static void main(String[] args) throws Exception {
		String dataDir = Utils.getDataDir(LightCellsTest1.class);
		LoadOptions opts = new LoadOptions();
		LightCellsDataHandlerVisitCells v = new LightCellsDataHandlerVisitCells();
		opts.setLightCellsDataHandler((LightCellsDataHandler) v);
		Workbook wb = new Workbook(dataDir + "LargeBook1.xlsx", opts);
		int sheetCount = wb.getWorksheets().getCount();
		System.out.println("Total sheets: " + sheetCount + ", cells: " + v.cellCount + ", strings: " + v.stringCount
				+ ", formulas: " + v.formulaCount);

	}
}

En klass som implementerar LightCellsDataHandler-gränssnittet

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
public class LightCellsDataHandlerVisitCells implements LightCellsDataHandler {
	public int cellCount;
	public int formulaCount;
	public int stringCount;

	public LightCellsDataHandlerVisitCells() {
		this.cellCount = 0;
		this.formulaCount = 0;
		this.stringCount = 0;
	}

	public int cellCount() {
		return cellCount;
	}

	public int formulaCount() {
		return formulaCount;
	}

	public int stringCount() {
		return stringCount;
	}

	public boolean startSheet(Worksheet sheet) {
		System.out.println("Processing sheet[" + sheet.getName() + "]");
		return true;
	}

	public boolean startRow(int rowIndex) {
		return true;
	}

	public boolean processRow(Row row) {
		return true;
	}

	public boolean startCell(int column) {
		return true;
	}

	public boolean processCell(Cell cell) {
		this.cellCount = this.cellCount + 1;
		if (cell.isFormula()) {
			this.formulaCount = this.formulaCount + 1;
		} else if (cell.getType() == CellValueType.IS_STRING) {
			this.stringCount = this.stringCount + 1;
		}
		return false;
	}
}