Convertir datos de texto plano en un libro de Excel estructurado es una tarea frecuente para los desarrolladores Java que necesitan analizar o compartir información. Conholdate.Total for Java es un SDK potente que simplifica la conversión de TXT a XLSX en flujos de trabajo Java en cualquier entorno de servidor o escritorio. En esta guía aprenderá cómo configurar la biblioteca, recorrer cada paso de codificación, explorar las opciones de conversión y aplicar consejos de rendimiento para manejar archivos grandes de manera eficiente.

Antes de comenzar: Requisitos e instalación

Para seguir este tutorial necesitas:

  • Java Development Kit 8 o superior
  • Un IDE como IntelliJ IDEA o Eclipse
  • Maven para la gestión de dependencias
  • Acceso a Internet para descargar los artefactos del SDK

Agregue el repositorio Maven de Conholdate y la dependencia del SDK a su 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>

Descargar el paquete SDK más reciente desde la página oficial: Download Conholdate.Total for Java. Después de resolver la dependencia, estás listo para comenzar a programar. La siguiente sección recorre la implementación paso a paso.

Construyéndolo paso a paso: Convertir TXT a XLSX en Java

Paso 1: Verificar que el archivo de entrada exista

Primero, asegúrese de que el archivo TXT de origen esté presente. El código verifica la ruta del archivo y aborta si no se puede encontrar.

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

Paso 2: Configurar opciones de conversión

Configure cómo el SDK debe interpretar los datos TXT. Puede establecer el delimitador (tabulación, coma, punto y coma, etc.), conservar el formato original y habilitar la caché en memoria para archivos grandes.

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

Para obtener más detalles, consulte la referencia de la API XlsxConvertOptions.

Paso 3: Ejecutar la conversión

Cree una instancia de Conversion con el archivo de entrada y llame a convert para producir la salida 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 clase Conversion se encarga del trabajo pesado en segundo plano, convirtiendo cada línea del archivo TXT en filas y columnas en la hoja de cálculo.

Paso 4: Verificar el archivo de salida y registrar el resultado

Después de la conversión, verifique que el archivo XLSX se haya creado y no esté vacío.

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

Paso 5: Validación rápida con Apache POI

Opcionalmente, use Apache POI para leer el libro de trabajo generado y confirmar el número de hojas y filas.

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

Con la conversión completada, ahora puedes explorar opciones de configuración adicionales o escalar el proceso para convertir en lote muchos archivos.

Ejemplo completo de funcionamiento para convertir TXT a XLSX en Java

El siguiente código muestra la implementación completa del flujo de trabajo para convertir TXT a XLSX en Java usando 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.");
        }
    }
}

Nota: Este ejemplo de código muestra la funcionalidad principal. Antes de usarlo en su proyecto, asegúrese de actualizar cualquier ruta de archivo y valores de configuración para que coincidan con su entorno real, verifique que todas las dependencias requeridas estén instaladas correctamente y realice pruebas exhaustivas en su entorno de desarrollo. Si encuentra algún problema, consulte la documentación oficial o póngase en contacto con el equipo de soporte para obtener ayuda.

Configuración de opciones de conversión

El SDK expone varias opciones que le permiten afinar el proceso de conversión:

  • Delimiter - Determina cómo el SDK divide cada línea del archivo TXT en columnas. El ejemplo usa un carácter de tabulación ('\t'). Puede cambiarlo a una coma (',') o cualquier otro carácter que coincida con sus datos de origen.
  • PreserveOriginalFormatting - Cuando se establece en true, el SDK intenta mantener el estilo de texto original (como negrita o cursiva) en las celdas XLSX resultantes.
  • EnableMemoryCache - Activar esta bandera mejora el rendimiento para archivos grandes al almacenar en caché datos intermedios en memoria.

Estas opciones se configuran a través del objeto XlsxConvertOptions, como se muestra en la sección paso a paso anterior.

Optimización del rendimiento de conversión

Al convertir archivos TXT grandes, tenga en cuenta los siguientes consejos:

  1. Habilitar caché en memoria - options.setEnableMemoryCache(true); reduce la E/S de disco y acelera el procesamiento.
  2. Transmitir la entrada - El SDK lee el archivo fuente de forma streaming, pero evite cargar todo el archivo en una String antes de la conversión.
  3. Reutilizar instancias de conversión - Si necesita convertir muchos archivos, cree un solo objeto Conversion por hilo y reutilícelo para cada archivo para minimizar la sobrecarga de creación de objetos.
  4. Ajustar el heap de JVM - Para conjuntos de datos muy grandes, aumente el tamaño del heap de JVM (-Xmx2g o superior) para evitar OutOfMemoryError.

Aplicar estas prácticas garantiza que la operación de conversión de TXT a XLSX en Java siga siendo rápida y eficiente en memoria, incluso con archivos fuente de tamaño gigabyte.

Conclusión

Ahora ha visto cómo convertir TXT a XLSX en Java usando Conholdate.Total for Java. El SDK maneja el análisis de delimitadores, la preservación del formato y la gestión de memoria, lo que le permite generar libros de Excel profesionales sin depender de Microsoft Office. Para implementaciones en producción, recuerde adquirir una licencia adecuada; puede revisar los detalles de precios en la página de precios y obtener una licencia temporal para pruebas en la página de licencia temporal. Con el código y los consejos de esta guía, puede integrar la conversión de TXT‑a‑XLSX en cualquier aplicación Java, automatizar el procesamiento por lotes y entregar datos en un formato que los usuarios finales puedan manipular fácilmente.

Preguntas frecuentes

¿Cómo convierto TXT a XLSX en Java usando el SDK?

Utilice la clase Conversion junto con XlsxConvertOptions. Establezca el delimitador deseado, habilite la caché en memoria y llame a conversion.convert(outputPath, options). El ejemplo completo se proporciona en la sección “Full Working Example”.

¿Puedo convertir archivos TXT delimitados a XLSX sin escribir código de análisis personalizado?

Sí. El método XlsxConvertOptions.setDelimiter del SDK le permite especificar el delimitador (coma, tabulación, punto y coma, etc.) para que pueda convertir archivos TXT delimitados a XLSX en Java con una única llamada a la API.

¿Es posible crear un libro de trabajo de varias hojas a partir de una única fuente TXT?

Mientras el ejemplo básico crea una hoja, puedes dividir los datos de entrada programáticamente e invocar conversiones separadas para cada segmento, y luego combinar las hojas resultantes en un libro de trabajo XLSX de varias hojas usando Apache POI o las funciones avanzadas del SDK.

Leer más