Öffnen von Dateien mit unterschiedlichen Formaten

Entwickler verwenden Aspose.Cells, um Dateien für verschiedene Zwecke zu öffnen. Öffnen Sie beispielsweise eine Datei, um Daten daraus abzurufen, oder verwenden Sie eine vordefinierte Designer-Tabellenkalkulationsdatei, um Ihren Entwicklungsprozess zu beschleunigen. Aspose.Cells ermöglicht es Entwicklern, verschiedene Arten von Quelldateien zu öffnen. Diese Quelldateien können Microsoft-Excel-Berichte, SpreadsheetML-Dateien mit kommagetrennten Werten (CSV), tabulatorgetrennten oder tabulatorgetrennten Werten (TSV) sein. Dieser Artikel beschreibt das Öffnen dieser verschiedenen Quelldateien mit Aspose.Cells.

Wenn Sie alle unterstützten Dateiformate kennen möchten, lesen Sie bitte die folgenden Seiten: Unterstützte Dateiformate

Einfache Möglichkeiten zum Öffnen von Excel-Dateien

Öffnung durch Pfad

Um eine Microsoft-Excel-Datei mit dem Dateipfad zu öffnen, übergeben Sie den Pfad der Datei als Parameter, während Sie die Instanz von erstellen**Arbeitsmappe**Klasse. Der folgende Beispielcode veranschaulicht das Öffnen einer Excel-Datei mithilfe des Dateipfads.

Beispiel

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(OpeningFilesThroughPath.class) + "files/";

// Opening from path.
// Creating an Workbook object with an Excel file path
Workbook workbook1 = new Workbook(dataDir + "Book1.xlsx");

// Print message
System.out.println("Workbook opened using path successfully.");

Öffnung durch Stream

Manchmal wird die Excel-Datei, die Sie öffnen möchten, als Stream gespeichert. Übergeben Sie in diesem Fall ähnlich wie beim Öffnen einer Datei mit dem Dateipfad den Stream als Parameter, während Sie die instanziieren**Arbeitsmappe** Klasse. Der folgende Beispielcode demonstriert das Öffnen einer Excel-Datei mit stream.

Beispiel

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(OpeningFilesThroughStream.class) + "loading_saving/";

// Opening workbook from stream
// Create a Stream object
FileInputStream fstream = new FileInputStream(dataDir + "Book2.xls");

// Creating an Workbook object with the stream object
Workbook workbook2 = new Workbook(fstream);

fstream.close();

// Print message
System.out.println("Workbook opened using stream successfully.");

Öffnen von Dateien verschiedener Microsoft Excel-Versionen

Der Benutzer kann die verwenden**LoadOptions** -Klasse, um das Format der Excel-Datei mithilfe der**LoadFormat**Aufzählung.

Das**LoadFormat**Enumeration enthält viele vordefinierte Dateiformate, von denen einige unten aufgeführt sind.

Formattypen	Beschreibung
CSV	Stellt eine CSV-Datei dar
Excel97To2003	Stellt eine Excel 97-2003-Datei dar
XLSX	Stellt eine Excel 2007/2010/2013/2016/2019- und Office 365-XLSX-Datei dar
XLSM	Stellt eine Excel 2007/2010/2013/2016/2019- und Office 365-XLSM-Datei dar
Xltx	Stellt eine Excel 2007/2010/2013/2016/2019- und Office 365-Vorlagendatei XLTX dar
Xltm	Stellt eine Excel 2007/2010/2013/2016/2019- und Office 365-Makro-aktivierte XLTM-Datei dar
XLSB	Stellt eine Excel 2007/2010/2013/2016/2019- und Office 365-Binärdatei XLSB dar
SpreadsheetML	Stellt eine SpreadsheetML-Datei dar
Tsv	Stellt eine tabulatorgetrennte Wertedatei dar
TabDelimited	Stellt eine tabulatorgetrennte Textdatei dar
Odds	Stellt eine ODS-Datei dar
HTML	Stellt eine HTML-Datei dar
HTML	Stellt eine MHTML-Datei dar

Öffnen von Microsoft Excel 95/5.0-Dateien

Um Microsoft Excel 95-Dateien zu öffnen, instanziieren Sie die**Arbeitsmappe**-Instanz mit dem Pfad oder Stream der Vorlagendatei. Eine Beispieldatei zum Testen des Codes kann unter folgendem Link heruntergeladen werden:

Excel95_5.0.xls

Beispiel

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// Opening Microsoft Excel 97 Files
// Creating an EXCEL_97_TO_2003 LoadOptions object

// Creating an Workbook object with excel 97 file path and the
// loadOptions object
new Workbook(srcDir + "Excel95_5.0.xls");

Öffnen von Microsoft Excel 97 oder späteren Versionen von XLS-Dateien

Um XLS-Dateien von Microsoft Excel XLS 97 oder späteren Versionen zu öffnen, instanziieren Sie die**Arbeitsmappe**-Instanz mit dem Pfad oder Stream der Vorlagendatei. Oder verwenden Sie die**LoadOptions** Methode und wählen Sie die aus**EXCEL_97_TO_2003** Wert in der**LoadFormat**Aufzählung.

Beispiel

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(OpeningMicrosoftExcel972003Files.class) + "loading_saving/";

// Opening Microsoft Excel 97 Files
// Createing and EXCEL_97_TO_2003 LoadOptions object
LoadOptions loadOptions1 = new LoadOptions(LoadFormat.EXCEL_97_TO_2003);

// Creating an Workbook object with excel 97 file path and the
// loadOptions object
Workbook workbook3 = new Workbook(dataDir + "Book_Excel97_2003.xls", loadOptions1);

// Print message
System.out.println("Excel 97 Workbook opened successfully.");

Öffnen von Microsoft Excel 2007 oder späteren Versionen von XLSX-Dateien

Um XLSX-Dateien von Microsoft Excel 2007 oder späteren Versionen zu öffnen, instanziieren Sie die**Arbeitsmappe**-Instanz mit dem Pfad oder Stream der Vorlagendatei. Oder verwenden Sie die**LoadOptions** Klasse und wählen Sie die aus**XLSX** Wert in der**LoadFormat**Aufzählung.

Beispiel

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(OpeningMicrosoftExcel2007XlsxFiles.class) + "loading_saving/";

// Opening Microsoft Excel 2007 XLSX Files. Createing and XLSX LoadOptions object
LoadOptions loadOptions2 = new LoadOptions(LoadFormat.XLSX);

// Creating an Workbook object with 2007 xlsx file path and the loadOptions object
Workbook workbook4 = new Workbook(dataDir + "Book_Excel2007.xlsx", loadOptions2);

// Print message
System.out.println("Excel 2007 Workbook opened successfully.");

Öffnen von Dateien mit unterschiedlichen Formaten

Aspose.Cells ermöglicht Entwicklern das Öffnen von Tabellenkalkulationsdateien mit unterschiedlichen Formaten wie SpreadsheetML, CSV, tabulatorgetrennte Dateien. Um solche Dateien zu öffnen, können Entwickler dieselbe Methode verwenden, die sie zum Öffnen von Dateien verschiedener Microsoft-Excel-Versionen verwenden.

Öffnen von SpreadsheetML-Dateien

SpreadsheetML-Dateien sind die XML-Darstellungen Ihrer Tabellenkalkulationen einschließlich aller Informationen über die Tabellenkalkulation wie Formatierung, Formeln usw. Seit Microsoft Excel XP wird Microsoft Excel eine XML-Exportoption hinzugefügt, die Ihre Tabellenkalkulationen in SpreadsheetML-Dateien exportiert.

Verwenden Sie zum Öffnen von SpreadsheetML-Dateien die**LoadOptions** Klasse und wählen Sie die aus**SPREADSHEET_ML** Wert in der**LoadFormat**Aufzählung.

Beispiel

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(OpeningSpreadsheetMLFiles.class) + "loading_saving/";

// Opening SpreadsheetML Files
// Creating and EXCEL_2003_XML LoadOptions object
LoadOptions loadOptions3 = new LoadOptions(LoadFormat.SPREADSHEET_ML);

// Creating an Workbook object with SpreadsheetML file path and the
// loadOptions object
Workbook workbook5 = new Workbook(dataDir + "Book3.xml", loadOptions3);

// Print message
System.out.println("SpreadSheetML format workbook has been opened successfully.");

Öffnen von CSV-Dateien

Dateien mit kommagetrennten Werten (CSV) enthalten Datensätze, deren Werte durch Kommas getrennt oder begrenzt sind. In CSV-Dateien werden Daten in einem tabellarischen Format gespeichert, das Felder enthält, die durch Kommas getrennt und durch doppelte Anführungszeichen eingeschlossen sind. Wenn der Wert eines Felds ein doppeltes Anführungszeichen enthält, wird es mit einem Paar doppelter Anführungszeichen maskiert. Sie können auch Microsoft Excel verwenden, um Ihre Tabellenkalkulationsdaten in eine CSV-Datei zu exportieren.

Verwenden Sie zum Öffnen von CSV-Dateien die**LoadOptions** Klasse und wählen Sie die aus**CSV** Wert, vordefiniert in der**LoadFormat**Aufzählung.

Beispiel

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(OpeningCSVFiles.class) + "loading_saving/";
// Opening CSV Files
// Creating and CSV LoadOptions object
LoadOptions loadOptions4 = new LoadOptions(LoadFormat.CSV);

// Creating an Workbook object with CSV file path and the loadOptions
// object
Workbook workbook6 = new Workbook(dataDir + "Book_CSV.csv", loadOptions4);

// Print message
System.out.println("CSV format workbook has been opened successfully.");

Öffnen von CSV-Dateien und Ersetzen ungültiger Zeichen

Wenn in Excel eine CSV-Datei mit Sonderzeichen geöffnet wird, werden die Zeichen automatisch ersetzt. Dasselbe wird von Aspose.Cells API durchgeführt, was in dem unten angegebenen Codebeispiel demonstriert wird.

Beispiel

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
//Source directory
String dataDir = Utils.getSharedDataDir(OpeningCSVFilesAndReplacingInvalidCharacters.class) + "LoadingSavingConvertingAndManaging/";
        
LoadOptions loadOptions = new LoadOptions(LoadFormat.CSV);

//Load CSV file
Workbook workbook = new Workbook(dataDir + "[20180220142533][ASPOSE_CELLS_TEST].csv", loadOptions);

System.out.println(workbook.getWorksheets().get(0).getName()); // (20180220142533)(ASPOSE_CELLS_T
System.out.println(workbook.getWorksheets().get(0).getName().length()); // 31
System.out.println("CSV file opened successfully!");

Öffnen von CSV-Dateien mit dem bevorzugten Parser

Dies ist nicht immer erforderlich, um die Standard-Parser-Einstellungen zum Öffnen der CSV-Dateien zu verwenden. Manchmal erzeugt das Importieren der Datei CSV nicht die erwartete Ausgabe, da das Datumsformat nicht wie erwartet ist oder leere Felder anders behandelt werden. Für diesen Zweck**TxtLoadOptions.PreferredParsers**ist verfügbar, um einen eigenen bevorzugten Parser bereitzustellen, um verschiedene Datentypen gemäß den Anforderungen zu analysieren. Der folgende Beispielcode demonstriert die Verwendung des bevorzugten Parsers.

Beispiel-Quelldatei und Ausgabedateien können von den folgenden Links heruntergeladen werden, um diese Funktion zu testen.

samplePreferredParser.csv

AusgabebeispielPreferredParser.xlsx

Beispiel

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
class TextParser implements ICustomParser
{
	@Override
	public Object parseObject(String s) {
		return s;
	}

	@Override
	public String getFormat() {
		return "";
	}
}

class DateParser implements ICustomParser {
	@Override
	public Object parseObject(String s) {
		Date myDate = null;
		SimpleDateFormat formatter = new SimpleDateFormat("dd/MM/yyyy");
		try {
			myDate = formatter.parse(s);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return myDate;
	}

	@Override
	public String getFormat() {
		return "dd/MM/yyyy";
	}
}

public class OpeningCSVFilesWithPreferredParser {

	//Source directory
	private static String sourceDir = Utils.Get_SourceDirectory();
	private static String outputDir = Utils.Get_OutputDirectory();

	public static void main(String[] args) throws Exception {

		// Initialize Text File's Load options
		TxtLoadOptions oTxtLoadOptions = new TxtLoadOptions(LoadFormat.CSV);

		// Specify the separatot character
		oTxtLoadOptions.setSeparator(',');

		// Specify the encoding scheme
		oTxtLoadOptions.setEncoding(Encoding.getUTF8());

		// Set the flag to true for converting datetime data
		oTxtLoadOptions.setConvertDateTimeData(true);

		// Set the preferred parsers
		oTxtLoadOptions.setPreferredParsers(new ICustomParser[] { new TextParser(), new DateParser() });

		// Initialize the workbook object by passing CSV file and text load options
		Workbook oExcelWorkBook = new Workbook(sourceDir + "samplePreferredParser.csv", oTxtLoadOptions);

		// Get the first cell
		Cell oCell = oExcelWorkBook.getWorksheets().get(0).getCells().get("A1");

		// Display type of value
		System.out.println("A1: " + getCellType(oCell.getType()) + " - " + oCell.getDisplayStringValue());

		// Get the second cell
		oCell = oExcelWorkBook.getWorksheets().get(0).getCells().get("B1");

		// Display type of value
		System.out.println("B1: " + getCellType(oCell.getType()) + " - " + oCell.getDisplayStringValue());

		// Save the workbook to disc
		oExcelWorkBook.save(outputDir + "outputsamplePreferredParser.xlsx");

		System.out.println("OpeningCSVFilesWithPreferredParser executed successfully.\r\n");
	}

	private static String getCellType(int type){
		if(type == CellValueType.IS_STRING){
			return "String";
		} else if(type == CellValueType.IS_NUMERIC){
			return "Numeric";
		} else if(type == CellValueType.IS_BOOL){
			return "Bool";
		} else if(type == CellValueType.IS_DATE_TIME){
			return "Date";
		} else if(type == CellValueType.IS_NULL){
			return "Null";
		} else if(type == CellValueType.IS_ERROR){
			return "Error";
		} else{
			return "Unknown";
		}
	}

Öffnen von TSV-Dateien (Tabulatorgetrennt).

Tabulatorgetrennte Dateien enthalten Tabellenkalkulationsdaten, jedoch ohne jegliche Formatierung. Daten werden in Zeilen und Spalten wie Tabellen und Tabellenkalkulationen angeordnet. Kurz gesagt, eine tabulatorgetrennte Datei ist eine spezielle Art von einfacher Textdatei mit einem Tabulator zwischen jeder Spalte im Text.

Um tabulatorgetrennte Dateien zu öffnen, sollten Entwickler die**LoadOptions** Klasse und wählen Sie die aus**TSV** Wert, vordefiniert in der**LoadFormat**Aufzählung.

Beispiel

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(OpeningTabDelimitedFiles.class) + "loading_saving/";

// Creating and TAB_DELIMITED LoadOptions object
LoadOptions loadOptions5 = new LoadOptions(LoadFormat.TSV);

// Creating an Workbook object with Tab Delimited text file path and the
// loadOptions object
Workbook workbook7 = new Workbook(dataDir + "Book1TabDelimited.txt", loadOptions5);

// Print message
System.out.println("Tab Delimited workbook has been opened successfully.");

Öffnen verschlüsselter Excel-Dateien

Wir wissen, dass es möglich ist, verschlüsselte Excel-Dateien mit Microsoft Excel zu erstellen. Um solche verschlüsselten Dateien zu öffnen, sollten Entwickler eine spezielle überladene LoadOptions-Methode aufrufen und den DEFAULT-Wert auswählen, der in der FileFormatType-Enumeration vordefiniert ist. Diese Methode würde auch das Passwort für die verschlüsselte Datei verwenden, wie unten im Beispiel gezeigt.

Beispiel

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(OpeningEncryptedExcelFiles.class) + "loading_saving/";

// Opening Encrypted Excel Files
// Creating and EXCEL_97_TO_2003 LoadOptions object
LoadOptions loadOptions6 = new LoadOptions(LoadFormat.EXCEL_97_TO_2003);

// Setting the password for the encrypted Excel file
loadOptions6.setPassword("1234");

// Creating an Workbook object with file path and the loadOptions object
Workbook workbook8 = new Workbook(dataDir + "encryptedBook.xls", loadOptions6);

// Print message
System.out.println("Encrypted workbook has been opened successfully.");

Aspose.Cells unterstützt auch das Öffnen passwortgeschützter MS Excel 2013-Dateien.

Es besteht die Möglichkeit, dass der Workbook-Konstruktor beim Laden großer Tabellenkalkulationen System.OutOfMemoryException auslöst. Diese Ausnahme deutet darauf hin, dass der verfügbare Speicher nicht ausreicht, um die Tabelle vollständig in den Speicher zu laden, daher muss die Tabelle geladen werden, während die aktiviert wirdSpeichereinstellungen.

Öffnen von SXC-Dateien

StarOffice Calc ähnelt Microsoft Excel und unterstützt Formeln, Diagramme, Funktionen und Makros. Die mit dieser Software erstellten Tabellenkalkulationen werden mit der Erweiterung SXC gespeichert. Die Datei SXC wird auch für Tabellenkalkulationsdateien von OpenOffice.org Calc verwendet. Aspose.Cells kann SXC-Dateien lesen, wie im folgenden Codebeispiel gezeigt wird.

Beispiel

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the source directory.
String sourceDir = Utils.Get_SourceDirectory();

// Instantiate LoadOptions specified by the LoadFormat.
LoadOptions loadOptions = new LoadOptions(LoadFormat.SXC);

// Create a Workbook object and opening the file from its path
Workbook workbook = new Workbook(sourceDir + "SampleSXC.sxc", loadOptions);
      
// Using the Sheet 1 in Workbook
Worksheet worksheet = workbook.getWorksheets().get(0);

// Accessing a cell using its name
Cell cell = worksheet.getCells().get("C3");

System.out.println("Cell Name: " + cell.getName() + " Value: " + cell.getStringValue());

Öffnen von FODS-Dateien

FODS-Datei ist eine Tabelle, die ohne Komprimierung in OpenDocument XML gespeichert wurde. Aspose.Cells kann FODS-Dateien lesen, wie im folgenden Codebeispiel gezeigt wird.

Beispiel

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-Java
// The path to the source directory.
String sourceDir = Utils.Get_SourceDirectory();

// Instantiate LoadOptions specified by the LoadFormat.
LoadOptions loadOptions = new LoadOptions(LoadFormat.FODS);

// Create a Workbook object and opening the file from its path
Workbook workbook = new Workbook(sourceDir + "SampleFods.fods", loadOptions);

// Print message
System.out.println("FODS file opened successfully!");

Themen vorantreiben

• Filtern Sie definierte Namen beim Laden der Arbeitsmappe
• Filtern Sie Objekte beim Laden der Arbeitsmappe oder des Arbeitsblatts
• Erhalten Sie Warnungen beim Laden einer Excel-Datei
• Behalten Sie Trennzeichen für leere Zeilen bei, während Sie Tabellenkalkulationen in das Format CSV exportieren
• Laden Sie die Arbeitsmappe mit dem angegebenen Druckerpapierformat
• Öffnen verschiedener Microsoft Excel-Versionsdateien
• Optimieren der Speichernutzung beim Arbeiten mit großen Dateien mit großen Datensätzen
• Read Numbers Spreadsheet Entwickelt von Apple Inc. unter Verwendung von Aspose.Cells
• Lesen von CSV-Datei mit mehreren Codierungen
• Stoppen Sie die Konvertierung oder das Laden mit InterruptMonitor, wenn es zu lange dauert
• Verwendung von LightCells API