How to print a table of arrays?

Question

I'm here to see if anyone would be able to help out with the problem.

I'm trying to print a table out which would look something like this

             Month #1      Month #2
   Person 1  $1293         $128
   Person 2  $122          $1233

I've already done all other steps on getting the number, etc i'm just stuck in my last step of getting the correct output as a table.

int[][] table = new int[people][month];

     // Load the table with values
    for (int i=0; i < table.length; i++){     
          for (int j=0; j < table[i].length; j++){
            table[i][j] = r.nextInt(20000-1000) + 1000;
           }
      }

      // Print the table
      System.out.println("\n\nSummer Internship Salary Information:");
      for (int i=0; i < table.length; i++) {
          for (int j=0; j < table[i].length; j++)                    
             System.out.print ("Person #" + (i+1) + "$" + table[i][j] + "\t");
         System.out.println();     

      } 

the initial size of the array is determined by the user. and the 1st part of loading the table with values. That can be ignore.

The part im having real trouble with is printing out into a table from. From the code i'm having now, it gives an output of

     person#1 $12312   person #1 $12312
     person#2 $12312   person #2 $12312

(note that the numbers are not the correct number,its just an example)

how can i enable it to have an output that looks like :

              Month#1   Month#2
    Person#1  $12312    $12312
    Person#2  $12312    $12312

And I'm not allowed to use the call method or JCF in this exercise.

Answer 1

I know this post is very old but, because I often fall in this question, probably because on internet it is watched by many people, I finally wanted to publish my aswer to it.

I wrote a very simple class that uses the String.format method to format a generic table of objects:

public class TableFormatter {
    private int columns;
    private List<String> cells = new LinkedList<>();
    private int minSpacesBetweenCells = 4;
    private boolean alignLeft = true;
    private int maxLength = 0;

    public TableFormatter(int columns) {
        this.columns = columns;
    }

    public TableFormatter insert(Object... cells) {
        for (Object content : cells) {
            String cell = content.toString();
            maxLength = Math.max(maxLength, cell.length());
            this.cells.add(cell);
        }
        return this;
    }

    public TableFormatter setMinSpacesBetweenCells(int minSpacesBetweenCells) {
        this.minSpacesBetweenCells = minSpacesBetweenCells;
        return this;
    }

    public TableFormatter alignCellsToRight() {
        this.alignLeft = false;
        return this;
    }

    public TableFormatter alignCellsToLeft() {
        this.alignLeft = true;
        return this;
    }

    @Override
    public String toString() {
        String format = "%";
        if (alignLeft)
            format += "-";
        format += maxLength + "s";

        String spaces = new String(new char[minSpacesBetweenCells]).replace("\0", " ");

        StringBuilder sb = new StringBuilder();

        int row = 0;
        int currentColumn = 0;
        for (String cell : cells) {
            if (currentColumn == 0) {
                if (row > 0)
                    sb.append("\n");
            } else {
                sb.append(spaces);
            }

            sb.append(String.format(format, cell));

            currentColumn = (currentColumn + 1) % columns;
            if (currentColumn == 0)
                row++;
        }

        return sb.toString();
    }

    public static void main(String[] args) {
        TableFormatter tableFormatter = new TableFormatter(3);

        tableFormatter.insert("column1", "column2", "column3");
        tableFormatter.insert("e11", 12, "e13");
        tableFormatter.insert("e21", "e22", 23);
        tableFormatter.insert(3.1d, "e32", "e33");
        tableFormatter.insert("e41", "e42", true);

        System.out.println(tableFormatter);
    }
}

See the main method at the bottom of the class. It produces the following output:

column1    column2    column3
e11        12         e13    
e21        e22        23     
3.1        e32        e33    
e41        e42        true   

I hope this will be useful to next visitors of this post.

Answer 2

Because of the variable nature of the columns, I would calculate the "required width" of each column as well. This would be used to "pad" shorter columns to ensure that the columns line up...

This would allow to increase the number of people and the size of there salaries without needing any additional compensation...

public class SalaryColumns {

    public static void main(String[] args) {

        int people = 20;
        int month = 12;

        String monthLabel = "Month #";
        String personLabel = "Person #";

        Random r = new Random(System.currentTimeMillis());
        int[][] table = new int[people][month];

        int[] columWidths = new int[month + 1];
        columWidths[0] = personLabel.length() + Integer.toString(people).length() + 1;
        // Load the table with values
        for (int i = 0; i < table.length; i++) {
            for (int j = 0; j < table[i].length; j++) {
                table[i][j] = r.nextInt(20000 - 1000) + 1000;
                columWidths[j + 1] = Math.max(
                        columWidths[j + 1], 
                        Math.max(
                            monthLabel.length() + Integer.toString(month).length() + 1, 
                            Integer.toString(table[i][j]).length() + 2));
            }
        }


        // Print the table
        System.out.println("\n\nSummer Internship Salary Information:");
        System.out.print(pad("", columWidths[0]));
        for (int i = 0; i < month; i++) {
            String value = monthLabel + String.format("%d", i);
            value += pad(value, columWidths[i + 1]);
            System.out.print(value);
        }
        System.out.println();

        for (int i = 0; i < table.length; i++) {
            String value = personLabel + String.format("%d", i);
            value += pad(value, columWidths[0]);
            System.out.print(value);
            for (int j = 0; j < table[i].length; j++) {
                value = String.format("$%d", table[i][j]);
                value += pad(value, columWidths[j + 1]);
                System.out.print(value);
            }
            System.out.println();

        }
    }

    public static String pad(String value, int length) {
        StringBuilder sb = new StringBuilder(length);
        while ((value.length() + sb.length()) < length) {
            sb.append(" ");
        }
        return sb.toString();
    }
}

Which outputs something like...

           Month #0  Month #1  Month #2  Month #3  Month #4  Month #5  Month #6  Month #7  Month #8  Month #9  Month #10 Month #11 
Person #0  $19428    $6333     $19057    $9502     $3265     $3731     $13855    $10254    $2997     $11370    $3264     $13038    
Person #1  $11988    $2313     $7722     $13457    $1100     $10589    $5453     $5996     $12301    $11490    $12283    $4407     
Person #2  $15179    $13993    $19421    $12370    $12090    $18623    $13716    $13215    $7308     $8446     $6657     $7861     
Person #3  $19673    $2956     $10505    $11141    $2020     $1025     $6833     $8821     $4366     $4127     $8938     $16353    
Person #4  $17210    $9442     $7960     $3178     $19924    $17406    $9637     $11655    $13862    $9136     $17205    $10832    
Person #5  $1609     $16141    $17245    $5073     $5716     $17390    $11861    $10235    $12540    $6037     $5199     $1782     
Person #6  $10721    $2257     $16660    $6635     $17384    $9606     $17578    $16799    $4066     $1960     $9563     $4705     
Person #7  $13224    $17277    $5932     $8532     $17321    $12650    $9672     $12527    $2251     $2702     $9033     $10322    
Person #8  $11625    $14107    $1171     $19300    $18455    $13178    $15637    $19687    $12751    $8870     $9412     $6501     
Person #9  $18550    $17017    $6902     $16676    $1057     $12067    $17656    $9220     $15494    $18450    $17341    $10378    
Person #10 $18408    $1907     $1203     $17781    $17106    $4861     $19259    $16245    $12223    $16278    $4429     $18283    
Person #11 $17548    $6160     $18262    $9116     $15075    $16619    $19431    $3463     $15789    $17814    $2059     $16414    
Person #12 $3882     $14816    $6580     $14257    $2192     $11033    $1387     $12269    $14246    $18406    $14794    $9036     
Person #13 $14124    $10216    $11960    $7462     $18001    $6254     $12928    $18118    $14161    $10585    $8102     $7295     
Person #14 $9849     $4085     $7184     $16173    $6847     $10288    $1796     $17384    $11323    $10811    $2636     $9946     
Person #15 $13500    $15157    $7618     $1810     $9368     $3295     $12586    $17489    $16092    $10978    $15227    $5506     
Person #16 $19668    $8540     $16249    $1039     $13672    $14082    $8978     $2710     $17092    $11280    $8090     $10266    
Person #17 $18138    $7467     $18246    $7110     $16501    $6583     $14026    $14204    $10877    $18628    $14575    $4836     
Person #18 $15090    $1579     $15613    $8480     $15854    $15687    $10024    $17004    $15452    $16351    $13714    $19755    
Person #19 $11015    $1152     $11733    $7620     $18217    $8518     $7243     $11819    $10313    $4339     $13532    $13700    

Answer 3

Assuming all people have the same number of months:

System.out.println("\n\nSummer Internship Salary Information:");
for (int j=0; j < table[0].length; j++) {
    System.out.print("\tMonth #" + (j+1));
}
for (int i=0; i < table.length; i++) {
    System.out.print("\nPerson #" + (i+1));
    for (int j=0; j < table[i].length; j++) {
        System.out.print("\t$" + table[i][j]);
    }
}
System.out.println();

Notice that the Person# is taken out of the inner loop, and the column headings are printed first.

Also beware that if any number is too wide (wider than a tabstop) it will break the layout. You would have to be cleverer to fix that (find maximum width for each column first or truncate the values)

(Edited to put tabs and newlines in better places; fewer strings and no trailing tabs)