formatNumber change
[nikiroo-utils.git] / src / be / nikiroo / utils / StringUtils.java
index 994522970af119ebd8c929e318df3849c452ad67..954d34113d09650c4b33d5ccd1dbb70f51ed32a1 100644 (file)
@@ -799,11 +799,13 @@ public class StringUtils {
         * Return a display {@link String} for the given value, which can be
         * suffixed with "k" or "M" depending upon the number, if it is big enough.
         * <p>
-        * Example:
+        * <p>
+        * Examples:
         * <ul>
-        * <li><tt>8765</tt> becomes "8k"</li>
-        * <li><tt>998765</tt> becomes "998k"</li>
-        * <li><tt>12987364</tt> becomes "12M"</li>
+        * <li><tt>8 765</tt> becomes "8k"</li>
+        * <li><tt>998 765</tt> becomes "998k"</li>
+        * <li><tt>12 987 364</tt> becomes "12M"</li>
+        * <li><tt>5 534 333 221</tt> becomes "5G"</li>
         * </ul>
         * 
         * @param value
@@ -812,39 +814,135 @@ public class StringUtils {
         * @return the display value
         */
        public static String formatNumber(long value) {
-               return formatNumber(value, true);
+               return formatNumber(value, 0);
        }
 
        /**
         * Return a display {@link String} for the given value, which can be
         * suffixed with "k" or "M" depending upon the number, if it is big enough.
         * <p>
-        * Example:
+        * Examples (assuming decimalPositions = 1):
         * <ul>
-        * <li><tt>8765</tt> becomes "8k"</li>
-        * <li><tt>998765</tt> becomes "998k"</li>
-        * <li><tt>12987364</tt> becomes "12M"</li>
+        * <li><tt>8 765</tt> becomes "8.7k"</li>
+        * <li><tt>998 765</tt> becomes "998.7k"</li>
+        * <li><tt>12 987 364</tt> becomes "12.9M"</li>
+        * <li><tt>5 534 333 221</tt> becomes "5.5G"</li>
         * </ul>
         * 
         * @param value
         *            the value to convert
-        * @param strict
-        *            TRUE if you want any value equals or greater than 1000 to use
-        *            the "k" suffix; FALSE if you want to go a bit higher and only
-        *            use "k" for values equal or greater than 4000
+        * @param decimalPositions
+        *            the number of decimal positions to keep
         * 
         * @return the display value
         */
-       public static String formatNumber(long value, boolean strict) {
-               if (value >= 1000000l) {
-                       return Long.toString(value / 1000000l) + "M";
+       public static String formatNumber(long value, int decimalPositions) {
+               long userValue = value;
+               String suffix = "";
+               long mult = 1;
+
+               if (value >= 1000000000l) {
+                       mult = 1000000000l;
+                       userValue = value / 1000000000l;
+                       suffix = " G";
+               } else if (value >= 1000000l) {
+                       mult = 1000000l;
+                       userValue = value / 1000000l;
+                       suffix = " M";
+               } else if (value >= 1000l) {
+                       mult = 1000l;
+                       userValue = value / 1000l;
+                       suffix = " k";
+               }
+
+               String deci = "";
+               if (decimalPositions > 0) {
+                       deci = Long.toString(value % mult);
+                       int size = Long.toString(mult).length() - 1;
+                       while (deci.length() < size) {
+                               deci = "0" + deci;
+                       }
+
+                       deci = deci.substring(0, Math.min(decimalPositions, deci.length()));
+                       while (deci.length() < decimalPositions) {
+                               deci += "0";
+                       }
+
+                       deci = "." + deci;
                }
 
-               if ((strict && value >= 1000l) || (!strict && value >= 4000l)) {
-                       return Long.toString(value / 1000l) + "k";
+               return Long.toString(userValue) + deci + suffix;
+       }
+
+       /**
+        * The reverse operation to {@link StringUtils#formatNumber(long)}: it will
+        * read a "display" number that can contain a "M" or "k" suffix and return
+        * the full value.
+        * <p>
+        * Of course, the conversion to and from display form is lossy (example:
+        * <tt>6870</tt> to "6.5k" to <tt>6500</tt>).
+        * 
+        * @param value
+        *            the value in display form with possible "M" and "k" suffixes,
+        *            can be NULL
+        * 
+        * @return the value as a number, or 0 if not possible to convert
+        */
+       public static long toNumber(String value) {
+               return toNumber(value, 0l);
+       }
+
+       /**
+        * The reverse operation to {@link StringUtils#formatNumber(long)}: it will
+        * read a "display" number that can contain a "M" or "k" suffix and return
+        * the full value.
+        * <p>
+        * Of course, the conversion to and from display form is lossy (example:
+        * <tt>6870</tt> to "6.5k" to <tt>6500</tt>).
+        * 
+        * @param value
+        *            the value in display form with possible "M" and "k" suffixes,
+        *            can be NULL
+        * @param def
+        *            the default value if it is not possible to convert the given
+        *            value to a number
+        * 
+        * @return the value as a number, or 0 if not possible to convert
+        */
+       public static long toNumber(String value, long def) {
+               long count = def;
+               if (value != null) {
+                       value = value.trim().toLowerCase();
+                       try {
+                               long mult = 1;
+                               if (value.endsWith("g")) {
+                                       value = value.substring(0, value.length() - 1).trim();
+                                       mult = 1000000000;
+                               } else if (value.endsWith("m")) {
+                                       value = value.substring(0, value.length() - 1).trim();
+                                       mult = 1000000;
+                               } else if (value.endsWith("k")) {
+                                       value = value.substring(0, value.length() - 1).trim();
+                                       mult = 1000;
+                               }
+
+                               long deci = 0;
+                               if (value.contains(".")) {
+                                       String[] tab = value.split("\\.");
+                                       if (tab.length != 2) {
+                                               throw new NumberFormatException(value);
+                                       }
+                                       double decimal = Double.parseDouble("0."
+                                                       + tab[tab.length - 1]);
+                                       deci = ((long) (mult * decimal));
+                                       value = tab[0];
+                               }
+                               count = mult * Long.parseLong(value) + deci;
+                       } catch (Exception e) {
+                       }
                }
 
-               return Long.toString(value);
+               return count;
        }
 
        /**