Ouverture de fichiers avec différents formats
Utilisation par les développeurs d’Aspose.Cells pour ouvrir des fichiers à différentes fins. Par exemple, ouvrir un fichier pour récupérer des données à partir de celui-ci, ou utiliser un fichier de feuille de calcul 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 source peuvent être des rapports Microsoft Excel, SpreadsheetML, des fichiers de valeurs séparées par des virgules (CSV), des fichiers de valeurs séparées par des onglets ou des valeurs séparées par des onglets (TSV). Cet article traite de l’ouverture de ces différents fichiers source à l’aide d’Aspose.Cells.
Si vous avez besoin de connaître tous les formats de fichier pris en charge, veuillez vous référer aux pages suivantes: Formats de fichiers pris en charge
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 :
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é.
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
- 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 d’un fichier Excel
- Conserver les séparateurs pour les lignes vides lors de l’exportation de feuilles de calcul au format CSV
- Charger le classeur avec une taille de papier d’imprimante spécifiée
- Ouvrir des fichiers de différentes versions de Microsoft Excel
- Optimiser l’utilisation de la mémoire lors du travail avec de gros fichiers contenant de grands ensembles de données
- Lire des feuilles de calcul numériques développées par Apple Inc. à l’aide d’Aspose.Cells
- Lecture d’un fichier CSV avec des encodages multiples
- Arrêter la conversion ou le chargement à l’aide de InterruptMonitor lorsqu’il prend trop de temps
- Utiliser l’API LightCells