Converting HTML Tables to JSON in Java

In the modern web development landscape, data often needs to be transferred and processed in different formats. One common requirement is to convert an HTML table into a JSON object using Java. HTML tables are a popular way to present tabular data on web pages, while JSON (JavaScript Object Notation) is a lightweight data - interchange format that is easy for humans to read and write and easy for machines to parse and generate. This blog post will guide you through the process of converting an HTML table to JSON in Java, covering core concepts, usage scenarios, common pitfalls, and best practices.

Table of Contents#

  1. Core Concepts
  2. Typical Usage Scenarios
  3. Tools and Libraries
  4. Code Example
  5. Common Pitfalls
  6. Best Practices
  7. Conclusion
  8. FAQ
  9. References

Core Concepts#

HTML Tables#

An HTML table is structured using <table>, <tr> (table row), <th> (table header), and <td> (table data) tags. Each <tr> represents a row in the table, and <th> or <td> represent cells within that row.

JSON#

JSON is a text-based data format that uses key-value pairs and arrays. A JSON object is enclosed in curly braces {} and consists of key-value pairs separated by commas. An array is enclosed in square brackets [].

Conversion Process#

The process of converting an HTML table to JSON involves parsing the HTML to extract table data and then transforming that data into a JSON structure. This typically means iterating over table rows and cells and mapping them to appropriate JSON keys and values.

Typical Usage Scenarios#

  1. Web Scraping: When you need to extract tabular data from a web page and process it further, converting the HTML table to JSON makes it easier to manipulate and integrate with other systems.
  2. Data Migration: Moving data from a legacy web-based system that presents data in HTML tables to a modern application that uses JSON for data exchange.
  3. Data Analysis: Converting HTML-based tabular data to JSON allows for easier analysis using data analysis tools that support JSON.

Tools and Libraries#

We will use the following libraries in our example:

  • Jsoup: A Java library for working with real-world HTML. It provides a convenient API for parsing, manipulating, and extracting data from HTML documents.
  • Gson: A Java library that can be used to convert Java objects into their JSON representation and vice versa.

Adding Dependencies#

If you are using Maven, add the following dependencies to your pom.xml:

<dependencies>
    <dependency>
        <groupId>org.jsoup</groupId>
        <artifactId>jsoup</artifactId>
        <version>1.15.3</version>
    </dependency>
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.8.8</version>
    </dependency>
</dependencies>

Code Example#

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
 
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
 
public class HtmlTableToJsonConverter {
 
    public static String convertHtmlTableToJson(String html) {
        // Parse the HTML document using Jsoup
        Document doc = Jsoup.parse(html);
        // Select all table elements in the HTML
        Elements tables = doc.select("table");
        JsonArray jsonTables = new JsonArray();
 
        // Iterate over each table
        for (Element table : tables) {
            JsonArray jsonRows = new JsonArray();
            // Get all table rows
            Elements rows = table.select("tr");
            // Get the table headers
            Elements headers = rows.first().select("th");
            List<String> headerList = new ArrayList<>();
            for (Element header : headers) {
                headerList.add(header.text());
            }
 
            // Iterate over each row starting from the second row (skipping the header row)
            for (int i = 1; i < rows.size(); i++) {
                Element row = rows.get(i);
                Elements cells = row.select("td");
                JsonObject jsonRow = new JsonObject();
                for (int j = 0; j < cells.size(); j++) {
                    String header = headerList.get(j);
                    String cellValue = cells.get(j).text();
                    jsonRow.addProperty(header, cellValue);
                }
                jsonRows.add(jsonRow);
            }
            jsonTables.add(jsonRows);
        }
 
        // Convert the JSON array to a JSON string using Gson
        Gson gson = new Gson();
        return gson.toJson(jsonTables);
    }
 
    public static void main(String[] args) {
        String html = "<table><tr><th>Name</th><th>Age</th></tr><tr><td>John</td><td>30</td></tr><tr><td>Jane</td><td>25</td></tr></table>";
        String json = convertHtmlTableToJson(html);
        System.out.println(json);
    }
}

Code Explanation#

  1. Parsing HTML: We use Jsoup to parse the input HTML string into a Document object.
  2. Selecting Tables: We select all <table> elements in the HTML document.
  3. Extracting Headers: We extract the table headers from the first row of each table.
  4. Iterating over Rows: We iterate over each row in the table, skipping the header row.
  5. Creating JSON Objects: For each row, we create a JSON object with key-value pairs where the keys are the table headers and the values are the cell contents.
  6. Converting to JSON String: Finally, we use Gson to convert the JSON array of rows into a JSON string.

Common Pitfalls#

  1. Missing Headers: If the HTML table does not have proper <th> tags, the conversion process will not be able to map the data correctly to JSON keys.
  2. Nested Tables: If the HTML contains nested tables, the current implementation may not handle them correctly and may lead to incorrect JSON output.
  3. Encoding Issues: If the HTML contains special characters, encoding issues may occur during the conversion process.

Best Practices#

  1. Validate Input: Before performing the conversion, validate the input HTML to ensure it contains proper table structure with headers.
  2. Handle Errors Gracefully: Implement proper error handling in case of issues such as network errors (if fetching HTML from a URL) or parsing errors.
  3. Test with Different HTML Structures: Test the conversion process with different HTML table structures, including tables with nested elements, to ensure robustness.

Conclusion#

Converting an HTML table to JSON in Java is a useful skill for web developers and data analysts. By using libraries like Jsoup and Gson, the process can be made relatively straightforward. However, it is important to be aware of common pitfalls and follow best practices to ensure accurate and reliable conversions.

FAQ#

Q1: Can I convert multiple tables in a single HTML document?#

Yes, the provided code example can handle multiple tables in a single HTML document. Each table will be represented as a separate JSON array within the main JSON array.

Q2: What if the HTML table has no headers?#

If the table has no headers, you will need to define your own headers or use a different approach to structure the JSON output. One option is to use sequential numbers as keys for each cell.

Q3: Can I convert HTML tables fetched from a URL?#

Yes, you can use Jsoup to fetch HTML from a URL. Replace the hard-coded HTML string in the main method with code to fetch the HTML from a URL using Jsoup.connect(url).get().

References#

2025-10