for

The table head my be copied from the code snippet. In addition we require a loop printing the table's body:

final int LIMIT = 9;                       // Upper limit to be printed.

System.out.println("n | n * n");           // Printing the table's
System.out.println("——+——————");           // head.

for (int i = 0; i <= LIMIT; i++) {         // Printing the table's body.
   System.out.println(i + " | " + i * i);
}

The $...d format specifier serves two purposes:

Example:

// Printing 12 right aligned in a field of 5 characters
// padded with 3 spaces to the left
System.out.format("Start:%5d:End", 12);  
                          ▲         ┃        
                          ┗━━━━━━━━━┛ 
                            replace

Start:␣␣␣12:End

The format string "%3d|%6d\n" allows for two decimal output fields of length 3 and 6 respectively. It thus corresponds to the two variables i and i * i being supplied as arguments:

final int LIMIT = 20;              // The number of records to be printed

System.out.println(" n | n * n");  // Printing the table's head
System.out.println("———+——————");

for (int i = 0; i <= LIMIT; i++) { // Printing the table's body

  System.out.format("%3d|%6d\n",   // Format string
                       i , i * i); // Values being inserted in above format
}                                  // string.

This solution works for a particular LIMIT value. A more general solution constructs the format string itself depending on the value of LIMIT:

final int LIMIT = 12; // Upper limit to be printed

// Field lengths for »n« and »n * n« depending on LIMIT
final int
        limitDigitCount = Integer.toString(LIMIT).length(),
        limitSquaredDigitCount = Integer.toString(LIMIT * LIMIT).length();

// Header like » n | n * n«
final String formatHead = "%" + limitDigitCount + "s |%" + limitSquaredDigitCount + "s\n";
System.out.format(formatHead, "n", " n * n");                 // Printing the table's head

// Header like »———+——————«
System.out.println("—".repeat(limitDigitCount + 1) + "+" + "—".repeat(limitSquaredDigitCount + 1));


// Formatting table body entries like e.g. » 9 |  81«
final String format = "%" + limitDigitCount + "d | %" + limitSquaredDigitCount + "d\n";

for (int i = 0; i <= LIMIT; i++) {                   // Printing the table's body
    System.out.format(format, i, i * i);
}

A complete solution is being provided by App.java. This solution uses both Java™ 15 multi line blocks and the String.indent(..) method.

// Block 1: Configuration parameter
final int SIZE = 6;                             // Table size is subject to change.

// Block 2: Printing table's head
System.out.print(" * |  ");                     // Printing table head's first line
for (int col = 1; col <= SIZE; col++) {         // using column values ranging from 1 to SIZE:
    System.out.format("%3d  ", col);            // * |    1    2    3 ...
}
System.out.print("\n———+" +                     // Printing table head's second line
        "—————".repeat(SIZE));                  // ———+——————————————— ...

// Block 3: Printing table's content
// organized in rows and columns.
//
for (int row = 1; row <= SIZE; row++) {         // Printing rows.
    System.out.format("\n%3d|  ", row);         // Printing new line by \n and beginning of row e.g. "  5|"
    for (int col = 1; col <= SIZE; col++) {
        System.out.format("%3d  ", row * col);  // Printing row times column product values.
    }
}

We require two changes with respect to the previous exercise:

You may want to use a debugger to get a quicker code understanding.

// Table parameter
final int
        numBlocksHorizontal = 5,
        numBlocksVertical = 2,
        entriesPerBlock = 10;

// Derived parameter
final int numRows = numBlocksVertical * entriesPerBlock;

System.out.println("  n |   n²     ".repeat(                    // Printing the overall
        numBlocksHorizontal));                                  // table's head section

for (int y = 0;  y < numBlocksVertical; y++) {                  // Looping through vertically stacked blocks.

    System.out.println(                                         // Supplementary separator line between
            "————+——————————".repeat(numBlocksHorizontal));     // two vertically adjacent blocks

    for (int row = 0;                                           // Stepping through the given
         row < entriesPerBlock; row++) {                        // block's rows ...

        for (int col = 0; col < numBlocksHorizontal; col++) {   // ... columns within each row.

            final int cellValue = y * entriesPerBlock           // The cell's value
                    + col * numRows + row;                      // to be squared.

            System.out.format("%3d | %4d     ",                 // Pretty print cell value
                    cellValue, cellValue * cellValue);          // and its square.
        }
        System.out.println();
    }
}

The following solution uses CSS style definitions in the generated HTML's header section being referenced from the document's body.

// Block 1: Setting table parameter
final int numBlocksHorizontal = 5,
        numBlocksVertical = 2,
        entriesPerBlock = 10;

final int numRows = numBlocksVertical * entriesPerBlock;

// Block 2: Printing table's static head
System.out.println("""
        <html xmlns='http://www.w3.org/1999/xhtml'>
          <head>
            <meta charset="UTF-8">
            <title>A square table</title>
            <style>
              table, th, td {border: 1px solid black;}
              table {border-collapse: collapse;}
              td {text-align: right;}
              .greyColumn {background-color:LightGray;}
              </style>
          </head>
          <body>
            <table>
              <colgroup>""");

// Block 3: Creating »n | n² | n  | n² ...« table header
for (int x = 0; x < numBlocksHorizontal; x++) {                 // Creating the overall
                                                                // table's head section.
    if (0 == x % 2) {
        System.out.println("        <col span='2'/>");
    } else {
        System.out.println("        <col span='2' class='greyColumn'/>");
    }
}
System.out.println("      </colgroup>");

System.out.println("      <tr>");
for (int x = 0; x < numBlocksHorizontal; x++) {                 // n | n² header line
    System.out.println("        <th>n</th><th>n²</th>");
}
System.out.println("      </tr>\n");

// Block 4: The table's »payload«.
for (int y = 0; y < numBlocksVertical; y++) {                   // Blocks stacked below another

    System.out.println("      <tr><td></td></tr>");            // extra row.

    for (int yBlock = 0;
         yBlock < entriesPerBlock; yBlock++) {                  // Stepping through values vertically ...
        System.out.println("      <tr>");
        for (int x = 0; x < numBlocksHorizontal; x++) {         // and horizontally within each line.
            final int cellValue = 1 + yBlock                    // The individual value to be squared.
                    + x * numRows + y * entriesPerBlock;

            System.out.println(                                 // Pretty print output
                    "        <td>" + cellValue + "</td><td>"    // value and its square.
                            + cellValue * cellValue + "</td>");
        }
        System.out.println("      </tr>");
    }
}

// Block 5: The table's tail
System.out.print("""
            </table>
          </body>
        </html>""");