Convertir des données texte simples en un classeur Excel structuré est une tâche fréquente pour les développeurs Java qui doivent analyser ou partager des informations. Conholdate.Total for Java est un SDK puissant qui simplifie la conversion de TXT en XLSX dans un flux de travail Java sur n’importe quel serveur ou environnement de bureau. Dans ce guide, vous apprendrez comment configurer la bibliothèque, parcourir chaque étape de codage, explorer les options de conversion et appliquer des conseils de performance pour gérer efficacement les gros fichiers.

Avant de commencer : prérequis et installation

Pour suivre ce tutoriel, vous avez besoin de :

  • Java Development Kit 8 ou supérieur
  • Un IDE tel que IntelliJ IDEA ou Eclipse
  • Maven pour la gestion des dépendances
  • Accès à Internet pour télécharger les artefacts du SDK

Ajoutez le référentiel Maven de Conholdate et la dépendance SDK à votre pom.xml :

<repositories>
  <repository>
    <id>conholdate-repo</id>
    <name>Conholdate Maven Repository</name>
    <url>https://repository.conholdate.com/repo/</url>
  </repository>
</repositories>

<dependency>
  <groupId>com.conholdate</groupId>
  <artifactId>conholdate-total</artifactId>
  <version>24.9</version>
  <type>pom</type>
</dependency>

Télécharger le dernier package SDK depuis la page officielle : Télécharger Conholdate.Total for Java. Après que la dépendance soit résolue, vous êtes prêt à commencer à coder. La section suivante parcourt l’implémentation étape par étape.

Construction étape par étape : Convertir TXT en XLSX en Java

Étape 1 : Vérifier que le fichier d’entrée existe

Tout d’abord, assurez-vous que le fichier TXT source est présent. Le code vérifie le chemin du fichier et s’arrête si le fichier est introuvable.

String inputPath = "sample.txt";
File inputFile = new File(inputPath);
if (!inputFile.exists() || !inputFile.isFile()) {
    System.err.println("Input file not found: " + inputPath);
    return;
}

Étape 2 : Configurer les options de conversion

Configurez la façon dont le SDK doit interpréter les données TXT. Vous pouvez définir le délimiteur (tabulation, virgule, point-virgule, etc.), conserver le formatage d’origine et activer la mise en cache en mémoire pour les gros fichiers.

XlsxConvertOptions options = new XlsxConvertOptions();
options.setDelimiter('\t');               // Tab‑delimited example
options.setPreserveOriginalFormatting(true);
options.setEnableMemoryCache(true);

Pour plus de détails, consultez la référence API XlsxConvertOptions.

Étape 3 : Exécuter la conversion

Créez une instance Conversion avec le fichier d’entrée et appelez convert pour produire la sortie XLSX.

String outputPath = "sample.xlsx";
try (Conversion conversion = new Conversion(inputFile)) {
    conversion.convert(outputPath, options);
} catch (ConversionException | IOException e) {
    System.err.println("Conversion failed: " + e.getMessage());
    e.printStackTrace();
    return;
}

La classe Conversion effectue le travail lourd en coulisses, transformant chaque ligne du fichier TXT en lignes et colonnes dans la feuille de calcul.

Étape 4 : Vérifier le fichier de sortie et consigner le résultat

Après la conversion, vérifiez que le fichier XLSX a été créé et n’est pas vide.

File outputFile = new File(outputPath);
if (outputFile.exists() && outputFile.isFile() && outputFile.length() > 0) {
    System.out.println("Conversion succeeded. Output file: " + outputPath);
} else {
    System.err.println("Conversion completed but output file is missing or empty.");
}

Étape 5 : Validation rapide avec Apache POI

Facultativement, utilisez Apache POI pour lire le classeur généré et confirmer le nombre de feuilles et de lignes.

try (XSSFWorkbook workbook = new XSSFWorkbook(Files.newInputStream(Paths.get(outputPath)))) {
    int sheetCount = workbook.getNumberOfSheets();
    System.out.println("Workbook contains " + sheetCount + " sheet(s).");
    if (sheetCount > 0) {
        Sheet sheet = workbook.getSheetAt(0);
        int rowCount = sheet.getPhysicalNumberOfRows();
        System.out.println("First sheet row count: " + rowCount);
    }
} catch (IOException ex) {
    System.err.println("Failed to read generated XLSX for validation: " + ex.getMessage());
}

Une fois la conversion terminée, vous pouvez désormais explorer des options de configuration supplémentaires ou mettre à l’échelle le processus pour convertir en lot de nombreux fichiers.

Exemple complet fonctionnel de conversion de TXT en XLSX en Java

Le code suivant montre l’implémentation complète du flux de travail de conversion de TXT en XLSX en Java en utilisant Conholdate.Total for Java.

import com.groupdocs.conversion.Conversion;
import com.groupdocs.conversion.options.convert.XlsxConvertOptions;
import com.groupdocs.conversion.exceptions.ConversionException;

import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.poi.ss.usermodel.Sheet;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class TxtToXlsxConverter {
    public static void main(String[] args) {
        // Input TXT file and desired XLSX output paths
        String inputPath = "sample.txt";
        String outputPath = "sample.xlsx";

// Verify that the input file exists
        File inputFile = new File(inputPath);
        if (!inputFile.exists() || !inputFile.isFile()) {
            System.err.println("Input file not found: " + inputPath);
            return;
        }

// Configure conversion options
        XxlsxConvertOptions options = new XlsxConvertOptions();
        // Set delimiter (tab, comma, semicolon, etc.). Here we use tab.
        options.setDelimiter('\t');
        // Preserve original formatting where possible
        options.setPreserveOriginalFormatting(true);
        // Enable memory cache to improve performance on large files
        options.setEnableMemoryCache(true);

// Perform the conversion
        try (Conversion conversion = new Conversion(inputFile)) {
            conversion.convert(outputPath, options);
        } catch (ConversionException | IOException e) {
            System.err.println("Conversion failed: " + e.getMessage());
            e.printStackTrace();
            return;
        }

// Validate that the XLSX file was created and is not empty
        File outputFile = new File(outputPath);
        if (outputFile.exists() && outputFile.isFile() && outputFile.length() > 0) {
            System.out.println("Conversion succeeded. Output file: " + outputPath);

// Optional quick validation using Apache POI
            try (XSSFWorkbook workbook = new XSSFWorkbook(Files.newInputStream(Paths.get(outputPath)))) {
                int sheetCount = workbook.getNumberOfSheets();
                System.out.println("Workbook contains " + sheetCount + " sheet(s).");
                if (sheetCount > 0) {
                    Sheet sheet = workbook.getSheetAt(0);
                    int rowCount = sheet.getPhysicalNumberOfRows();
                    System.out.println("First sheet row count: " + rowCount);
                }
            } catch (IOException ex) {
                System.err.println("Failed to read generated XLSX for validation: " + ex.getMessage());
            }
        } else {
            System.err.println("Conversion completed but output file is missing or empty.");
        }
    }
}

Remarque : Cet exemple de code démontre la fonctionnalité principale. Avant de l’utiliser dans votre projet, assurez‑vous de mettre à jour tous les chemins de fichiers et les valeurs de configuration pour qu’ils correspondent à votre environnement réel, vérifiez que toutes les dépendances requises sont correctement installées et testez soigneusement dans votre environnement de développement. Si vous rencontrez des problèmes, veuillez consulter la documentation officielle ou contacter l’équipe de support pour obtenir de l’aide.

Configuration des options de conversion

Le SDK expose plusieurs options qui vous permettent d’ajuster finement le processus de conversion :

  • Delimiter - Détermine comment le SDK divise chaque ligne du fichier TXT en colonnes. L’exemple utilise un caractère de tabulation ('\t'). Vous pouvez le changer en une virgule (',') ou tout autre caractère correspondant à vos données source.
  • PreserveOriginalFormatting - Lorsqu’il est défini sur true, le SDK tente de conserver le style de texte original (comme le gras ou l’italique) dans les cellules XLSX résultantes.
  • EnableMemoryCache - L’activation de ce drapeau améliore les performances pour les gros fichiers en mettant en cache les données intermédiaires en mémoire.

Ces options sont configurées via l’objet XlsxConvertOptions, comme indiqué dans la section étape par étape ci‑dessus.

Optimisation des performances de conversion

Lors de la conversion de gros fichiers TXT, prenez en compte les conseils suivants :

  1. Activer le cache mémoire - options.setEnableMemoryCache(true); réduit les entrées/sorties disque et accélère le traitement.
  2. Diffuser l’entrée - Le SDK lit le fichier source de manière flux, mais évitez de charger le fichier entier dans une String avant la conversion.
  3. Réutiliser les instances de conversion - Si vous devez convertir de nombreux fichiers, créez un seul objet Conversion par thread et réutilisez‑le pour chaque fichier afin de minimiser la surcharge de création d’objets.
  4. Ajuster le tas JVM - Pour des ensembles de données très volumineux, augmentez la taille du tas JVM (-Xmx2g ou plus) pour éviter OutOfMemoryError.

Appliquer ces pratiques garantit que l’opération de conversion de TXT en XLSX en Java reste rapide et efficace en mémoire, même avec des fichiers source de plusieurs gigaoctets.

Conclusion

Vous avez maintenant vu comment convertir TXT en XLSX en Java en utilisant Conholdate.Total for Java. Le SDK gère l’analyse des délimiteurs, la préservation du formatage et la gestion de la mémoire, vous permettant de générer des classeurs Excel professionnels sans dépendre de Microsoft Office. Pour les déploiements en production, n’oubliez pas d’acquérir une licence appropriée ; vous pouvez consulter les détails des tarifs sur la page de tarification et obtenir une licence temporaire pour les tests sur la page de licence temporaire. Avec le code et les conseils de ce guide, vous pouvez intégrer la conversion TXT‑vers‑XLSX dans n’importe quelle application Java, automatiser le traitement par lots et fournir des données dans un format que les utilisateurs finaux peuvent facilement manipuler.

FAQs

Comment convertir un fichier TXT en XLSX en Java à l’aide du SDK ?

Utilisez la classe Conversion avec XlsxConvertOptions. Définissez le délimiteur souhaité, activez le cache mémoire et appelez conversion.convert(outputPath, options). L’exemple complet est fourni dans la section “Exemple complet”.

Puis-je convertir des fichiers TXT délimités en XLSX sans écrire de code d’analyse personnalisé ?

Oui. La méthode XlsxConvertOptions.setDelimiter du SDK vous permet de spécifier le délimiteur (virgule, tabulation, point‑virgule, etc.) afin de pouvoir convertir des fichiers TXT délimités en XLSX en Java avec un seul appel d’API.

Est-il possible de créer un classeur multi‑feuilles à partir d’une source TXT unique ?

Bien que l’exemple de base crée une feuille, vous pouvez diviser les données d’entrée de manière programmatique et invoquer des conversions séparées pour chaque segment, puis combiner les feuilles résultantes en un classeur XLSX multi‑feuilles à l’aide d’Apache POI ou des fonctionnalités avancées du SDK.

En savoir plus