You want to align strings left, right, or centered.

Do the math yourself, and use substring (Section 3.2) and a StringBuffer (Section 3.4). Or, just use my StringAlign class, which is based on the java.text.Format class.

Centering, or left- or right-aligning text, comes up surprisingly often. Suppose you want to print a simple report with centered page numbers. There doesn’t seem to be anything in the standard API that will do the job fully for you. But I have written a class called StringAlign that will. Here’s how you might use it:

/* Align a page number on a 70-character line. */
public class StringAlignSimple {

    public static void main(String[] args) {
        // Construct a "formatter" to center strings.
        StringAlign formatter = new StringAlign(70, StringAlign.JUST_CENTER);
        // Try it out, for page "i"
        System.out.println(formatter.format("- i -"));
        // Try it out, for page 4. Since this formatter is
        // optimized for Strings, not specifically for page numbers,
        // we have to convert the number to a String
        System.out.println(formatter.format(Integer.toString(4)));
    }
}

If we compile and run this class, it prints the two demonstration line numbers centered, as shown:

> jikes +E -d . StringAlignSimple.java
> java StringAlignSimple
                                - i -
                                  4
>

Here is the code for the StringAlign class. Note that this class extends a class called Format . In the package java.text there is a series of Format classes; they all have at least one method called format( ). It is thus in a family with numerous other formatters such as DateFormat, NumberFormat, and others that we’ll meet in upcoming chapters.

import java.text.*;

/** Bare-minimum String formatter (string aligner). */
public class StringAlign extends Format {
    /* Constant for left justification. */
    public static final int JUST_LEFT = 'l';
    /* Constant for centering. */
    public static final int JUST_CENTRE = 'c';
    /* Centering Constant, for those who spell "centre" the American way. */
    public static final int JUST_CENTER = JUST_CENTRE;
    /** Constant for right-justified Strings. */
    public static final int JUST_RIGHT = 'r';

    /** Current justification */
    private int just;
    /** Current max length */
    private int maxChars;

    public StringAlign(int maxChars, int just) {
        switch(just) {
        case JUST_LEFT:
        case JUST_CENTRE:
        case JUST_RIGHT:
            this.just = just;
            break;
        default:
            throw new IllegalArgumentException("invalid justification arg.");
        }
        if (maxChars < 0) {
            throw new IllegalArgumentException("maxChars must be positive.");
        }
        this.maxChars = maxChars;
    }

    /** Format a String */
    public StringBuffer format(
        Object obj, StringBuffer where, FieldPosition ignore)  {

        String s = (String)obj;
        String wanted = s.substring(0, Math.min(s.length(  ), maxChars));

        // If no space left for justification, return maxChars' worth */
        if (wanted.length(  ) > maxChars) {
            where.append(wanted);
        }
        // Else get the spaces in the right place.
        else switch (just) {
            case JUST_RIGHT:
                pad(where, maxChars - wanted.length(  ));
                where.append(wanted);
                break;
            case JUST_CENTRE:
                int startPos = where.length(  );
                pad(where, (maxChars - wanted.length(  ))/2);
                where.append(wanted);
                pad(where, (maxChars - wanted.length(  ))/2);
                // Adjust for "rounding error"
                pad(where, maxChars - (where.length(  ) - startPos));
                break;
            case JUST_LEFT:
                where.append(wanted);
                pad(where, maxChars - wanted.length(  ));
                break;
            }
        return where;
    }

    protected final void pad(StringBuffer to, int howMany) {
        for (int i=0; i<howMany; i++)
            to.append(' '),
    }

    /** Convenience Routine */
    String format(String s) {
        return format(s, new StringBuffer(), null).toString(  );
    }

    /** ParseObject is required, but not useful here. */
    public Object parseObject (String source, ParsePosition pos)  {
        return source;
    }

}

The alignment of numeric columns is considered in Chapter 5.