Öppna filer med olika format

Utvecklare använder Aspose.Cells för att öppna filer för olika ändamål. Öppna till exempel en fil för att hämta data från den, eller använd en fördefinierad designarkfil för att påskynda utvecklingsprocessen. Aspose.Cells tillåter utvecklare att öppna olika typer av källfiler. Dessa källfiler kan vara Microsoft Excel-rapporter, SpreadsheetML, kommaseparerade värden (CSV), tabbavgränsade eller tabbseparerade värden (TSV). Den här artikeln diskuterar att öppna dessa olika källfiler med Aspose.Cells.

Om du behöver veta alla filformat som stöds, se följande sidor: Filformat som stöds

Enkla sätt att öppna Excel-filer

Öppning genom vägen

För att öppna en Microsoft Excel-fil med hjälp av filsökvägen, skicka sökvägen till filen som en parameter medan du skapar instansen av**Arbetsbok**klass. Följande exempelkod visar hur du öppnar en Excel-fil med hjälp av filsökvägen.

Exempel

// 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.");

Öppnas genom Stream

Ibland lagras Excel-filen som du vill öppna som en ström. I så fall, på samma sätt som att öppna en fil med hjälp av filsökvägen, skicka strömmen som en parameter medan du instansierar**Arbetsbok** klass. Följande exempelkod visar hur du öppnar en Excel-fil med stream.

Exempel

// 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.");

Öppna filer av olika Microsoft Excel-versioner

Användaren kan använda**LoadOptions** klass för att ange formatet för Excel-filen med hjälp av**LoadFormat**uppräkning.

De**LoadFormat**uppräkningen innehåller många fördefinierade filformat av vilka några ges nedan.

Formattyper	Beskrivning
Csv	Representerar en CSV-fil
Excel97To2003	Representerar en Excel 97 - 2003-fil
Xlsx	Representerar en Excel 2007/2010/2013/2016/2019 och Office 365 XLSX-fil
Xlsm	Representerar en Excel 2007/2010/2013/2016/2019 och Office 365 XLSM-fil
Xltx	Representerar en Excel 2007/2010/2013/2016/2019 och Office 365 mall XLTX fil
Xltm	Representerar en Excel 2007/2010/2013/2016/2019 och Office 365 makroaktiverad XLTM-fil
Xlsb	Representerar en Excel 2007/2010/2013/2016/2019 och Office 365 binär XLSB fil
SpreadsheetML	Representerar en SpreadsheetML-fil
Tsv	Representerar en tabbseparerad värdefil
TabDelimited	Representerar en tabbavgränsad textfil
Odds	Representerar en ODS-fil
Html	Representerar en HTML-fil
Mhtml	Representerar en MHTML-fil

Öppnar Microsoft Excel 95/5.0-filer

För att öppna Microsoft Excel 95-filer, instansiera**Arbetsbok**instans med sökvägen eller strömmen till mallfilen. Exempelfil för att testa koden kan laddas ner från följande länk:

Excel95_5.0.xls

Exempel

// 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");

Öppna Microsoft Excel 97 eller senare versioner XLS Filer

För att öppna XLS-filer av Microsoft Excel XLS 97 eller senare versioner, instansiera**Arbetsbok**instans med sökvägen eller strömmen till mallfilen. Eller använd**LoadOptions** metod och välj**EXCEL_97_TO_2003** värde i**LoadFormat**uppräkning.

Exempel

// 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.");

Öppna Microsoft Excel 2007 eller senare versioner XLSX Filer

För att öppna XLSX-filer av Microsoft Excel 2007 eller senare versioner, instansiera**Arbetsbok**instans med sökvägen eller strömmen till mallfilen. Eller använd**LoadOptions** klass och välj**XLSX** värde i**LoadFormat**uppräkning.

Exempel

// 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.");

Öppna filer med olika format

Aspose.Cells tillåter utvecklare att öppna kalkylbladsfiler med olika format som SpreadsheetML, CSV, tabbavgränsade filer. För att öppna sådana filer kan utvecklare använda samma metod som de använder för att öppna filer av olika Microsoft Excel-versioner.

Öppnar SpreadsheetML Filer

SpreadsheetML-filer är XML-representationer av dina kalkylblad inklusive all information om kalkylarket såsom formatering, formler etc. Sedan Microsoft Excel XP har ett XML-exportalternativ lagts till i Microsoft Excel som exporterar dina kalkylblad till SpreadsheetML-filer.

För att öppna SpreadsheetML-filer, använd**LoadOptions** klass och välj**SPREADSHEET_ML** värde i**LoadFormat**uppräkning.

Exempel

// 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.");

Öppnar CSV Filer

Kommaseparerade värden (CSV) filer innehåller poster vars värden är avgränsade eller separerade med kommatecken. I CSV-filer lagras data i ett tabellformat som har fält separerade med kommatecken och citerade med dubbla citattecken. Om ett fälts värde innehåller ett dubbelcitattecken escapes det med ett par dubbla citattecken. Du kan också använda Microsoft Excel för att exportera dina kalkylbladsdata till en CSV-fil.

För att öppna CSV-filer, använd**LoadOptions** klass och välj**CSV** värde, fördefinierat i**LoadFormat**uppräkning.

Exempel

// 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.");

Öppnar CSV-filer och ersätter ogiltiga tecken

Excel, när CSV-filen med specialtecken öppnas, ersätts tecknen automatiskt. Detsamma görs av Aspose.Cells API vilket visas i kodexemplet nedan.

Exempel

// 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!");

Öppnar CSV-filer med föredragen parser

Detta är inte alltid nödvändigt för att använda standardparserinställningar för att öppna CSV-filerna. Ibland skapar import av CSV-fil inte förväntad utdata som att datumformatet inte är som förväntat eller tomma fält hanteras annorlunda. För detta ändamål**TxtLoadOptions.PreferredParsers**är tillgänglig för att tillhandahålla en egen föredragen parser för att analysera olika datatyper enligt kravet. Följande exempelkod visar användningen av den föredragna parsern.

Exempel på källfiler och utdatafiler kan laddas ner från följande länkar för att testa den här funktionen.

samplePreferredParser.csv

outputsamplePreferredParser.xlsx

Exempel

// 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";
		}
	}

Öppnar TSV(tabbavgränsade) filer

Tabbavgränsade filer innehåller kalkylbladsdata men utan någon formatering. Data är ordnade i rader och kolumner som tabeller och kalkylblad. Kortfattat är en tabbavgränsad fil en speciell typ av vanlig textfil med en tabb mellan varje kolumn i texten.

För att öppna tabbavgränsade filer bör utvecklare använda**LoadOptions** klass och välj**TSV** värde, fördefinierat i**LoadFormat**uppräkning.

Exempel

// 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.");

Öppna krypterade Excel-filer

Vi vet att det är möjligt att skapa krypterade Excel-filer med Microsoft Excel. För att öppna sådana krypterade filer bör utvecklare anropa en speciell överbelastad LoadOptions-metod och välja DEFAULT-värdet, fördefinierat i FileFormatType-uppräkningen. Denna metod skulle också ta lösenordet för den krypterade filen som visas nedan i exemplet.

Exempel

// 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 stöder även öppning av lösenordsskyddade MS Excel 2013-filer.

Det finns rimliga chanser att Workbook-konstruktören kan kasta System.OutOfMemoryException när stora kalkylblad laddas. Detta undantag tyder på att det tillgängliga minnet är otillräckligt för att fullständigt ladda kalkylarket i minnet, därför måste kalkylarket laddas samtidigt som du aktiverarMinnesinställningar.

Öppnar SXC Filer

StarOffice Calc liknar Microsoft Excel och stöder formler, diagram, funktioner och makron. Kalkylbladen som skapas med denna programvara sparas med tillägget SXC. Filen SXC används också för OpenOffice.org Calc-kalkylbladsfiler. Aspose.Cells kan läsa SXC-filer som visas av följande kodexempel.

Exempel

// 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());

Öppnar FODS Filer

FODS-filen är ett kalkylblad som sparas i OpenDocument XML utan någon komprimering. Aspose.Cells kan läsa FODS-filer som visas av följande kodexempel.

Exempel

// 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!");

Förhandsämnen

• Filtrera definierade namn när arbetsboken laddas
• Filtrera objekt när du laddar arbetsbok eller arbetsblad
• Få varningar när du laddar Excel-fil
• Behåll avgränsare för tomma rader när du exporterar kalkylblad till CSV-format
• Ladda arbetsbok med angiven skrivarpappersstorlek
• Öppna olika Microsoft Excel-versionsfiler
• Optimera minnesanvändning när du arbetar med stora filer med stora datamängder
• Läs Numbers Kalkylblad Utvecklat av Apple Inc. med Aspose.Cells
• Läser CSV Fil med flera kodningar
• Stoppa konvertering eller laddning med InterruptMonitor när det tar för lång tid
• Använder LightCells API