XQA
Back to Java
2026-02-236 min read

HTML Tables (Java)

Learn HTML Tables (Java) step by step with clear examples and exercises.

Why This Matters

HTML tables are an essential part of web development, allowing for the organization and presentation of complex data in a structured manner. By learning how to create HTML tables using Java, developers can build more dynamic and user-friendly web applications.

In addition to their practical use, understanding HTML tables is crucial for various scenarios, such as exams, interviews, and real-world projects.

Prerequisites

To follow this lesson, you should have a basic understanding of the following:

  1. Java programming language syntax and concepts
  2. Basic HTML and CSS
  3. Understanding of web development fundamentals (e.g., HTTP, URLs)
  4. Familiarity with servlets and JSP (JavaServer Pages) for handling requests and generating dynamic content in a web application

Core Concept

In Java, we can create HTML tables using the PrintWriter class within a servlet or JSP file to write HTML content directly to a response object. To create an HTML table, follow these steps:

  1. Import the necessary packages:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
  1. Create a servlet or JSP file that will generate and send the HTML content as a response:

For Servlets:

public class TableServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// Set up the response MIME type (HTML) and character encoding
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();

// Start writing the HTML content
out.println("<!DOCTYPE html>");
out.println("<html lang='en'>");
out.println("<head>");
out.println("<meta charset='UTF-8'>");
out.println("<title>Java HTML Table Example</title>");
out.println("</head>");
out.println("<body>");

// Start the table tag and define its attributes
out.println("<table border='1'>");
out.println("<tr><th>Header 1</th><th>Header 2</th></tr>");

// Add rows to the table
for (int i = 0; i < 5; i++) {
out.println("<tr><td>Row " + (i+1) + "</td><td>Data " + (i*2+1) + "</td></tr>");
}

// Close the table tag and end the HTML content
out.println("</table>");
out.println("</body>");
out.println("</html>");
}
}

For JSP:

<%@ page import="java.io.*" %>
<%@ page import="javax.servlet.*" %>
<%@ page import="javax.servlet.http.*" %>

<html lang='en'>
<head>
<meta charset='UTF-8'>
<title>Java HTML Table Example</title>
</head>
<body>
<table border='1'>
<tr><th>Header 1</th><th>Header 2</th></tr>
<% for (int i = 0; i < 5; i++) { %>
<tr><td>Row <%= i+1 %></td><td>Data <%= i*2+1 %></td></tr>
<% } %>
</table>
</body>
</html>

In this example, we create a simple servlet or JSP file that generates an HTML table with 5 rows and 2 columns. The table is then sent as the response to the client.

Worked Example

Let's create a more complex example where we generate a dynamic table based on user input. We will create a simple form to allow users to enter data, which will be displayed in an HTML table.

  1. First, create a new Java web project and add the following files:
  • index.html (HTML file for the form)
  • TableServlet.java or table.jsp (the servlet or JSP that generates the HTML content)
  1. Update your project's web.xml to map the servlet or JSP to the appropriate URL pattern:

For Servlets:

<servlet>
<servlet-name>TableServlet</servlet-name>
<servlet-class>com.example.TableServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>TableServlet</servlet-name>
<url-pattern>/table</url-pattern>
</servlet-mapping>

For JSP:

No web.xml configuration is required, as JSP files are automatically mapped by the servlet container.

  1. Update index.html to include a form for user input:
<!DOCTYPE html>
<html lang='en'>
<head>
<meta charset='UTF-8'>
<title>Java HTML Table Example</title>
</head>
<body>
<h1>Enter Data for the Table:</h1>
<form action="/table" method="get">
<label for="rows">Number of Rows:</label><br>
<input type="number" id="rows" name="rows" min="1" max="50"><br>
<label for="columns">Number of Columns:</label><br>
<input type="number" id="columns" name="columns" min="1" max="20"><br>
<button type="submit">Generate Table</button>
</form>
</body>
</html>
  1. Update TableServlet.java or table.jsp to generate a dynamic table based on user input:

For Servlets:

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class TableServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// Get user input from the form
int rows = Integer.parseInt(request.getParameter("rows"));
int columns = Integer.parseInt(request.getParameter("columns"));

// Set up the response MIME type (HTML) and character encoding
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();

// Start writing the HTML content
out.println("<!DOCTYPE html>");
out.println("<html lang='en'>");
out.println("<head>");
out.println("<meta charset='UTF-8'>");
out.println("<title>Dynamic Java HTML Table</title>");
out.println("</head>");
out.println("<body>");

// Start the table tag and define its attributes
out.println("<table border='1'>");
for (int i = 0; i < rows; i++) {
out.println("<tr>");
for (int j = 0; j < columns; j++) {
out.println("<td>" + (i * columns + j + 1) + "</td>");
}
out.println("</tr>");
}

// Close the table tag and end the HTML content
out.println("</table>");
out.println("</body>");
out.println("</html>");
}
}

For JSP:

<%@ page import="java.io.*" %>
<%@ page import="javax.servlet.*" %>
<%@ page import="javax.servlet.http.*" %>

<html lang='en'>
<head>
<meta charset='UTF-8'>
<title>Dynamic Java HTML Table</title>
</head>
<body>
<table border='1'>
<% for (int i = 0; i < rows; i++) { %>
<tr>
<% for (int j = 0; j < columns; j++) { %>
<td><%= i * columns + j + 1 %></td>
<% } %>
</tr>
<% } %>
</table>
</body>
</html>
  1. Run your web application, open http://localhost:8080/ in a browser, and test the form by entering different numbers of rows and columns to generate dynamic tables.

Common Mistakes

  1. Forgetting to set the MIME type (response.setContentType("text/html;charset=UTF-8");)
  2. Not closing the table tag properly (out.println("");)
  3. Incorrectly parsing user input (e.g., using Integer.parseInt() on a null or empty string)
  4. Forgetting to define the number of rows and columns in the table generation code
  5. Not escaping user-generated content properly, which can lead to cross-site scripting (XSS) vulnerabilities
  6. Failing to handle exceptions and errors appropriately within your servlet or JSP code
  7. Neglecting to optimize performance by minimizing HTTP requests, caching static resources, and using efficient algorithms for generating dynamic content
  8. Overlooking the importance of user experience (UX) and accessibility considerations when designing HTML tables

Practice Questions

  1. Modify the example to allow users to sort the generated table by one of the columns.
  2. Add a search functionality that allows users to find specific data in the table.
  3. Create a paginated version of the dynamic table, where only a certain number of rows are displayed at a time.
  4. Implement styling for the table using CSS.
  5. Optimize the performance of your servlet or JSP code by implementing best practices such as caching and minimizing HTTP requests.
  6. Ensure that your HTML tables are accessible to users with disabilities by following WAI (Web Accessibility Initiative) guidelines.

FAQ

  1. Why is it important to set the MIME type?

Setting the MIME type helps the browser understand the nature of the data being sent and ensures that it is rendered correctly. In our case, setting the MIME type to "text/html" tells the browser that we are sending HTML content.

  1. Why do I need to close the table tag properly?

Properly closing the table tag ensures that the generated HTML is well-formed and can be correctly parsed by browsers, which is essential for proper display and functionality.

  1. What should I do to prevent XSS vulnerabilities in user-generated content?

To prevent XSS vulnerabilities, always validate and sanitize user-generated content before outputting it to the browser. This can be achieved by using libraries such as OWASP's Escaper or by manually escaping special characters like `, and &`.

  1. What are some best practices for optimizing performance in servlets or JSPs?

Some best practices include caching static resources, minimizing HTTP requests, using efficient algorithms for generating dynamic content, and handling exceptions and errors appropriately.

  1. How can I make my HTML tables accessible to users with disabilities?

To make your HTML tables accessible, follow WAI guidelines such as providing descriptive table headers (th elements), using appropriate ARIA roles and properties, and ensuring that the table is properly structured and labeled.

HTML Tables (Java) | Java | XQA Learn