Java Aligning Strings

Java Aligning Strings


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


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


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

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

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

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.
/** 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:
 this.just = just;
 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) {
 pad(where, maxChars - wanted.length( ));
 int startPos = where.length( );
 pad(where, (maxChars - wanted.length( ))/2);
 pad(where, (maxChars - wanted.length( ))/2);
 // Adjust for "rounding error"
 pad(where, maxChars - (where.length( ) - startPos));
 case JUST_LEFT:
 pad(where, maxChars - wanted.length( ));
 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;


Post a Comment