Ouverture de fichiers avec différents formats

Les développeurs utilisent Aspose.Cells pour ouvrir des fichiers à des fins différentes. Par exemple, ouvrez un fichier pour en extraire des données ou utilisez une feuille de calcul de concepteur prédéfinie pour accélérer votre processus de développement. Aspose.Cells permet aux développeurs d’ouvrir différents types de fichiers source. Ces fichiers sources peuvent être des rapports Excel Microsoft, SpreadsheetML, des fichiers de valeurs séparées par des virgules (CSV), des fichiers de valeurs séparées par des tabulations ou des valeurs séparées par des tabulations (TSV). Cet article traite de l’ouverture de ces différents fichiers source à l’aide de Aspose.Cells.

Si vous avez besoin de connaître tous les formats de fichiers pris en charge, veuillez vous référer aux pages suivantes : Formats de fichiers pris en charge

Des moyens simples d’ouvrir des fichiers Excel

Ouverture par chemin

Pour ouvrir un fichier Excel Microsoft à l’aide du chemin du fichier, passez le chemin du fichier en tant que paramètre lors de la création de l’instance du**Classeur**classe. L’exemple de code suivant illustre l’ouverture d’un fichier Excel à l’aide du chemin d’accès au fichier.

Exemple

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

Ouverture via Stream

Parfois, le fichier Excel que vous souhaitez ouvrir est stocké sous forme de flux. Dans ce cas, similaire à l’ouverture d’un fichier en utilisant le chemin du fichier, passez le flux en tant que paramètre lors de l’instanciation du**Classeur** classe. L’exemple de code suivant illustre l’ouverture d’un fichier Excel à l’aide de stream.

Exemple

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

Ouverture de fichiers de différentes versions d’Excel Microsoft

L’utilisateur peut utiliser le**LoadOptions** classe pour spécifier le format du fichier Excel à l’aide de la**ChargerFormat**énumération.

Le**ChargerFormat**énumération contient de nombreux formats de fichiers prédéfinis dont certains sont donnés ci-dessous.

Types de formats	Description
CSV	Représente un fichier CSV
Excel97To2003	Représente un fichier Excel 97 - 2003
Xlsx	Représente un fichier Excel 2007/2010/2013/2016/2019 et Office 365 XLSX
Xlsm	Représente un fichier Excel 2007/2010/2013/2016/2019 et Office 365 XLSM
XLTX	Représente un fichier de modèle Excel 2007/2010/2013/2016/2019 et Office 365 XLTX
Xltm	Représente un fichier Excel 2007/2010/2013/2016/2019 et Office 365 prenant en charge les macros XLTM
Xlsb	Représente un fichier Excel 2007/2010/2013/2016/2019 et Office 365 binaire XLSB
SpreadsheetML	Représente un fichier SpreadsheetML
Tsv	Représente un fichier de valeurs séparées par des tabulations
TabDelimited	Représente un fichier texte délimité par des tabulations
cotes	Représente un fichier ODS
HTML	Représente un fichier HTML
Mhtml	Représente un fichier MHTML

Ouverture des fichiers Microsoft Excel 95/5.0

Pour ouvrir les fichiers Microsoft Excel 95, instanciez le**Classeur**instance avec le chemin ou le flux du fichier modèle. Un exemple de fichier pour tester le code peut être téléchargé à partir du lien suivant :

Excel95_5.0.xls

Exemple

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

Ouverture de fichiers Microsoft Excel 97 ou versions ultérieures XLS

Pour ouvrir les fichiers XLS de Microsoft Excel XLS 97 ou versions ultérieures, instanciez le**Classeur**instance avec le chemin ou le flux du fichier modèle. Ou utilisez le**LoadOptions** méthode et sélectionnez la**EXCEL_97_TO_2003** valeur dans le**ChargerFormat**énumération.

Exemple

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

Ouverture Microsoft Excel 2007 ou versions ultérieures XLSX Fichiers

Pour ouvrir les fichiers XLSX de Microsoft Excel 2007 ou versions ultérieures, instanciez le**Classeur**instance avec le chemin ou le flux du fichier modèle. Ou utilisez le**LoadOptions** classe et sélectionnez la**XLSX** valeur dans le**ChargerFormat**énumération.

Exemple

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

Ouverture de fichiers avec différents formats

Aspose.Cells permet aux développeurs d’ouvrir des fichiers de feuille de calcul avec différents formats tels que SpreadsheetML, CSV, fichiers délimités par des tabulations. Pour ouvrir de tels fichiers, les développeurs peuvent utiliser la même méthodologie que celle qu’ils utilisent pour ouvrir des fichiers de différentes versions d’Excel Microsoft.

Ouverture des fichiers SpreadsheetML

Les fichiers SpreadsheetML sont les représentations XML de vos feuilles de calcul, y compris toutes les informations sur la feuille de calcul telles que le formatage, les formules, etc. Depuis Microsoft Excel XP, une option d’exportation XML est ajoutée à Microsoft Excel qui exporte vos feuilles de calcul vers des fichiers SpreadsheetML.

Pour ouvrir les fichiers SpreadsheetML, utilisez le**LoadOptions** classe et sélectionnez la**SPREADSHEET_ML** valeur dans le**ChargerFormat**énumération.

Exemple

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

Ouverture des fichiers CSV

Les fichiers de valeurs séparées par des virgules (CSV) contiennent des enregistrements dont les valeurs sont délimitées ou séparées par des virgules. Dans les fichiers CSV, les données sont stockées dans un format tabulaire dont les champs sont séparés par une virgule et entre guillemets. Si la valeur d’un champ contient un guillemet double, elle est échappée avec une paire de guillemets doubles. Vous pouvez également utiliser Microsoft Excel pour exporter vos données de feuille de calcul vers un fichier CSV.

Pour ouvrir les fichiers CSV, utilisez le**LoadOptions** classe et sélectionnez la**CSV** valeur, prédéfinie dans le**ChargerFormat**énumération.

Exemple

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

Ouverture des fichiers CSV et remplacement des caractères invalides

Dans Excel, lorsque le fichier CSV avec des caractères spéciaux est ouvert, les caractères sont automatiquement remplacés. La même chose est faite par Aspose.Cells API qui est démontré dans l’exemple de code ci-dessous.

Exemple

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

Ouverture de fichiers CSV à l’aide de l’analyseur préféré

Il n’est pas toujours nécessaire d’utiliser les paramètres d’analyseur par défaut pour ouvrir les fichiers CSV. Parfois, l’importation du fichier CSV ne crée pas la sortie attendue, car le format de date n’est pas celui attendu ou les champs vides sont traités différemment. Dans ce but**TxtLoadOptions.PreferredParsers**est disponible pour fournir son propre analyseur préféré pour analyser différents types de données selon les besoins. L’exemple de code suivant illustre l’utilisation de l’analyseur préféré.

Des exemples de fichiers source et de sortie peuvent être téléchargés à partir des liens suivants pour tester cette fonctionnalité.

exemplePreferredParser.csv

outputsamplePreferredParser.xlsx

Exemple

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

Ouverture de fichiers TSV (délimités par des tabulations)

Les fichiers délimités par des tabulations contiennent des données de feuille de calcul mais sans aucune mise en forme. Les données sont organisées en lignes et en colonnes telles que des tableaux et des feuilles de calcul. En bref, un fichier délimité par des tabulations est un type spécial de fichier texte brut avec une tabulation entre chaque colonne du texte.

Pour ouvrir des fichiers délimités par des tabulations, les développeurs doivent utiliser le**LoadOptions** classe et sélectionnez la**TSV** valeur, prédéfinie dans le**ChargerFormat**énumération.

Exemple

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

Ouverture de fichiers Excel cryptés

Nous savons qu’il est possible de créer des fichiers Excel cryptés en utilisant Microsoft Excel. Pour ouvrir de tels fichiers chiffrés, les développeurs doivent appeler une méthode spéciale LoadOptions surchargée et sélectionner la valeur DEFAULT, prédéfinie dans l’énumération FileFormatType. Cette méthode prendrait également le mot de passe du fichier crypté, comme indiqué ci-dessous dans l’exemple.

Exemple

// 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 prend également en charge l’ouverture de fichiers MS Excel 2013 protégés par mot de passe.

Il y a de bonnes chances que le constructeur Workbook lève System.OutOfMemoryException lors du chargement de feuilles de calcul volumineuses. Cette exception suggère que la mémoire disponible est insuffisante pour charger complètement la feuille de calcul dans la mémoire, par conséquent, la feuille de calcul doit être chargée tout en activant lePréférences de mémoire.

Ouverture des fichiers SXC

StarOffice Calc est similaire à Microsoft Excel et prend en charge les formules, les graphiques, les fonctions et les macros. Les feuilles de calcul créées avec ce logiciel sont enregistrées avec l’extension SXC. Le fichier SXC est également utilisé pour les fichiers de feuille de calcul OpenOffice.org Calc. Aspose.Cells peut lire les fichiers SXC comme illustré par l’exemple de code suivant.

Exemple

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

Ouverture des fichiers FODS

Le fichier FODS est une feuille de calcul enregistrée dans OpenDocument XML sans aucune compression. Aspose.Cells peut lire les fichiers FODS comme le montre l’exemple de code suivant.

Exemple

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

Sujets avancés

• Filtrer les noms définis lors du chargement du classeur
• Filtrer les objets lors du chargement du classeur ou de la feuille de calcul
• Obtenir des avertissements lors du chargement du fichier Excel
• Conserver les séparateurs pour les lignes vides lors de l’exportation des feuilles de calcul au format CSV
• Charger le classeur avec le format de papier d’imprimante spécifié
• Ouverture de différents fichiers de versions Excel Microsoft
• Optimisation de l’utilisation de la mémoire lors de l’utilisation de fichiers volumineux contenant de grands ensembles de données
• Lire la feuille de calcul Numbers développée par Apple Inc. en utilisant Aspose.Cells
• Lecture du fichier CSV avec plusieurs encodages
• Arrêtez la conversion ou le chargement à l’aide d’InterruptMonitor lorsque cela prend trop de temps
• Utilisation de LightCells API