Fast way to append blank strings.

Question

I have to generate a single string containing all the data members of a class. For example, if a class definition is

class A    
 {
   private String field1;
   private String field2;
   private String field3;
   ...
   ...
 }

Then I want to generate a string that will contain field1, field2 and field3 in that order. However, the additional thing that I want to do is ensure the following rules -

  field1 is of length 20. If it is less than 20, pad it with blank spaces.
  field2 is of length 10. If it is less than 10, pad it with blank spaces.
  field1 is of length 15. If it is less than 15, pad it with blank spaces.
  ...
  ...

I plan to use a helper class to build this string. I want to use a StringBuilder to get the final string. So I have something like -

  StringBuilder builder = new StringBuilder();

  Helper.addString(field1,20,builder);

Now the implmentation of this addString function is what I am concerned about. This function will be called thousands of times for different classes. So I want to make it as efficient as possible. The question is, what is the most efficient way? Currently, I have the following implementation -

 public static void addString(String field, int totalLengthOfField, StringBuilder builder)
 {
    int lengthOfField = field.length();
    int numberOfBlankSpacesToPutAfterString = totalLengthOfField - lengthOfField;

    if(numberOfBlankSpacesToPutAfterString >=0)
      {
        builder.append(field);
        for(int i=1; i<= numberOfBlankSpacesToPutAfterString; i++)
          {
            builder.append(" "); // append a blank space
          }
      }
    else
      {
        // throw exception - field is longer than the maximum allowed length.
      }
 }

Answer 1

Java has the Formatter class that supports creating strings with width definitions for specific fields, much like sprintf() in C. String.format() also uses a Formatter object internally.

That said, Formatter is not all that fast. You might be better off appending strings manually to a StringBuilder and using a small cache of strings with various number of spaces, to avoid always appending single spaces...

For example, if you know that the padding size will always be less than 20 spaces, you could just create a String[] table with strings that have 0, 1, 2... spaces and completely skip the loop. If there is no such restriction, you could still append blocks of, say, 20 spaces at once until you reach the necessary padding size.

Answer 2

Any reason not to use String.format?

Answer 3

Use the static method

String.format("%"+numberOfBlankSpacesToPutAfterString+"s",string)'

Answer 4

I can see at least one optimization. Change:

 if(numberOfBlankSpacesToPutAfterString >=0)

To:

 if(numberOfBlankSpacesToPutAfterString >0)

That way you never enter the for loop if you have 0 spaces to add. Not a huge deal, but it sounds like every little bit counts.

Second thing: is the builder object needed? You could be using

 if(numberOfBlankSpacesToPutAfterString >0)
  {
    for(int i=1; i<= numberOfBlankSpacesToPutAfterString; i++)
      {
        field +=(" "); // append a blank space
      }
  }

Reading what someone else mentioned, you could speed things up further by adding spacing of powers of 2.

 if(numberspaces > 16)
      {field +="16spaceshere"
      numberspaces -= 16;
      }
 if(numberspaces > 8)...
 if(numberspaces > 4)...

That would turn it into a maximum of 4 operations on field and 4 on numberspacestoadd, 8 total.

Answer 5

Consider to check how apache commons (StringUtils) is implemented, they already have same problems as you are having and they already optimized the method:

public static String rightPad(String str, int size, char padChar) {
    if (str == null) {
        return null;
    }
    int pads = size - str.length();
    if (pads <= 0) {
        return str; // returns original String when possible
    }
    if (pads > PAD_LIMIT) {
        return rightPad(str, size, String.valueOf(padChar));
    }
    return str.concat(repeat(padChar, pads));
}

public static String repeat(String str, int repeat) {
    // Performance tuned for 2.0 (JDK1.4)

    if (str == null) {
        return null;
    }
    if (repeat <= 0) {
        return EMPTY;
    }
    int inputLength = str.length();
    if (repeat == 1 || inputLength == 0) {
        return str;
    }
    if (inputLength == 1 && repeat <= PAD_LIMIT) {
        return repeat(str.charAt(0), repeat);
    }

    int outputLength = inputLength * repeat;
    switch (inputLength) {
        case 1 :
            return repeat(str.charAt(0), repeat);
        case 2 :
            char ch0 = str.charAt(0);
            char ch1 = str.charAt(1);
            char[] output2 = new char[outputLength];
            for (int i = repeat * 2 - 2; i >= 0; i--, i--) {
                output2[i] = ch0;
                output2[i + 1] = ch1;
            }
            return new String(output2);
        default :
            StringBuilder buf = new StringBuilder(outputLength);
            for (int i = 0; i < repeat; i++) {
                buf.append(str);
            }
            return buf.toString();
    }
}

Answer 6

As long as you know the maximum padding with you need (20) it is fairly simple.

private static String spaces = "                    "; // Whatever you need max!

// your code to compute numberOfBlankSpacesToPutAfterString

if(numberOfBlankSpacesToPutAfterString >= 0) {
    builder.append(field);
    builder.append(spaces, 0, numberOfBlankSpacesToPutAfterString);
} else {
    // Report error
}

Answer 7

import  com.google.common.base.Strings

foo = Strings.repeat(" ", 10)