How does this code add commas before every three digits?

Question

Help me to understand how this code works. It essentially adds commas into a string of numbers. So if the user types a 1 to 3 digit number it is unchanged. For a four digit number ,it adds a comma so

• 1111 becomes 1,111
• 11111 becomes 11,111
• 111111111 becomes 11,111,111

and so on. Here's the code:

private String addCommasToNumericString (String digits)
{
    String result = "";
    int len = digits.length();
    int nDigits = 0;

    for (int i = len - 1; i >= 0; i--)                      
    {
        result = digits.charAt(i) + result;                 
        nDigits++;                                          
        if (((nDigits % 3) == 0) && (i > 0))                
        {
            result = "," + result;
        }
    }
    return (result);
}

I´ll explain what I do understand of it

The for loop basically counts the length of the number the user has written to avoid putting a comma before the first number (e.g. ,1111). And while i is less than the length of the string it subtracts 1.

result returns the char at position i, since it counts downwards it returns the chars "opposite" from right towards left.

nDigits adds 1 from to the initial value of 0 on each iteration through the loop.

I guess now is where I am having trouble seeing exactly what is going on: if ("nDigits % 3) == 0.

So for the two first iteration through loop it will not execute the if loop because:

• 1 % 3 = 1
• 2 % 3 = 2
• 3 % 3 = 0

nDigits starts out as 1 because of the nDigits++ code inside the for loop, so how does it put the comma after three digits and not two? And how does it know when there is only 4 or 5 digits to place the comma corretly at position 1 and two (1,111 - 11,111)?

Answer 1

I think the easiest way to explain this is to slow it down to each pass.

The loop starts at the end of the string so if you have the string 12345, then after the first time through the loop result will be "5" and nDigits will be 1.

The next time through, '4' will be added to the front of the result giving you "45" and nDigits will be 2.

The third time through, it adds '3' to the front of result making that "345" and then the if-then triggers and adds a comma to the front. Result is now ",345".

More passes will give you "12,345".

I think what is confusing you is that loop starts at the '5' and not at the '1'. Everything is added to the front of result and not to the end as you would normally expect.

Hope this helps!

Answer 2

The key thing in this method is to count the digits from right to left. If you don't do it that way it won't work.

You can also do the same with String Manipulation instead of char manipulation. Maybe it makes it easier to understand so I'll provide an example.

My solution involves the use of the subString Method and operates in a similar manner to yours. Starting FROM RIGHT TO LEFT, it divides the original String in two substrings and adds a comma in between them every time there is a 3 digits group.

private String addCommas (String digits) {

    String result = digits;

    if (digits.length() <= 3) return digits; // If the original value has 3 digits or  less it returns that value

    for (int i = 0; i < (digits.length() – 1) / 3; i++) {

      int commaPos = digits.length() – 3 – (3 * i); // comma position in each cicle

      result = result.substring(0, commaPos) + "," + result.substring(commaPos);
    }
   return result;
}

Answer 3

The variable result is used for incremental build of the final output, in each iteration one or two chars are concatenated from left (i.e. the string is build from right to left).

• One char is concatenated everytime by running

  result = digits.charAt(i) + result;  
  

  it is the actual digit

• the second char is concatenated in each third iteration by running

  result = "," + result;
  

  it is the order separator

The implementation is not optimal at all, because in Java the string are immutable and result = "," + result; ends up in creating a new object. The StringBuffer or StringBuilder are far more effective for this purpose.