Last Updated: 

Converting XLS to HTML in Java

In the world of data processing and presentation, there are often scenarios where you need to convert Excel (XLS) files into HTML format. This conversion can be useful for various reasons, such as displaying data on a web page, sharing data in a more accessible format, or integrating Excel data into web applications. Java, being a versatile and widely-used programming language, offers several ways to achieve this conversion. In this blog post, we will explore the core concepts, typical usage scenarios, common pitfalls, and best practices related to converting XLS to HTML in Java.

Table of Contents#

  1. Core Concepts
  2. Typical Usage Scenarios
  3. Java Libraries for XLS to HTML Conversion
  4. Code Example
  5. Common Pitfalls
  6. Best Practices
  7. Conclusion
  8. FAQ
  9. References

Core Concepts#

XLS Files#

XLS is the file format used by Microsoft Excel versions prior to Excel 2007. It is a binary file format that stores spreadsheet data, including cells, rows, columns, formulas, and formatting information.

HTML Files#

HTML (Hypertext Markup Language) is the standard markup language for creating web pages. It uses tags to structure content, such as headings, paragraphs, tables, and images. When converting an XLS file to HTML, we essentially transform the spreadsheet data into an HTML table structure, preserving as much of the original formatting as possible.

Typical Usage Scenarios#

  1. Web-based Data Presentation: You may have an Excel spreadsheet containing sales data, and you want to display this data on a company's internal website. Converting the XLS file to HTML allows you to embed the data in a web page easily.
  2. Data Sharing: Sharing Excel files can sometimes be cumbersome, especially if the recipient does not have Excel installed. Converting the XLS file to HTML makes it accessible to a wider audience, as any web browser can display the HTML file.
  3. Integration with Web Applications: If you are developing a web application that needs to process and display Excel data, converting the XLS file to HTML can simplify the integration process.

Java Libraries for XLS to HTML Conversion#

Apache POI#

Apache POI is a popular Java library for working with Microsoft Office file formats, including XLS. It provides a set of classes and methods to read, write, and manipulate Excel files. To convert an XLS file to HTML using Apache POI, you need to extract the data and formatting information from the XLS file and generate an HTML table.

JExcelAPI#

JExcelAPI is another Java library for working with Excel files. It is relatively lightweight and easy to use. Similar to Apache POI, it allows you to read data from an XLS file and convert it to HTML.

In this example, we will use Apache POI for the conversion.

Code Example#

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import java.io.*;
 
public class XlsToHtmlConverter {
    public static void main(String[] args) {
        try {
            // Step 1: Read the XLS file
            FileInputStream file = new FileInputStream(new File("input.xls"));
            Workbook workbook = new HSSFWorkbook(file);
 
            // Step 2: Create a StringBuilder to build the HTML content
            StringBuilder htmlContent = new StringBuilder();
            htmlContent.append("<html><body><table border='1'>");
 
            // Step 3: Iterate through each sheet in the workbook
            for (int i = 0; i < workbook.getNumberOfSheets(); i++) {
                Sheet sheet = workbook.getSheetAt(i);
                // Iterate through each row in the sheet
                for (int j = 0; j <= sheet.getLastRowNum(); j++) {
                    Row row = sheet.getRow(j);
                    if (row != null) {
                        htmlContent.append("<tr>");
                        // Iterate through each cell in the row
                        for (int k = 0; k < row.getLastCellNum(); k++) {
                            Cell cell = row.getCell(k);
                            if (cell != null) {
                                switch (cell.getCellType()) {
                                    case STRING:
                                        htmlContent.append("<td>").append(cell.getStringCellValue()).append("</td>");
                                        break;
                                    case NUMERIC:
                                        if (DateUtil.isCellDateFormatted(cell)) {
                                            htmlContent.append("<td>").append(cell.getDateCellValue()).append("</td>");
                                        } else {
                                            htmlContent.append("<td>").append(cell.getNumericCellValue()).append("</td>");
                                        }
                                        break;
                                    case BOOLEAN:
                                        htmlContent.append("<td>").append(cell.getBooleanCellValue()).append("</td>");
                                        break;
                                    default:
                                        htmlContent.append("<td></td>");
                                }
                            } else {
                                htmlContent.append("<td></td>");
                            }
                        }
                        htmlContent.append("</tr>");
                    }
                }
            }
 
            htmlContent.append("</table></body></html>");
 
            // Step 4: Write the HTML content to a file
            FileWriter writer = new FileWriter("output.html");
            writer.write(htmlContent.toString());
            writer.close();
 
            // Step 5: Close the workbook and file input stream
            workbook.close();
            file.close();
 
            System.out.println("Conversion completed successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explanation of the Code#

  1. Reading the XLS File: We use FileInputStream to read the XLS file and create a HSSFWorkbook object, which represents the Excel workbook.
  2. Building the HTML Content: We use a StringBuilder to build the HTML table structure. We iterate through each sheet, row, and cell in the workbook and append the cell values to the HTML table.
  3. Writing the HTML Content to a File: We use FileWriter to write the HTML content to an output file named output.html.
  4. Closing Resources: Finally, we close the workbook and the file input stream to release system resources.

Common Pitfalls#

  1. Formatting Loss: Excel files can have complex formatting, such as cell borders, colors, and fonts. When converting to HTML, some of this formatting may be lost, especially if you are using a simple conversion approach.
  2. Large File Size: If the Excel file is very large, the conversion process can be memory-intensive and may cause out-of-memory errors.
  3. Date and Time Formatting: Excel stores dates and times as numeric values with specific formatting. When converting to HTML, you need to handle date and time formatting correctly to ensure that the values are displayed correctly.

Best Practices#

  1. Handle Formatting Properly: If you want to preserve as much formatting as possible, you can use more advanced techniques, such as applying CSS styles to the HTML table based on the Excel cell formatting.
  2. Optimize Memory Usage: For large Excel files, consider processing the file in chunks instead of loading the entire workbook into memory at once.
  3. Test with Different Excel Files: Test your conversion code with different types of Excel files, including files with complex formatting and large datasets, to ensure that it works correctly in all scenarios.

Conclusion#

Converting XLS to HTML in Java is a useful task that can be achieved using libraries like Apache POI. By understanding the core concepts, typical usage scenarios, and following best practices, you can effectively convert Excel files to HTML and use the data in various applications. However, be aware of the common pitfalls and take appropriate measures to handle them.

FAQ#

Q1: Can I convert XLSX files using the same code?#

A1: No, the code provided is specifically for XLS files. To convert XLSX files, you need to use XSSFWorkbook instead of HSSFWorkbook in Apache POI.

Q2: How can I preserve cell formatting in the HTML output?#

A2: You can analyze the cell formatting information in the Excel file and apply corresponding CSS styles to the HTML table cells.

Q3: Is it possible to convert multiple XLS files at once?#

A3: Yes, you can modify the code to iterate through a list of XLS files and perform the conversion for each file.

References#

  1. Apache POI Documentation: https://poi.apache.org/
  2. JExcelAPI Documentation: http://jexcelapi.sourceforge.net/
  3. HTML Tutorial: https://www.w3schools.com/html/
2025-10