如何格式化基于指定长度的空格？

Question

Trying to create a method in Java formats the string by stretching the content (by putting appropriate number of whitespaces) of a buffer, based on the length. So, based on a particular length given, the first character of the string is in the first index and the last character is located at the actual last index itself.

public static String format(String sentence, int length) {
    if (sentence.length() >= length) {
        return sentence;
    }
    StringBuilder sb = new StringBuilder();

    String[] words = sentence.split("\\s+");

    int usedCharacters = 0;

    for (String word : words) {
        usedCharacters += word.length();
    }

    int emptyCharacters = length - usedCharacters;
    int spaces = emptyCharacters / words.length - 1;

    for (String word : words) {
        sb.append(word);
        for (int i = 0; i <= spaces; i++) {
            sb.append(" ");
        }
    }
    return sb.toString();
}

For this unit test, this works:

@Test
public void isCorrectLength() {
    String value = StringUtils.format("brown clown", 20);
    assert(value.length() == 20);
}

So, here, the maximum buffer size is: 20

Total number of used characters is: 10

Total number of unused characters is: 10

The end result (if you print the String) is:

brown     clown

The "n" in clown is at index 20...

However, there is an edge case with the following test (which causes it to break):

@Test
public void isCorrectLengthWithLongerSentence() {
    String value = StringUtils.format("Love programming Java using Eclipse!", 50);
    assert(value.length() == 50);
}

Buffer size: 50

Total Used Characters: 25 Total Unused Characters: 25

Spaces: 3

Final Length: 48

The end result (if you print the String) is:

Love     programming    Java    using    Eclipse!

Why is the final index 48 instead of 50?

The exclamation point "!" after "Eclipse", should be at 50 instead of 48...

Am suspecting that its due to my spaces calculation being off.

Thanks for taking the time to read this.

Answer 1

For this test

@Test
public void isCorrectLength() {
    String value = StringUtils.format("Went to the slope and snowboarded for hours., 103);
    assert(value.length() == 103);
}

This happens because you are dividing:

int spaces = emptyCharacters / words.length - 1;

This results in (66 / 8) - 1) = 7.25, and then you have a for loop, which does not account for the extra .25 This means you will not fill the desired buffer length.

Also, since you declared it as int, you will not get the extra 0.25, so you should change it to double , and cast the others as double as well.

You then can count the words and check if the extra 0.25 multiplied by the counter reaches 1, you add a space, and reset the counter.

    double spaces = (double)emptyCharacters / (double)words.length - 1.0;

    double extraSpace = spaces % 1;
    double counter = 0;
    for (String word : words) {
        counter++;

        sb.append(word);
        for (int i = 0; i <= spaces; i++) {
            sb.append(" ");
        }

        if ((counter * extraSpace) >= 1) {
             sb.append(" "); // This is the extra space.
             counter = 0;
        }
    }

Something like this. The problem resides in that not all words can have the same number of spaces. Some will have more, some will have less, in order to accommodate for the static buffer length. This is also a special case, because the remainder is 0.25, and will produce exactly 2 spaces, You still need to accommodate for the remainder of the remainder. (In case it does not reach 1 and you still have one more word.)

The following code makes up for this.

    double spaces = (double)emptyCharacters / (double)words.length - 1.0;

    double extraSpace = spaces % 1;
    double counter = 0;
    int wordIndex = 0;
    for (String word : words) {
        counter++;
        wordIndex++;

        sb.append(word);
        for (int i = 0; i <= spaces; i++) {
            sb.append(" ");
        }

        if ((counter * extraSpace) >= 1) {
             sb.append(" "); // This is the extra space.
             counter = 0;
        }

        if ((wordIndex == words.length - 1) && (counter * extraSpace) > 0) {
            sb.append(" "); // This accounts for remainder.
        }
    }

This is not, in any way, elegant, but it works, for the previous test, and for example, for this new one:

@Test
public void isCorrectLength() {
    String value = StringUtils.format("We went to the giant slope and snowboarded for hours., 103);
    assert(value.length() == 103);
}

Answer 2

1. Split the string into words, based on white space.
2. Find the number of total spaces needed to pad the words to the desired string length (total length of string - words length).
3. Find the number of "space blocks" to be placed between words (number of words - 1).
4. Build the "space blocks" by iteratively adding spaces to each space block until we run out of spaces (see step 2).

5. Re-assemble the sentence by placing word, space block, word, etc.

   private static String formatString(String sentence, int length) { // parse words by white space String[] words = sentence.split("\\s+");

    // calc the char length of all words int wordsLength = 0; for (String w: words) { wordsLength += w.length(); } // find the number of space blocks and initialize them int spacesLength = length - wordsLength; String[] spaceBlocks = new String[words.length - 1]; Arrays.fill(spaceBlocks, ""); // distribute spaces as evenly as possible between space blocks int spacesLeft = spacesLength; int k = 0; while (spacesLeft > 0) { spaceBlocks[k++] += " "; if (k == spaceBlocks.length) { k = 0; } spacesLeft--; } // assemble the buffer: for each word, print the word, then a spaces block, and so on StringBuilder b = new StringBuilder(); for (int i = 0; i < words.length; i++) { b.append(words[i]); if (i < spaceBlocks.length) { b.append(spaceBlocks[i]); } } return b.toString(); 

   }

   public static void main(String[] args) { String s; String t;

    s = "Hello, spaces."; t = formatString(s, 50); System.out.println(String.format("\\"%s\\" (length=%d)", t, t.length())); s = "Hello, spaces."; t = formatString(s, 51); System.out.println(String.format("\\"%s\\" (length=%d)", t, t.length())); s = "Good day, spaces."; t = formatString(s, 52); System.out.println(String.format("\\"%s\\" (length=%d)", t, t.length())); s = "The quick brown fox."; t = formatString(s, 53); System.out.println(String.format("\\"%s\\" (length=%d)", t, t.length())); s = "Ask not what your country can do for you."; t = formatString(s, 54); System.out.println(String.format("\\"%s\\" (length=%d)", t, t.length())); s = "Ask not what your country can do for you, Bob."; t = formatString(s, 55); System.out.println(String.format("\\"%s\\" (length=%d)", t, t.length())); 

   }

Output,

"Hello,                                     spaces." (length=50)
"Hello,                                      spaces." (length=51)
"Good                   day,                  spaces." (length=52)
"The            quick            brown            fox." (length=53)
"Ask   not   what   your   country   can  do  for  you." (length=54)
"Ask  not  what  your  country  can  do  for  you,  Bob." (length=55)

In the cases where the spaces don't result in all even-length space blocks, the code favors placing them in the earlier-occurring space blocks.

Note for clarity I did not code edge cases (one-word strings, zero-length output, null inputs, words don't fit in buffer, etc). That's left as an exercise for the reader.