src/java.base/share/classes/java/math/BigInteger.java

@@ -3958,10 +3958,23 @@
         toString(this, sb, radix, 0);
 
         return sb.toString();
     }
 
+    private static void padWithZeros(StringBuilder buf, int len, int digits) {
+        if (digits > 0 && len < digits) {
+            int m = digits - len;
+            while (m >= NUM_ZEROS) {
+                buf.append(ZEROS);
+                m -= NUM_ZEROS;
+            }
+            if (m > 0) {
+                buf.append(ZEROS, 0, m);
+            }
+        }
+    }
+
     /**
      * This method is used to perform toString when arguments are small.
      * A negative sign will be prepended if and only if {@code this < 0}.
      * If {@code digits <= 0} no padding (pre-pending with zeros) will be
      * effected.

@@ -3971,10 +3984,11 @@
      * @param digits The minimum number of digits to pad to.
      */
     private void smallToString(int radix, StringBuilder buf, int digits) {
         if (signum == 0) {
             buf.append('0');
+            padWithZeros(buf, 1, digits);
             return;
         }
 
         // Put sign (if any) into result buffer
         if (signum < 0) {

@@ -4004,34 +4018,23 @@
 
         // Get string version of first digit group
         String s = Long.toString(digitGroups[numGroups-1], radix);
 
         // Pad with internal zeros if necessary.
-        if (digits > 0) {
-            int len = s.length() + (numGroups - 1)*digitsPerLong[radix];
-            if (len < digits) {
-                int m = digits - len;
-                while (m >= NUM_ZEROS) {
-                    buf.append(zeros);
-                    m -= NUM_ZEROS;
-                }
-                if (m > 0) {
-                    buf.append(zeros, 0, m);
-                }
-            }
-        }
+        padWithZeros(buf, s.length() + (numGroups - 1)*digitsPerLong[radix],
+            digits);
 
         // Put first digit group into result buffer
         buf.append(s);
 
         // Append remaining digit groups each padded with leading zeros
         for (int i=numGroups-2; i >= 0; i--) {
             // Prepend (any) leading zeros for this digit group
             s = Long.toString(digitGroups[i], radix);
             int numLeadingZeros = digitsPerLong[radix] - s.length();
             if (numLeadingZeros != 0) {
-                buf.append(zeros, 0, numLeadingZeros);
+                buf.append(ZEROS, 0, numLeadingZeros);
             }
             buf.append(s);
         }
     }
 

@@ -4112,15 +4115,15 @@
             powerCache = pc; // volatile write, publish
         }
         return cacheLine[exponent];
     }
 
-    /* Size of zeros string. */
+    /* Size of ZEROS string. */
     private static int NUM_ZEROS = 63;
 
-    /* zero is a string of NUM_ZEROS consecutive zeros. */
-    private static final String zeros = "0".repeat(NUM_ZEROS);
+    /* ZEROS is a string of NUM_ZEROS consecutive zeros. */
+    private static final String ZEROS = "0".repeat(NUM_ZEROS);
 
     /**
      * Returns the decimal String representation of this BigInteger.
      * The digit-to-character mapping provided by
      * {@code Character.forDigit} is used, and a minus sign is