Recipe 3.5 Aligning Strings

Problem

You want to align strings to the left, right, or center.

Solution

Do the math yourself, and use substring (Recipe Recipe 3.1) and a StringBuilder (Recipe 3.3). Or, just use my StringAlign class, which is based on the java.text.Format class.

Discussion

Centering and 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 >

Example 3-4 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 that 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.

Example 3-4. StringAlign.java

/** 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;             /** Construct a StringAlign formatter; length and alignment are             * passed to the Constructor instead of each format( ) call as the              * expected common use is in repetitive formatting e.g., page numbers.             * @param nChars - the length of the output             * @param just - one of  JUST_LEFT, JUST_CENTRE or JUST_RIGHT             */     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.                 * @param input _ the string to be aligned             * @parm where - the StringBuffer to append it to.             * @param ignore - a FieldPosition (may be null, not used but             * specified by the general contract of Format).             */     public StringBuffer format(         Object obj, StringBuffer where, FieldPosition ignore)  {         String s = (String)obj;         String wanted = s.substring(0, Math.min(s.length( ), maxChars));         // Get the spaces in the right place.          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;     } }

See Also

The alignment of numeric columns is considered in Chapter 5.