Ouverture de fichiers avec différents formats

Moyens simples d’ouvrir des fichiers Excel

Ouverture par chemin

Pour ouvrir un fichier Microsoft Excel en utilisant le chemin du fichier, transmettez le chemin du fichier en tant que paramètre lors de la création de l’instance de la classe Workbook. Le code d’exemple suivant démontre l’ouverture d’un fichier Excel en utilisant le chemin du 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 un flux

Parfois, le fichier Excel que vous voulez ouvrir est stocké en tant que flux. Dans ce cas, tout comme pour ouvrir un fichier en utilisant le chemin du fichier, transmettez le flux en tant que paramètre lors de l’instanciation de la classe Workbook. Le code d’exemple suivant démontre l’ouverture d’un fichier Excel en utilisant un flux.

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 de Microsoft Excel

L’utilisateur peut utiliser la classe LoadOptions pour spécifier le format du fichier Excel en utilisant l’énumération LoadFormat.

L’énumération LoadFormat contient de nombreux formats de fichier prédéfinis dont certains sont donnés ci-dessous.

Types de format Description
Csv Représente un fichier CSV
Excel97To2003 Représente un fichier Excel 97 - 2003
Xlsx Représente un fichier XLSX Excel 2007/2010/2013/2016/2019 et Office 365
Xlsm Représente un fichier XLSM Excel 2007/2010/2013/2016/2019 et Office 365
Xltx Représente un modèle de fichier XLTX Excel 2007/2010/2013/2016/2019 et Office 365
Xltm Représente un fichier activé par macro XLTM Excel 2007/2010/2013/2016/2019 et Office 365
Xlsb Représente un fichier binaire XLSB Excel 2007/2010/2013/2016/2019 et Office 365
SpreadsheetML Représente un fichier SpreadsheetML
Tsv Représente un fichier de valeurs séparées par des tabulations
TabDelimited Représente un fichier de texte à onglets
Ods Représente un fichier ODS
Html Représente un fichier HTML
Mhtml Représente un fichier MHTML

Ouverture de fichiers Microsoft Excel 95/5.0

Pour ouvrir des fichiers Microsoft Excel 95, instanciez la classe Workbook avec le chemin ou le flux du fichier modèle. Le fichier d’exemple pour tester le code peut être téléchargé depuis le 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 des fichiers XLS de Microsoft Excel 97 ou des versions ultérieures

Pour ouvrir des fichiers XLS de Microsoft Excel XLS 97 ou des versions ultérieures, instanciez la classe Workbook avec le chemin ou le flux du fichier modèle. Ou utilisez la méthode LoadOptions et sélectionnez la valeur EXCEL_97_TO_2003 dans l’énumération LoadFormat.

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 des fichiers XLSX de Microsoft Excel 2007 ou des versions ultérieures

Pour ouvrir des fichiers XLSX de Microsoft Excel 2007 ou des versions ultérieures, instanciez la classe Workbook avec le chemin ou le flux du fichier modèle. Ou utilisez la classe LoadOptions et sélectionnez la valeur XLSX dans l’énumération LoadFormat.

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

Ouvrir des 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élimitation tabulaire. Pour ouvrir de tels fichiers, les développeurs peuvent utiliser la même méthodologie que celle utilisée pour l’ouverture de fichiers de différentes versions de Microsoft Excel.

Ouverture de fichiers SpreadsheetML

Les fichiers SpreadsheetML sont les représentations XML de vos feuilles de calcul, incluant 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 des fichiers SpreadsheetML, utilisez la classe LoadOptions et sélectionnez la valeur SPREADSHEET_ML dans l’énumération LoadFormat.

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 qui a des champs séparés par le caractère virgule et mis entre guillemets par le caractère double quote. Si la valeur d’un champ contient un double guillemet, elle est échappée avec une paire de double guillemets. Vous pouvez également utiliser Microsoft Excel pour exporter les données de votre feuille de calcul vers un fichier CSV.

Pour ouvrir des fichiers CSV, utilisez la classe LoadOptions et sélectionnez la valeur CSV, prédéfinie dans l’énumération LoadFormat.

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, lorsqu’un fichier CSV avec des caractères spéciaux est ouvert, les caractères sont automatiquement remplacés. Il en va de même pour l’API Aspose.Cells qui est démontrée 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 des fichiers CSV en utilisant un analyseur préféré

Ce n’est pas toujours nécessaire d’utiliser les paramètres de l’analyseur par défaut pour ouvrir les fichiers CSV. Parfois, l’importation d’un fichier CSV ne crée pas la sortie attendue, comme le format de date n’est pas tel qu’attendu ou les champs vides sont géré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. Le code d’exemple suivant illustre l’utilisation de l’analyseur préféré.  

Le fichier source d’échantillon et les fichiers de sortie peuvent être téléchargés aux liens suivants pour tester cette fonctionnalité.

samplePreferredParser.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 des fichiers TSV (Séparé par des tabulations)

Les fichiers tabulés contiennent des données de feuilles de calcul mais sans mise en forme. Les données sont disposées en lignes et colonnes comme des tableaux et des feuilles de calcul. Bref, un fichier tabulé est un type spécial de fichier texte simple avec une tabulation entre chaque colonne dans le texte.

Pour ouvrir des fichiers tabulés, les développeurs doivent utiliser la classe LoadOptions et sélectionner la valeur TSV, prédéfinie dans l’énumération LoadFormat.

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 chiffrés

Nous savons qu’il est possible de créer des fichiers Excel chiffrés à l’aide de Microsoft Excel. Pour ouvrir de tels fichiers chiffrés, les développeurs doivent appeler une méthode LoadOptions surchargée spéciale et sélectionner la valeur DEFAULT prédéfinie dans l’énumération FileFormatType. Cette méthode prendrait également le mot de passe pour le fichier chiffré 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.

Ouverture de 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 démontré 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 de fichiers FODS

Le fichier FODS est une feuille de calcul enregistrée au format OpenDocument XML sans 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